h)]%SSKJr SSKrSSKrSSKrSSKJr SSKJrJ r SSK J r SSK J r SSKJr SSKJr SS KJrJrJrJr SS KJr SSKrSS KJr SS KJr S SKJr S SKJr S SK J!r! S SK"J#r#J$r$ \RJS:aSSKJ&r& \(aSSK'J(r( \)\\\)\S44r*\"S5r+\"S5r,Sr-"SS\.\+\,45r/\\*S4r0\(a"SS\\+\,45r1O "SS\5r1\ "S SS!9r2S"\3S '"S#S$\Rh5r5S:S%jr6S;SS*jrS+jr=S?S,jr>S@S-jr?SAS.jr@SBS/jrA\ "S0SS!9rBS1\3S0'\ SCS2j5rCSDS3jrDSES4jrESFS5jrFSGSHS6jjrGSIS7jrHSJS8jrISKS9jrJg)L) annotationsN)ChainMap)IteratorMapping)contextmanager) ContextVar) zip_longest) prepare_class) TYPE_CHECKING AnnotatedAnyTypeVar)WeakValueDictionary)typing_objects)is_union_origin) _typing_extra) get_type_ref)PydanticRecursiveRef) all_identicalis_model_class )_UnionGenericAlias) BaseModel.KTVTdcB^\rSrSr\4SU4SjjjrSU4SjjrSrU=r$) LimitedDict+c.>Xl[TU] 5 gN) size_limitsuper__init__)selfr& __class__s N/var/www/html/env/lib/python3.13/site-packages/pydantic/_internal/_generics.pyr(LimitedDict.__init__,s$ c>[TU]X5 [U5UR:aP[U5UR- URS--n[ UR 55SUnUHnX M gg)Nr)r' __setitem__lenr&listkeys)r)keyvalueexcess to_removekr*s r+r/LimitedDict.__setitem__0sk C' t9t &Y04??b3HHFTYY[)'62IG 'r-)r&)r&intreturnNoner3rr4rr:r;) __name__ __module__ __qualname____firstlineno___LIMITED_DICT_SIZEr(r/__static_attributes__ __classcell__)r*s@r+r"r"+s);r-r"type[BaseModel]c\rSrSrSrg) DeepChainMap?N)r=r>r?r@rBrHr-r+rFrF?s r-rFc6\rSrSrSrSSjrS SjrS SjrSrg) rFDzVariant of ChainMap that allows direct updates to inner scopes. Taken from https://docs.python.org/3/library/collections.html#collections.ChainMap, with some light modifications for this use case. cJURHnUR5 M gr%)mapsclear)r)mappings r+rMDeepChainMap.clearKs99 %r-c2URHnX#U'M gr%)rL)r)r3r4rNs r+r/DeepChainMap.__setitem__Os99$ %r-chSnURHnX;dM X1 SnM U(d [U5eg)NFT)rLKeyError)r)r3hitrNs r+ __delitem__DeepChainMap.__delitem__Ss8C99> C%sm#r-rHN)r:r;r<)r3rr:r;) r=r>r?r@__doc__rMr/rUrBrHr-r+rFrFDs   % $r-_GENERIC_TYPES_CACHE)defaultz$ContextVar[GenericTypesCache | None]c4\rSrSr%S\S'S\S'S\S'Srg ) PydanticGenericMetadatar type[BaseModel] | Noneorigintuple[Any, ...]argsztuple[TypeVar, ...] parametersrHN)r=r>r?r@__annotations__rBrHr-r+r[r[ds "" ##r-r[cDSUR0nU4n[X5upgnURU5 U"UUU4UUUS.SS.UD6n [SS9upU (aKSn Un [R U RR nXLaURX5n U S- n XLaMU $) a"Dynamically create a submodel of a provided (generic) BaseModel. This is used when producing concrete parametrizations of generic models. This function only *creates* the new subclass; the schema/validators/serialization must be updated to reflect a concrete parametrization elsewhere. Args: model_name: The name of the newly created model. origin: The base class for the new model to inherit from. args: A tuple of generic metadata arguments. params: A tuple of generic metadata parameters. Returns: The created submodel. r>)r]r_r`F)__pydantic_generic_metadata__#__pydantic_reset_parent_namespace__r)depthN_)r>r update_get_caller_frame_infosysmodules__dict__ setdefault) model_namer]r_params namespacebasesmetanskwds created_model model_modulecalled_globallyobject_by_referencereference_namereference_module_globalss r+create_generic_submodelrzjs$".v/@/@ AI IE":5NDd R    ' -2   M%;$C!L"##&;;}/G/G#H#Q#Q !6":"E"En"d  c !N"6 r-c[R"U5nUR nUR S5URUL4$![an[S5UeSnAf[a gf=f)zUsed inside a function to check whether it was called globally. Args: depth: The depth to get the frame. Returns: A tuple contains `module_name` and `called_globally`. Raises: RuntimeError: If the function is not called inside a function. z2This function must be used inside another functionN)NFr=)ri _getframe ValueError RuntimeErrorAttributeError f_globalsgetf_locals)reprevious_caller_framee frame_globalss r+rhrhsr # e 4 *33M   Z (*?*H*HM*Y YY XOPVWW sA A) A A)(A)z type[Any] DictValuesc#Z# [U[5(aUv g[U5(aURSShvN g[U[[ 45(aUHn[ U5ShvN M g[U5nUHn[ U5ShvN M gNeN3N 7f)a+Recursively iterate through all subtypes and type args of `v` and yield any typevars that are found. This is inspired as an alternative to directly accessing the `__parameters__` attribute of a GenericAlias, since __parameters__ of (nested) generic BaseModel subclasses won't show up in that list. r`N) isinstancerrrcrr1iter_contained_typevarsget_args)vvarr_args r+rrs !W   22<@@@ A D) * *C.s3 3 3{C.s3 3 3 A 4 4s4=B+B%3B+3B'4'B+B) B+'B+)B+cx[USS5nU(aURS5$[R"U5$)Nrcr_)getattrrtyping_extensionsrrpydantic_generic_metadatas r+rrs8@GKjlp@q (,,V44  % %a ((r-cx[USS5nU(aURS5$[R"U5$)Nrcr])rrr get_originrs r+rrs8@GKjlp@q (,,X66  ' ' **r-c[U5nUcg[US5(dgURnURn[ [ X255$)zPackage a generic type's typevars and parametrization (if present) into a dictionary compatible with the `replace_types` function. Specifically, this works with standard typing generics and typing._GenericAlias. N__parameters__)rhasattr__args__rdictzip)clsr]r_r`s r+get_standard_typevars_maprsL_F ~ 6+ , , LLD&,&;&;J J% &&r-c|URnUSnUSnU(d0$[[[U5U55$)aUPackage a generic BaseModel's typevars and concrete parametrization (if present) into a dictionary compatible with the `replace_types` function. Since BaseModel.__class_getitem__ does not produce a typing._GenericAlias, and the BaseModel generic info is stored in the __pydantic_generic_metadata__ attribute, we need special handling here. r]r_)rcrrr)rgeneric_metadatar]r_s r+get_model_typevars_maprsD88 h 'F F #D  +F3T: ;;r-cn^T(dU$[U5n[U5n[R"U5(aUtpE[ UT5n[ U/UQ7$U(Ga"[ U4SjU55n[X&5(aU$Ubf[U[R5(aG[U[R5(d([USS5b[[UR5nUce[U5(a0[SU55(a[ 4n[ SU55n["R$S:aU[&R(La [+X65$U[-U5S:XaUS$U$U(dS[/U5(aCUR0S nU(dU$[ U4S jU55n[Xv5(aU$X$[U[25(a0UVs/sHn[ UT5PM n n[X 5(aU$U $TR5X5$s snf) a4Return type with all occurrences of `type_map` keys recursively replaced with their values. Args: type_: The class or generic alias. type_map: Mapping from `TypeVar` instance to concrete types. Returns: A new type representing the basic structure of `type_` with all `typevar_map` keys recursively replaced. Example: ```python from typing import List, Union from pydantic._internal._generics import replace_types replace_types(tuple[str, Union[List[str], float]], {str: int}) #> tuple[int, Union[List[int], float]] ``` c3<># UHn[UT5v M g7fr% replace_types).0rtype_maps r+ replace_types..s"U9C=h#?#?9N_namec3N# UHn[R"U5v M g7fr%)ris_anyrrs r+rr-s L9K#>((--9Ks#%c3# UHAn[R"U5(aM [R"U5(aM=Uv MC g7fr%)r is_noreturnis_neverrs r+rr1s;'-C&2237;I;R;RSV;W-sA A  A rrrr`c3<># UHn[UT5v M g7fr%r)rtrs r+rrEs"Rz!=H#=#=zr)rrr is_annotatedrr tuplerrr typing_basertypingrranyr ri version_infotypes UnionTyperr0rrcr1r) type_r type_args origin_typeannotated_typerresolved_type_argsr`element resolved_lists ` r+rrs *  IU#K"";//'0$&~x@.7;788""U9"UU  7 7L  #5-";";<<{M,E,EFFw-9 "&%++6K&&& ; ' 'L9KLLL&)V"!&'-'"    w &;%//+I%kF FC8J4Kq4P-a0iiVhii >%0088F L""Rz"RR  8 8L((%INOgw9 O  . .L << %%Ps5H2c "URSn[U5n0n[5n[X!US9HupgXeLa[ SUS[U5SU35eXuLa[ R "[U5nUR5n U (a[URU5XH'MwU[SU55-n[ SUS[U5S U35e[ R "[U5nXtU'M U$![a Sn Nf=f) aFReturn a mapping between the parameters of a generic model and the provided arguments during parameterization. Raises: TypeError: If the number of arguments does not match the parameters (i.e. if providing too few or too many arguments). Example: ```python {test="skip" lint="skip"} class Model[T, U, V = int](BaseModel): ... map_generic_model_arguments(Model, (str, bytes)) #> {T: str, U: bytes, V: int} map_generic_model_arguments(Model, (str,)) #> TypeError: Too few arguments for ; actual 1, expected at least 2 map_generic_model_arguments(Model, (str, bytes, int, complex)) #> TypeError: Too many arguments for ; actual 4, expected 3 ``` Note: This function is analogous to the private `typing._check_generic_specialization` function. r`) fillvaluezToo many arguments for z ; actual z , expected Fc3h# UH(n[US5=(a UR5v M* g7f) has_defaultN)rr)rps r+r.map_generic_model_arguments..s(#f[eVWGA}$=$Q!--/$Q[es02zToo few arguments for z, expected at least ) rcr0objectr TypeErrorrcastrrrr __default__sum) rr_r` expected_len typevars_map_missing parameterargumentparamrs r+map_generic_model_argumentsrWs .22<@Jz?L')LxH*:xP  5cU)CI;kZfYghi i  KK3E $#//1 '4E4E4E|&T ##f[e#f ff "8Ys4ykQefres tuuKK3E"* ) Q, " $#  $s7C?? D D_generic_recursion_cachezContextVar[set[str] | None]c## [R5nUc [5n[RU5nOSn[XS9nXB;a[ US9nUv O&UR U5 Sv UR U5 U(a[RU5 gg!U(a[RU5 ff=f7f)aThis contextmanager should be placed around the recursive calls used to build a generic type, and accept as arguments the generic origin type and the type arguments being passed to it. If the same origin and arguments are observed twice, it implies that a self-reference placeholder can be used while building the core schema, and will produce a schema_ref that will be valid in the final parent schema. N) args_override)type_ref)rrsetrraddremovereset)r]r_previously_seen_type_refstokenr self_types r+generic_recursion_self_typers!9 < < > ($'E!(,,-FG 2;  0,h?IO % ) )( 3  % , ,X 6  $ * *5 1 5 $ * *5 1 s:B?AB?B?B<<B?cl[R5nU(d [5$UR5$r%)rrrcopy)visiteds r+recursively_defined_type_refsrs&&**,G u <<>r-c[R5nUc[5n[RU5 UR[ X55$)aThe use of a two-stage cache lookup approach was necessary to have the highest performance possible for repeated calls to `__class_getitem__` on generic types (which may happen in tighter loops during runtime), while still ensuring that certain alternative parametrizations ultimately resolve to the same type. As a concrete example, this approach was necessary to make Model[List[T]][int] equal to Model[List[int]]. The approach could be modified to not use two different cache keys at different points, but the _early_cache_key is optimized to be as quick to compute as possible (for repeated-access speed), and the _late_cache_key is optimized to be as "correct" as possible, so that two types that will ultimately be the same after resolving the type arguments will always produce cache hits. If we wanted to move to only using a single cache key per type, we would either need to always use the slower/more computationally intensive logic associated with _late_cache_key, or would need to accept that Model[List[T]][int] is a different type than Model[List[T]][int]. Because we rely on subclass relationships during validation, I think it is worthwhile to ensure that types that are functionally equivalent are actually equal. )rXrGenericTypesCacher_early_cache_key)parenttypevar_valuesgeneric_types_caches r+get_cached_generic_type_earlyrsH"/224"/1  !45  " "#3F#K LLr-c[R5nUc[5n[RU5 UR[ X#U55nUb [ XXRU5 U$)zkSee the docstring of `get_cached_generic_type_early` for more information about the two-stage cache lookup.)rXrrr_late_cache_keyset_cached_generic_type)rrr]r_rcacheds r+get_cached_generic_type_laters_/224#/1  !45 $ $_V>%R SF M Mr-c[R5nUc[5n[RU5 X%[ X5'[ U5S:XaX%[ XS5'U(aU(aX%[ X4U5'ggg)z~See the docstring of `get_cached_generic_type_early` for more information about why items are cached with two different keys. Nrr)rXrrrrr0r)rrrr]r_rs r+rrsz/224#/1  !45DI(@A >aKP,VA5FGH $MROF.IJvr-c[U[5(a0/nUHnUR[U55 M [U5$[R "[ R"U55(a [U5$g)akThis is intended to help differentiate between Union types with the same arguments in different order. Thanks to caching internal to the `typing` module, it is not possible to distinguish between List[Union[int, float]] and List[Union[float, int]] (and similarly for other "parent" origins besides List) because `typing` considers Union[int, float] to be equal to Union[float, int]. However, you _can_ distinguish between (top-level) Union[int, float] vs. Union[float, int]. Because we parse items as the first Union type that is successful, we get slightly more consistent behavior if we make an effort to distinguish the ordering of items in a union. It would be best if we could _always_ get the exact-correct order of items in the union, but that would require a change to the `typing` module itself. (See https://github.com/python/cpython/issues/86483 for reference.) rH) rrappend_union_orderings_keyris_unionrrr)r args_datar4s r+rrsj.%(( #E   1%8 9$Y  !2!=!=n!M N N''r-cX[U54$)aThis is intended for minimal computational overhead during lookups of cached types. Note that this is overly simplistic, and it's possible that two different cls/typevar_values inputs would ultimately result in the same type being created in BaseModel.__class_getitem__. To handle this, we have a fallback _late_cache_key that is checked later if the _early_cache_key lookup fails, and should result in a cache hit _precisely_ when the inputs to __class_getitem__ would result in the same type. r)rrs r+rrs  4^ D DDr-c[U5X4$)aqThis is intended for use later in the process of creating a new type, when we have more information about the exact args that will be passed. If it turns out that a different set of inputs to __class_getitem__ resulted in the same inputs to the generic type creation process, we can still return the cached type, and update the cache with the _early_cache_key as well. r)r]r_rs r+rrs  / ==r-) rmstrr]rDr_r^rnr^r:rD)r)rer9r:ztuple[str | None, bool])rr r:zIterator[TypeVar])rr r:r )rr r:zdict[TypeVar, Any] | None)rrDr:dict[TypeVar, Any])rr rzMapping[TypeVar, Any] | Noner:r )rrDr_r^r:r)r]rDr_r^r:z%Iterator[PydanticRecursiveRef | None])r:zset[str])rrDrr r:r\) rrDrr r]rDr_r^r:r\)NN) rrDrr^rrDr]r\r_ztuple[Any, ...] | Noner:r;)rr r:r )rrDrr r:GenericTypesCacheKey)r]rDr_r^rr r:r)K __future__rrirr collectionsrcollections.abcrr contextlibr contextvarsr itertoolsr r r r r rweakrefrrtyping_inspectionrtyping_inspection.introspectionrr _core_utilsr _forward_refr_utilsrrrrmainrrrrrrArr"rrFrXra TypedDictr[rzrhvaluesr*rrrrrrrrrrrrrrrrrrHr-r+r sM" -%"!99',;%.1w) S#uS#X67 T] T] $r2v,  ((<>O(OP xB' $x$:>HH^hl=m:m$/99$ ,,,,4C,M\,,^Z, -- I-4&)+'"<$^&B2j9CC]gk8l5l2 2#22*22>M0   -0 :I Q`  (&*#' S S#S S # S ! S  S.0 E >r-