tPj$ ~dZddlmZddlmZddlmZmZmZddlm Z m Z m Z m Z ddl mZmZmZddlmZddlmZdd lmZmZdd lmZe rdd lmZd ZGd de ZGdde dZGdde ZGdde Z dede fdZ!eddGddZ"Gdde Z#Gd d!eZ$defd"Z%d#e&de'd$zfd%Z(d&ed$zded$zfd'Z)d(d)de"fd*Z*d+e"ded$zfd,Z+d+e"d$zde#fd-Z,d+e"d.e'd/ed0ed1e-de.f d2Z/ded3e-de"d$zfd4Z0ded3e-d5e'dd$fd6Z1ded3e-dd$fd7Z2ded3e-d8edd$fd9Z3ded3e-d8ede'fd:Z4y$);a Persistence for the admin-configured periodic model cost map reload schedule stored in ``LiteLLM_Config``. Field ownership is split by writer so concurrent writers never overwrite each other: the schedule endpoints own the ``param_value`` JSON (``interval_hours``), while the reload job and the manual reload endpoints own the dedicated ``last_run_at`` / ``reload_revision`` columns. ``last_run_at`` lives in the row rather than process memory so the Admin UI still reports the last execution after a restart and across pods. ``reload_revision`` is a monotonic counter a manual reload increments; each pod records the revision it last applied and reloads whenever the row's differs, so a request reaches every pod exactly once without any pod clearing it and without comparing clocks. A booting pod starts at revision 0 rather than adopting the published one, because it cannot know whether that request predates the prices it fetched at import. Interval reloads stay per-pod, driven by when that pod's own copy of the data was loaded. )Mapping) dataclass)datetime timedeltatimezone) TYPE_CHECKINGProtocol TypedDictcast) BaseModel ConfigDictValidationError)verbose_proxy_logger) safe_dumps) PrismaClientevict_config_param)ConfigRepository)LiteLLM_Configmodel_cost_map_reload_configceZdZUeed<y)_RevisionIncrement incrementN)__name__ __module__ __qualname__int__annotations__x/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/litellm/proxy/common_utils/periodic_reload_schedule.pyrr)sNrrc<eZdZUeed<eed<eed<eezed<y)_ConfigRowWrite param_name param_value last_run_atreload_revisionN)rrrstrrrrrrrr r"r"-sO---rr"F)totalc"eZdZUeed<eed<y)_ConfigUpsertDatacreateupdateN)rrrr"rrrr r*r*4s  rr*cbeZdZdeeefddfdZdeeefdeddfdZdedeeefde fdZ y ) _ConfigTablewherereturnzLiteLLM_Config | Nonec KywNr)selfr/s r find_uniquez_ConfigTable.find_unique:datarc Kywr2r)r3r/r7s r upsertz_ConfigTable.upsert<r5r6c Kywr2r)r3r7r/s r update_manyz_ConfigTable.update_many>r5r6N) rrrrr'r4r*r9r"rr;rrr r.r.9sRYwsCx'8Y=TYf'#s("3f;LfQaf\o\gc3h>O\TW\rr. prisma_clientr0cHttt|jSr2)r r.rtable)r<s r _config_tabler?As  .}=CC DDrT)frozenslotscDeZdZUdZedzed<dZeed<dZedzed<y)ReloadScheduleNinterval_hoursrr&r%) rrrrDrrr&r%rrrr rCrCEs(!%NC$J%OS#'KD'rrCcHeZdZUeed<edzed<edzed<edzed<y)ReloadScheduleStatus scheduledNrDlast_runnext_run)rrrboolrrr'rrr rFrFLs%O$JDjDjrrFc4eZdZUedZdZedzed<y)_IntervalConfigT)strictNrD)rrrr model_configrDrrrrr rLrLSsT*L!%NC$J%rrLcHtjtjSr2)rnowrutcrrr utc_nowrRYs << %%rr$Nc t|trtj|jStj |jS#t $rYywxYw)a``param_value`` is written as serialized JSON, and a raw row read can hand it back either decoded or still as a string depending on the driver, so accept both rather than reading a string as no schedule at all. Mirrors ``ConfigRepository.get_param``N) isinstancer'rLmodel_validate_jsonrDmodel_validater)r$s r _parse_interval_hoursrW]sQ k3 '"66{CRR R--k:III s.AA AAvaluecd|y|j|S|jtjS)N)tzinfo)rZreplacerrQ)rXs r _as_utcr\is- }LL,5T%--x||-2TTrrowrctt|jt|jxsdt |j S)Nr)rDr&r%)rCrWr$rr&r\r%)r]s r parse_reload_scheduler_os: ,S__=C//415COO, rschedulecz|j |jy|jt|jzS)N)hours)rDr%r)r`s r next_run_atrcws8&(*>*>*F   )(2I2I"J JJrc|dddddSt|}|jdu|j|j|jjnd||jdSddS)NF)rGrDrHrI)rcrDr% isoformat)r`rIs r reload_schedule_statusrf}s"dZ^__8$H,,D8"118@8L8L8XH((224^b,4,@H&&(  GK  rpod_applied_revisionpod_data_loaded_at current_time descriptionc@|j|k7rtjd|y|jy|jtjd|y||z j dz }||jkrytjd|||jy)a Whether this pod should reload now. A revision it has not applied means a manual reload it has not served. A pod starts at revision 0, so it serves any request published before it booted; that costs one redundant fetch per boot and is what keeps a request from being marked applied against data fetched before it. Interval reloads compare against this pod's own data, and a schedule that has never run anywhere fires immediately rather than one interval later z,%s reload triggered by manual reload requestTFz,%s reload triggered - schedule has never runizL%s reload triggered by interval. Hours since data loaded: %.2f, Interval: %s)r&rinforDr% total_seconds)r`rgrhrirjhours_since_data_loadeds r pod_reload_is_dueros #77!!"PR]^&#!!"PR]^+.@@OOQTXX!8!88V  rr#ctKt|jd|id{}|yt|S7w)Nr#)r/)r?r4r_)r<r#r]s r read_reload_schedulerqs?m,88 j?Y8Z ZC {  %% [s !868rDcKtd|i}t|jd|i||dd|idd{t|d{y77w)zRAdmin-owned write: replaces ``param_value`` without touching the job-owned columnsrDr#)r#r$r$r+r,r/r7N)rr?r9r)r<r#rDr$s r write_reload_intervalrusp.?@K  & - -Z(%/ L$k2  .  Z ((()s!7AAA A AAcKt|jdtddiid|id{t|d{y77w)aAdmin-owned write: drops the schedule but keeps the row, because the revision counter identifies a request rather than ordering one and so can never reuse a number. Deleting the row restarts it, and a reissued revision matches what pods already applied, so their next manual reload is silently skipped. The interval is nulled inside the JSON rather than by nulling the column, which prisma rejects for a ``Json?`` fieldr$rDNr#r7r/)r?r;rr)r<r#s r clear_reload_intervalrxs`  & 2 2Z)94(@A BZ( 3  Z ((( )s!/AA AA A Aran_atcKt|jd|id|id{t|d{y77w)zJob-owned write after this pod reloaded: stamps the shared last run only if the row still exists, so a schedule deleted mid-poll is not resurrectedr%r#rwN)r?r;r)r<r#rys r record_reload_runr{sU  & 2 2V $Z( 3  Z ((( )s$A?AAAAcKt|jd|i||dd|ddiddd{}t|d{t|jS7,7w) af After a manual in-pod reload: stamp the shared last run and bump the revision every other pod compares against. The increment is atomic, so concurrent requests each publish a distinct revision instead of overwriting one another. Returns the published revision so the serving pod can adopt it rather than reloading again on its next poll r#)r#r%r&r)r%r&rsrtN)r?r9rrr&)r<r#ryr]s r record_manual_reloadr~sxm,33Z(%/[\]&,+qAQR 4 C Z ((( s"" ## )s!.A!AA!AA!A!)5__doc__collections.abcr dataclassesrrrrtypingrr r r pydanticr r rlitellm._loggingr*litellm.litellm_core_utils.safe_json_dumpsrlitellm.proxy.utilsrr&litellm.repositories.config_repositoryr prisma.modelsr MODEL_COST_MAP_RELOAD_PARAM_NAMErr"r*r.r?rCrFrLrRobjectrrWr\r_rcrfr'rJrorqrurxr{r~rrr rs1"$!22<;1A@C,#A .iu.  ]8]EE,E $d#(($( 9&i& && v #* U8d?Ux$U /NK.KX_K ^d%: ?S !!!! !  !  ! !H&l&&P^aePe& )| ) )^a )fj ) )| ) )QU ))<)S)RZ)_c)$l$$U]$be$r