tPj jdZddlZddlZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z m Z ddl mZmZmZddlmZddlmZmZmZmZmZmZmZddlmZd ZGd d eZGd d eZGddeZ GddZ!GddZ"GddZ#GddZ$ dde%e&zdzde%fdZ'y)z This file contains the PrismaWrapper class, which wraps the Prisma client and keeps the database token (AWS RDS IAM or Microsoft Entra ID) fresh. N)Callable)datetime timedelta)AnyFinalProtocol)verbose_proxy_logger)DEFAULT_POSTGRES_PORTDatabaseTokenAuth IAMEndpointRdsIamTokenAuthmint_database_tokenparse_database_token_expirationparse_iam_endpoint_from_url) str_to_bool)r PrismaManager PrismaWrapperrceZdZUeed<y)_PrismaProcesspidN)__name__ __module__ __qualname__object__annotations__c/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/litellm/proxy/db/prisma_client.pyrr&s KrrcleZdZedefdZdededzdefdZdedefdZ deddfdZ deddfd Z y) _PrismaEnginereturncyNrselfs rprocessz_PrismaEngine.process+s),rcontenttx_idNc Kywr#rr%r'r(s rqueryz_PrismaEngine.query.c Kywr#r)r%r's rstart_transactionz_PrismaEngine.start_transaction0r,r-c Kywr#rr%r(s rcommit_transactionz _PrismaEngine.commit_transaction2r,r-c Kywr#rr1s rrollback_transactionz"_PrismaEngine.rollback_transaction4r,r-) rrrpropertyrr&strrr+r/r2r4rrrr r *sR ,,,L3L#*LLB#B#B?c?d?AAArr c.eZdZUeed<edefdZy) _PrismaClient_Prisma__enginer!cyr#rr$s r_enginez_PrismaClient._engine:s(+rN)rrrr rr5r;rrrr8r87s"" +++rr8cLeZdZd dZd dZd dZdeddfdZdeddfdZd d Z y) _PrismaDrainTrackerr!Ncd|_t|_tj|_|j j yNr)_active_operations frozenset _transactionsasyncioEvent_drainedsetr$s r__init__z_PrismaDrainTracker.__init__?s1"#-6[   rc|jdk(r|jj|xjdz c_y)Nr)r@rEclearr$s rbegin_operationz#_PrismaDrainTracker.begin_operationEs1  " "a ' MM   ! 1$rc|xjdzc_|jdk(r|jjyy)NrIr)r@rErFr$s r end_operationz!_PrismaDrainTracker.end_operationJs6 1$  " "a ' MM    (rtransaction_idcF|jj|f|_yr#)rBunionr%rNs rtransaction_startedz'_PrismaDrainTracker.transaction_startedOs!//55~6GHrc||jvry|jj|f|_|jyr#)rB differencerMrQs rtransaction_finishedz(_PrismaDrainTracker.transaction_finishedRs; !3!3 3 !//::N;LM rcTK|jjd{y7wr#)rEwaitr$s rwait_until_drainedz&_PrismaDrainTracker.wait_until_drainedXsmm  """s (&(r!N) rrrrGrKrMr6rRrUrXrrrr=r=>s? %  I#I$I34 #rr=ceZdZdededdfdZedefdZde de fdZ d e d e dzde fd Z d e de fd Z d e ddfd Zd e ddfdZy)_TrackedPrismaEngineenginetrackerr!Nc ||_||_yr#)r;r])r%r\r]s rrGz_TrackedPrismaEngine.__init__]s  rc.|jjSr#)r;r&r$s rr&z_TrackedPrismaEngine.processas||###rnamec.t|j|Sr#)getattrr;)r%r`s r __getattr__z _TrackedPrismaEngine.__getattr__est||T**rr'r(cK|jj |jj||d{|jj S7#|jj wxYww)N)r()r]rKr;r+rMr*s rr+z_TrackedPrismaEngine.queryhs\ $$& )++G5+AA LL & & (B LL & & (s,A> AAAA>AA;;A>c6K|jj |jj|d{}|jj||S7!#tt j f$r|jjwxYww)N)r') r]rKr;r/ ExceptionrCCancelledErrorrMrR)r%r'rNs rr/z&_TrackedPrismaEngine.start_transactionos $$& *.,,*H*HQX*H*Y$YN ((8 %Z7112  LL & & (  s,BA!AA!BA!!5BBcjK|jj |jj|d{|jj |jj |y7:#|jj |jj |wxYwwr#)r]rKr;r2rMrUr1s rr2z'_TrackedPrismaEngine.commit_transactionys} $$& 5,,11%8 8 8 LL & & ( LL - -e 4 9 LL & & ( LL - -e 4,B3A9A7A96B37A997B00B3cjK|jj |jj|d{|jj |jj |y7:#|jj |jj |wxYwwr#)r]rKr;r4rMrUr1s rr4z)_TrackedPrismaEngine.rollback_transactions} $$& 5,,33E: : : LL & & ( LL - -e 4 ; LL & & ( LL - -e 4ri)rrrr r=rGr5rr&r6rrcr+r/r2r4rrrr[r[\s}7Jt$$$+++)3)#*))##5c5d5555rr[ceZdZdZdZdZdZdZ dAddddd d d ed e d e dzde de dzde de fdZ ede dzfdZede fdZede fdZededefdZedededdfdZdededzfdZdBdedzdefdZdededzddfdZdededzddfd Zd!ej<dddfd"ZdBd#ee zdzddfd$Z!ededdfd%Z"d&e dzde dzfd'Z#d(e dzde$dzfd)Z%de&fd*Z'd+e dzde fd,Z(de dzfd-Z)ede fd.Z*edefd/Z+dCd0Z,d1e&ddfd2Z- dBdd3d4e d5edzd6edzde fd7Z. dBdd3d4e d5edzd6edzde fd8Z/d4e ddfd9Z0dCd:Z1dCd;Z2dCd<Z3dCd=Z4d+e dzde fd>Z5d?e fd@Z6y)Dra/ Wrapper around Prisma client that handles token-based database authentication. When a token strategy is active (AWS RDS IAM or Microsoft Entra ID), this wrapper: 1. Proactively refreshes the token before it expires (background task) 2. Falls back to synchronous refresh if a token is found expired 3. Uses proper locking to prevent race conditions during reconnection RDS IAM tokens are valid for 15 minutes and Entra tokens for about an hour. This wrapper refreshes 3 minutes before whatever expiry the live token carries. iXZFN DATABASE_URL) token_authdb_url_env_var iam_endpointrecreate_uses_datasource log_prefixoriginal_prismaiam_token_db_authrqrrrsrtrucX||n |r tnd|_||_||_||_||_|r|dnd|_d|_tj|_ d|_ |j||_ t|_t!|_d|_d|_y)N rpr)r _token_auth_original_prisma_db_url_env_var _iam_endpoint_recreate_uses_datasource _log_prefix_token_refresh_taskrCLock_reconnection_lock_last_refresh_time_instrument_prisma_client_active_drain_trackerrA_retirement_tasksrF_expected_engine_deaths_engine_generationon_engine_replaced)r%rvrwrqrrrsrtrus rrGzPrismaWrapper.__init__s*4)?:[loFWrv / .))A& 0:j\+r9= "),,.37%)%C%CO%T"@I 25$'(=Arr!c|jS)z>The active database token strategy, or None for password auth.rzr$s rrqzPrismaWrapper.token_authsrcJ|j|jjSdS)z3Human name of the active token kind, for log lines.zdatabase token)rzlabelr$s r token_labelzPrismaWrapper.token_labels'*.)9)9)Et%%[K[[rc|jduS)zWhether any token strategy is active. Read-only: the kind of token is chosen once, by injection, so there is no way to flip this back on and silently get AWS RDS on an Azure deployment. Nrr$s rrwzPrismaWrapper.iam_token_db_authst++r prisma_clientc|jSr#)r;)rs r _read_enginezPrismaWrapper._read_engines$$$rr\c||_yr#)r9)rr\s r _write_enginezPrismaWrapper._write_engines (. %rcddlm} |j|}t |t r |j St}|j|t |||S#t|f$rYywxYw)NrClientNotConnectedError) prisma.errorsrrAttributeError isinstancer[r]r=r)r%rrr\r]s rrz'PrismaWrapper._instrument_prisma_clientsp9  --m> !,. =*>vw*OP  78  sA A+*A+cddlm} | |jn|}|j|jj }t |tr|S y#t|tf$rYywxYw)aGet the PID of the current Prisma engine subprocess, or 0 if unavailable. Must never raise: it runs inside the reconnect path, where the client may be in any broken state. Prisma's ``_engine`` is a property that raises ``ClientNotConnectedError`` on a disconnected client; if that escaped here, ``recreate_prisma_client`` would fail before it could build a replacement client and the reconnect loop could never recover. rr) rrr{rr&rrintr TypeError)r%rr target_prismars r_get_engine_pidzPrismaWrapper._get_engine_pidss : P!Q))$*C*CDrrcF|jj|f|_yr#)rrT)r%rs rrz"PrismaWrapper._retirement_finished-s!%!7!7!B!BOCU!VrrcK|#|jjd{n#|jj|d{|j|j|_y7I7'wr#)r{connectrr)r%rs rrzPrismaWrapper.connect0s_ ?''//1 1 1''//8 8 8%)%C%CDDYDY%Z" 2 8s! A0A,#A0A.&A0.A0cK|dkry tj|tjtjd|tjdd{ tj|ttdtjtjd|y#tt t f$rYywxYw7i#tt t f$rYywxYww)uForce-kill the engine subprocess to prevent DB connection pool leaks. Called on every reconnect (in `recreate_prisma_client`) to retire the old query-engine subprocess without invoking prisma-client-py's synchronous `disconnect()` — which blocks the asyncio event loop on `subprocess.Popen.wait()` for 30-120+ seconds when the engine is stuck on TCP close. Sends SIGTERM for graceful shutdown, waits briefly, then SIGKILL as a backstop. rNz "LL11&9F||++FOO<<  sAA A&%A&tokencL| |jyt|j|S)z Parse the token to extract its expiration time. Returns the datetime when the token expires, or None if parsing fails. N)rzr)r%rs r_parse_token_expirationz%PrismaWrapper._parse_token_expirationns* =D,,4.t/?/?GGrctj|j}|j|}|j |}|,t j d|j|jS|t|jz }tj}||z j}t|j|S)a Calculate exactly how many seconds until we need to refresh the token. Uses precise timing: sleeps until (token_expiration - buffer_seconds). For a 15-minute (900s) token with 180s buffer, this returns ~720s (12 min). Returns: Number of seconds to sleep before the next refresh, never less than TOKEN_REFRESH_MIN_SLEEP_SECONDS so a token whose expiry never advances cannot spin the loop. Returns FALLBACK_REFRESH_INTERVAL_SECONDS if parsing fails. z@Could not parse token expiration, using fallback interval of %ss)seconds)rgetenvr|rrr debug!FALLBACK_REFRESH_INTERVAL_SECONDSrTOKEN_REFRESH_BUFFER_SECONDSrutcnow total_secondsmaxTOKEN_REFRESH_MIN_SLEEP_SECONDS)r%rrexpiration_time refresh_atnowseconds_until_refreshs r _calculate_seconds_until_refreshz.PrismaWrapper._calculate_seconds_until_refreshxs $"6"6766v>!%!=!=e!D  " & &R66 99 9,i@a@a.bb __&(2S(8'G'G'I 4779NOOr token_urlc|y|j|}|j|}|tjdyt j |kDS)z/Check if the token in the given URL is expired.Tz5Could not parse token expiration, treating as expired)rrr rrr)r%rrrs ris_token_expiredzPrismaWrapper.is_token_expiredsU  66yA!%!=!=e!D  " & &'^ _ ?22rc|j}|y|j |jn|j}|jt ||}|t j |j<|S)abMint a fresh database token and update the configured DB URL env var. When the wrapper was constructed with an explicit `iam_endpoint` (typical for a reader wrapper whose host/port/user came from a parsed URL), use that. Otherwise fall back to the DATABASE_HOST/PORT/USER/ NAME/SCHEMA env vars (writer behavior). N)rzr}_endpoint_from_env build_urlrrenvironr|)r%authendpointrs rget_rds_iam_tokenzPrismaWrapper.get_rds_iam_tokensj&& <040B0B0N$,,TXTkTkTm **+>tX+NO+1 4''( rc ttjd}tjd}tjd}|r|r|s9tdd|fd|fd|ffD}tddj |dt |tjdt ||tjd  S) N DATABASE_HOST DATABASE_USER DATABASE_NAMEc3*K|] \}}|s| ywr#r).0envvalues r z3PrismaWrapper._endpoint_from_env..s#C#szCannot mint a database token: z, zX unset. Set them so the connection URL can be reassembled around a freshly minted token. DATABASE_PORTDATABASE_SCHEMA)hostportuserr`schema)rrtuple RuntimeErrorjoinr r )rrr`missings rrz PrismaWrapper._endpoint_from_envsii0ii0ii04t"#$3T#:_d'>'E'E'G  ""4#=#=#?Y Y Y##   s:!A-(A A AA-AA*'A-)A**A-)expected_generation new_db_url http_clientrcK|j4d{|j|||d{cdddd{S7177 #1d{7swYyxYww)u{Disconnect and reconnect the Prisma client with a new database URL. Kills the old engine subprocess directly (SIGTERM → SIGKILL) rather than calling `disconnect()`. prisma-client-py's `disconnect()` calls a synchronous `subprocess.Popen.wait()` that can freeze the asyncio event loop for 30-120+ seconds when the engine is stuck on TCP close, breaking `/health/liveliness` and causing Kubernetes pod restarts. The writer wrapper relies on Prisma re-reading `DATABASE_URL` from env; the reader wrapper opts into `recreate_uses_datasource=True` so the new URL is passed explicitly via `datasource={"url": ...}` (Prisma does not auto-read alternate env vars like DATABASE_URL_READ_REPLICA). Serializes all recreations through `self._reconnection_lock` so the IAM-refresh path and the engine-death/transport-error reconnect paths cannot recreate concurrently (issue #29176). `expected_generation`, if given, is an optimistic-lock token: when it no longer matches `self._engine_generation` once the lock is held, another path already replaced the engine, so this call is a no-op and returns ``False``. Returns: bool: ``True`` if the client was actually recreated, ``False`` if the recreate was skipped because the engine generation moved on. N)rr)r_recreate_prisma_client_locked)r%rrrs rrecreate_prisma_clientz$PrismaWrapper.recreate_prisma_clientsg>**  <<'$7=       sRA AA A AA  A A A A  A  AA AA cKddlm}|<||jk7r-tjd|j |j|y|j }|dkDrft|jdk\r|jj|jj||j|d{i}|||d<|jrd|i|d <|d i||_ |jjd{|j|j|_|xjd z c_|j"|j#y 77Xw) uCore recreate logic. Caller MUST hold `self._reconnection_lock`. Split out so callers that already hold the lock (e.g. `_safe_refresh_token`, which double-checks token freshness under the lock) don't re-acquire it — `asyncio.Lock` is not reentrant. rPrismaNzZ%sSkipping Prisma client recreate: engine already replaced (generation %s != expected %s).F@httpurl datasourcerITr)prismarrr inforrlenrrJaddrr~r{rrrr)r%rrrrold_engine_pidkwargss rrz,PrismaWrapper._recreate_prisma_client_lockedsU "  */BdF]F]/] % %l  ''#    $ 4 4 6 A 4//0B6,,224  ( ( , ,^ <++N; ; ;(*  "(F6N  ) )$):#6F< & 0 0##++---%)%C%CDDYDY%Z" 1$  " " .  # # %' < .s&B;E#=E>A E#E! AE#!E#cKddlm}ddlm}|jr||}||}n|}|j }|j |}|j}||j|} |jd{|j|} |dkDrMt|jdk\r|jj!|jj#|||_| |_|xj$dz c_|j&|j'|j||y7#ttjf$r#|j|j |dwxYww)Nrr)DatasourceOverride)r)rrrI)r r prisma.typesrr~r{rrrrrfrCrgrr rrJr rr) r%rrrrreplacement_prisma old_prismar old_drain_trackerreplacement_drain_trackers r/_replace_prisma_client_for_token_refresh_lockedz=PrismaWrapper._replace_prisma_client_for_token_refresh_lockedXsf "3  ) ) 2z BJ!':!> !'  11 $ 4 4Z @ 66  $ $ > >z J  $,,. . .,0+I+IJ\+]! A 4//0B6,,224  ( ( , ,^ < 2%>" 1$  " " .  # # % ((9JK% /7112   , ,T-A-ABT-UW[ \  s1A/F2ED?E B5F?E>T(-Z 8J37OyZ"-- 666%))4$$$$ ..000%71)) $))1$$$$  $**H$$$$:: !--(N(NOOO--P s8GA&C.!C*"AC.$C,%C.)G*C.,C..>F>,G.F>67F9."FFFF9F1*F9+G0F11F94G9F>>GcK|j4d{|jtj|jr=t j d|j|j dddd{ytj|j}|j}|r_ |j|d{t!j"|_t j&d|j|jn+t j(d|j|jdddd{y7<77#ttjf$rL|+tjj|jd|tj|j<wxYw7t#1d{7swYyxYww)z Refresh the database token with proper locking to prevent race conditions. Uses an asyncio lock to ensure only one refresh operation happens at a time, preventing multiple concurrent reconnection attempts. Nz-%s%s still fresh; skipping redundant refresh.z%s%s refreshed successfully.z4%sFailed to generate new %s during proactive refresh)r_token_refresh_not_neededrrr|r rrrrrrfrCrgrpoprrrr r )r%previous_db_urlrs rrz!PrismaWrapper._safe_refresh_tokens**$ $  --bii8L8L.MN$**C$$$$ $ $ $ &(YYt/C/C%DO $ 6 6 8JNNzZZZ+3//*;'$))2$$$$ %**J$$$$A$ $ $ $ $[!7#9#9:&. t';';TBG1G5E E EA0G> G F> GGEA%F;;G>GGG GGc|j|}|j|}|y|tjz j }||j kDS)uTrue iff the token in ``token_url`` has more than the refresh buffer of runway left, so a refresh would be redundant. Used to coalesce stacked refresh triggers. Deliberately mirrors the proactive loop's schedule (refresh at ``expiration - buffer``): a token with exactly ``buffer`` seconds left is NOT considered fresh, so the legitimate proactive refresh still fires. Unparseable tokens return ``False`` (refresh) — skipping them would mean never refreshing. F)rrrrrr)r%rrr seconds_lefts rr$z'PrismaWrapper._token_refresh_not_neededsX66yA!%!=!=e!D  ".1BBQQS d????rr`ct|j|}|jrEtj|j }|j |r tj}|Ltjd|j|j|j|j|Stjd|j|j|j!}|r\tj"|j%|t|j|}tj&d|j|St)d|j|S#t$rd}YwxYw)u Proxy attribute access to the underlying Prisma client. If IAM token auth is enabled and the token is found expired here, the proactive refresh task has missed its window. Behavior depends on whether we're called from inside a running event loop: - Inside the loop (typical: from a coroutine): schedule a refresh as a background task and return the (stale) attribute. The caller's await will likely fail with a connection error and be retried by upper layers (`call_with_db_reconnect_retry`); by that time the refresh has either completed or escalated to the proactive loop's error path. We CANNOT block here — `run_coroutine_threadsafe(...)` + `future.result()` from inside the same loop deadlocks the loop (loop thread is blocked, scheduled coroutine never runs, 30s timeout). - No running loop (sync caller, mostly tests): run the refresh in a fresh loop and re-fetch the attribute. Nz%s%s expired in __getattr__ - proactive refresh may have failed. Scheduling async refresh; the current request may fail and be retried with the fresh token.zk%s%s expired in __getattr__ - proactive refresh may have failed. Triggering synchronous fallback refresh...z2%sSynchronous token refresh completed successfullyzFailed to get )rbr{rwrrr|rrCget_running_looprr rrrrrrrunrr  ValueError)r%r` original_attrr running_looprs rrczPrismaWrapper.__getattr__!se(  5 5t<  ! !IId&:&:;F$$V,(#*#;#;#=L +(00P(((( !,,T-E-E-GH(%)00V((((  )-(>(>(@J! D$?$? $KL(/0E0Et(L ,11P ,,)>$:J:J9K)LMME$(#'L(sE++ E:9E:)Fr#rY)7rrr__doc__rrrrrboolr r6r rGr5rqrrw staticmethodr8r rrr=rrrrrrCTaskrrrrrrrfloatrrrrrrrrrrrrrrr$rcrrrrrs $' ),% ')#.0+ #(3B 04,+/).3B3B 3B &, 3B  3B"D(3B#'3B3Bj -4  \S\\,4,,%M%m%%/]/M/d// } I\_cIc ]T-AS(-S-CVY]C]-bf- EsE=PSW=WE\`EWGLL4FW4W[S9_t%;[t[Btd *HS4ZHHtOH#P%#PJ 3#* 3 33:"   2'3''SW(#'$ +/ $$4Z$ !4Z $  $R#'9 +/ 994Z9 !4Z 9  9v%L%L %LN . *6p+Z@3:@$@"??rrcfeZdZedefdZed dZed dZed dededefdZ y) rr!ctjjt}tjj tjj |}|S)z(Get the path to the migrations directory)rpathabspath__file__dirname)r7dnames r_get_prisma_dirzPrismaManager._get_prisma_dirds:2wwrwww'?@ rNcP ddlm}|jy#t$rYywxYw)z `prisma db push` bypasses litellm-proxy-extras, so the opt-in REPLICA IDENTITY FULL step has to be driven from here too. litellm-proxy-extras is an optional install, so this is a no-op when it is absent. rProxyExtrasDBManagerN)litellm_proxy_extras.utilsr> ImportError(apply_replica_identity_full_if_requestedr=s r)_apply_replica_identity_full_if_requestedz7PrismaManager._apply_replica_identity_full_if_requestedks,  G EEG   s  %%cj ddlm}m}|j r t |y#t$rYywxYw)z`prisma db push` rewrites a doc-partitioned LiteLLM_SpendLogs primary key back to ("request_id"), which Postgres rejects. Fail fast with guidance instead of retrying into that raw error. No-op when litellm-proxy-extras is absent.r!PARTITIONED_SPEND_LOGS_PUSH_ERRORr>N)r?rEr>r@spend_logs_is_partitionedrrDs r _raise_if_partitioned_spend_logsz.PrismaManager._raise_if_partitioned_spend_logszs?    9 9 ;@A A <   s & 22 use_migrateuse_v2_resolvercVtdD]}tj}tj }tj | |rE ddlm}tj }|j||tj |cStjtjgdd d tj tj |y y#t$r6}tjd|Yd}~tj |yd}~wwxYw#tj $rEtj"d |d zt%j&t)j*ddYnqtj,$r\}d|z }|dkDrd|dnd}tj"d||t%j&t)j*ddYd}~nd}~wwxYwtj |#tj |wxYw)a Set up the database using either prisma migrate or prisma db push Args: use_migrate: Use `prisma migrate deploy` instead of `db push`. use_v2_resolver: Opt into the v2 migration resolver that avoids the diff-and-force recovery behavior (which caused schema thrashing during rolling deploys). Defaults to False. Returns: bool: True if setup was successful, False otherwise rr=z9LiteLLM: Failed to import proxy extras. Got %sNF)rHrI)r dbpushz--accept-data-lossz--skip-generaterT)rcheckzAttempt %s timed outrIz Retrying... (z attempts left)rpz-The process failed to execute. Details: %s.%s)rangergetcwdrr;chdirr?r>r@r r setup_databaserG subprocessr+rBTimeoutExpiredrtimerrandom randrangeCalledProcessError) rHrIattempt original_dir prisma_dirr>r" attempts_left retry_msgs rrUzPrismaManager.setup_databasesQx+ 'G99;L&668J HHZ ' '%S "/!>!>!@J/>>$/(7?:&1"BBDNN!#" "KKM&W+ 'XI'%,223tvwx$B&G%4,, 4$,,-CWq[Q 6++Ar2300 4 !G O\_`O`n]O?Kfh $,,-\^_ajk 6++Ar233  4 &&si D2C0&D2AD20 D/9D*D2*D//D22AG7H G7AG2-H2G77HH(rY)FF) rrrr1r6r;rBrGr0rUrrrrrcsqS  H H B B:D:4:TX::rrdisable_updatesr!c|tjdd}t|tr t |}t | S)ao Determines if Prisma Schema updates should be applied during startup. Args: disable_updates: Controls whether schema updates are disabled. Accepts boolean or string ('true'/'false'). Defaults to checking DISABLE_SCHEMA_UPDATE env var. Returns: bool: True if schema updates should be applied, False if updates are disabled. Examples: >>> should_update_prisma_schema() # Checks DISABLE_SCHEMA_UPDATE env var >>> should_update_prisma_schema(True) # Explicitly disable updates >>> should_update_prisma_schema("false") # Enable updates using string DISABLE_SCHEMA_UPDATEfalse)rrrr6rr0)ras rshould_update_prisma_schemares=$))$;WE/3'%o6O$ $$rr#)(r/rCrrYrrVrXr urllib.parsecollections.abcrrrtypingrrrlitellm._loggingr litellm.proxy.db.token_authr r r r rrrlitellm.secret_managers.mainr__all__rr r8r=r[rrr0r6rerrrrms   $(''15 X BH B,H,##<+5+5\V V rbbL*.%CZ$&% %r