gSrSSKJr SSKrSSKrSSKrSSKrSSKrSSK r SSK J r SSK J r Jr SSKJr SSKJrJrJrJrJrJr SSKJrJr SS KJrJrJrJr S S KJ r J!r! S S K"J#r# S S KJ$r$J%r% SSK&J'r' SSK(J)r)J*r*J+r+J,r, SSK-J.r.J/r/J0r0 SSK1J2r2 SSK3J4r4J5r5 SSK6J7r7J8r8 SSK9J:r: SSK;Jr> SSK?J@r@ SSKAJBrBJCrCJDrDJErEJFrF SSKGJHrHJIrI \R(aS SKKJLrLJMrMJNrN S SKKJOrP S SKKJQrR S SKSJTrT O\%rU\V"5rP\V"5rR\VRrX"SS \Y5rZS!S".S9S#jjr[\"S$\P\R\[4S%9"S&S'\ 55r\S:S(jr]S;S)jr^SS,jraS?S-jrbS$SSS..S@S/jjrcSAS0jrd"S1S25re"S3S45rfSBS5jrgSBS6jrh\ "SS79SCS8j5rig)Dz"Private logic for creating models.) annotationsN)ABCMeta) lru_cachepartial) FunctionType)AnyCallableGenericLiteralNoReturncast)PydanticUndefinedSchemaSerializer) TypeAliasTypedataclass_transform deprecatedget_args)PydanticUndefinedAnnotationPydanticUserError)create_schema_validator)GenericBeforeBaseModelWarningPydanticDeprecatedSince20) ConfigWrapper)DecoratorInfosPydanticDescriptorProxyget_attribute_from_basesunwrap_wrapped_function)collect_model_fieldsis_valid_field_nameis_valid_privateattr_name)GenerateSchema)PydanticGenericMetadataget_model_typevars_map)import_cached_base_modelimport_cached_field_info)set_model_mocks) NsResolver)CallbackGetCoreSchemaHandler)generate_pydantic_signature)_make_forward_refeval_type_backport is_annotatedis_classvar_annotationparent_frame_namespace)LazyClassAttributeSafeGetItemProxy)ComputedFieldInfo FieldInfoModelPrivateAttr)Field) PrivateAttr) BaseModelc0^\rSrSrSrSU4SjjrSrU=r$)_ModelNamespaceDict8zsA dictionary subclass that intercepts attribute setting on model classes and warns about overriding of decorators. c>URUS5nU(aJX#LaF[U[5(a1[R"SUSUR R S35 [TU]!X5$)N`z"` overrides an existing Pydantic `z ` decorator) get isinstancerwarningswarndecorator_infodecorator_reprsuper __setitem__)selfkvexisting __class__s _/home/matz/Project1/venv/lib/python3.13/site-packages/pydantic/_internal/_model_construction.pyrE_ModelNamespaceDict.__setitem__=sbD) )jCZ.[.[ MMAaS B8CZCZCiCiBjjuv ww"1(()rGstrrHobjectreturnNone)__name__ __module__ __qualname____firstlineno____doc__rE__static_attributes__ __classcell__rJs@rKr:r:8s))rMr:Finitcg)zOnly for typing purposes. Used as default value of `__pydantic_fields_set__`, `__pydantic_extra__`, `__pydantic_private__`, so they could be ignored when synthesizing the `__init__` signature. NrNr[s rK NoInitFieldr^EsrMT)kw_only_defaultfield_specifiersc^\rSrSrSSU4Sjjjr\R (dSSjr\SSj5r SU4Sjjr \ SSj5r \ \"SSS 9SS j55r\ SS j5r\ SS j5rSU4S jjrSrU=r$)ModelMetaclassONc  >^ ^!^"U(GaURU5upn [R"X#U5n U RUS'[ X;R X5n U (dU (a$[ X25m T b S'U 4Sjjn XS'O [US'XS'0U EU EUS'[S[T#U]("XX#40UD65n[5nURn[U;aFUR[5URU5:a[R "[#S5S S 9 [%UR&S S 5(+UlUR*UR*LaSOSUl[.R0"U5UlU(aXNlGOv[%US 05R7SS5m"[%USS5=(d T"m!T!(Ga0T"(Ga([9U!4SjT"55(Gd S SKJn [?U"4SjT!55nUT";aUUT!;aOSRAUVs/sHnURBPM sn5nURBSUSURBSUS3nOT"U-nSRAUVs/sHn[EU5PM sn5nSUS3nSUS3n[U;aFSRAUVs/sHnURBPM snU/-5nUSURBSUS3- n[GU5eSST!S .UlS Ul$U RK5HunnURMUU5 M U(a[O[Q55Ul)[%US!S5nU5(a [YU5n[[US"9n[]XU U5 U R^(aS#U;a [aX5 [cUUU S UUS$9 UR2RdRK5VVs0sHunnUURf_M snnUl4[kU5 [X]"S0UD6 U$S%HnURoUS5 M UR7S&05Rq5 [T#U]("XX#40UD6$s snfs snfs snfs snnf)(a-Metaclass for creating Pydantic models. Args: cls_name: The name of the class to be created. bases: The base classes of the class to be created. namespace: The attribute dictionary of the class to be created. __pydantic_generic_metadata__: Metadata for generic models. __pydantic_reset_parent_namespace__: Reset parent namespace. _create_model_module: The module of the class to be created, if created by `create_model`. **kwargs: Catch-all for any other keyword arguments. Returns: The new class created by the metaclass. model_configNc,>[X5 T"X5 g)z`We need to both initialize private attributes and call the user-defined model_post_init method. N)init_private_attributes)rFcontextoriginal_model_post_inits rKwrapped_model_post_init7ModelMetaclass.__new__..wrapped_model_post_initys0>0?rMmodel_post_init__class_vars____private_attributes__type[BaseModel]zClasses should inherit from `BaseModel` before generic classes (e.g. `typing.Generic[T]`) for pydantic generics to work properly.r stacklevel__pydantic_base_init__F__pydantic_generic_metadata__ parametersrN__parameters__c3,># UH oT;v M g7fNrN).0xrts rK )ModelMetaclass.__new__..s?kYjTUZYjs)RootModelRootTypec36># UHoT;dM Uv M g7frwrN)rxryparent_parameterss rKrzr{s.c*QQbHbqq*s  z, zS is a subclass of `RootModel`, but does not include the generic type identifier(s) zL in its parameters. You should parametrize RootModel directly, e.g., `class z (RootModel[z ]): ...`.ztyping.Generic[]zJAll parameters must be present on typing.Generic; you should inherit from .z- Note: `typing.Generic` must go last: `class (z): ...`))originargsrt__pydantic_parent_namespace__)parent_namespace__hash__ raise_errors ns_resolvercreate_model_module)__pydantic_fields_set____pydantic_extra____pydantic_private____annotations__rFr8rhrrQrR)9_collect_bases_datar for_model config_dictinspect_namespace ignored_typesget_model_post_initrgr rD__new__r&__mro__r indexr@rArgetattr__init____pydantic_custom_init__rl__pydantic_post_init__rbuild__pydantic_decorators__rsr>all root_modelr|tuplejoinrSrO TypeError__pydantic_complete__items __set_name__build_lenient_weakvaluedictr0rr?dictunpack_lenient_weakvaluedictr)set_model_fieldsfrozenset_default_hash_funccomplete_model_classcomputed_fieldsinfo__pydantic_computed_fields__set_deprecated_descriptors__pydantic_init_subclass__popclear)$mcscls_namebases namespacers#__pydantic_reset_parent_namespace___create_model_modulekwargsbase_field_names class_varsbase_private_attributesconfig_wrapperprivate_attributesrjcls BaseModel_mror|missing_parametersryparameters_str error_messagecombined_parametersgeneric_type_label bases_strnameobjrrrGrH instance_slotrirtr~rJs$ @@@rKrModelMetaclass.__new__Qs6 DGD[D[\aDb A *A*44UvNN(6(B(BIn %!277" "%<+>y+P(+7@4K/03JI/0*4& '2c5L2cPb2cI. /(%'/#*d]c*deC13J++C#~#))G"4syy7L"L 1B ! 07s||E]_d/e+eC (++z/I/IIO`  &+9*>*>s*CC '-4Q1$+C1PRT$U$Y$YZfhj$k!$S*:DAVEV "3C?kYj?k)..c*.c)c&(,==BS[eBe*.HZ3[HZ1AJJHZ3[)\"||n,-./WWZWcWcVddop~o@IJ& /@BT.T+)-DW3XDWqCFDW3X)Y/>~>Na-P*88J7K1N&#%/ )- u2Mu!1::u2MQcPd2d(eI)"OPSP\P\~]^_h^iiq rM$M22#",51 ).C %0557 c  d+834OPfPh4i16=cCbdh6i *D11#?@P#Q $6FGK S E$$9)D%c1 "'$8  '*&A&A&Q&Q&W&W&Y0&Yda166 &Y0C , 's + # 6 @ @J"i  !"i MM+R 0 6 6 87?3%MfM Mc4\4Y3NV0sQ93Q>4R-RcnURRS5nU(a X;aX!$[U5e)zNThis is necessary to keep attribute access working for class attribute access.rn)__dict__r>AttributeError)rFitemrs rK __getattr__ModelMetaclass.__getattr__s4!%!2!23K!L !d&@)// & &rMc[5$rw)r:)rrrs rK __prepare__ModelMetaclass.__prepare__ s "$$rMcH>[US5=(a [TU] U5$)zcAvoid calling ABC _abc_subclasscheck unless we're pretty sure. See #3829 and python/cpython#92810 __pydantic_validator__)hasattrrD__instancecheck__)rFinstancerJs rKr ModelMetaclass.__instancecheck__s# x!9:buw?XYa?bbrMcL[5n[5n[5n0nUH{n[XQ5(dMXQLdMUR[ US05R 55 URUR 5 URUR5 M} X#U4$)N__pydantic_fields__)r&set issubclassupdaterkeysrmrn)rr8 field_namesrrbases rKr"ModelMetaclass._collect_bases_datas,. # "u :<D$**t/D""741F#K#P#P#RS!!$"5"56"))$*E*EF  (:::rMEThe `__fields__` attribute is deprecated, use `model_fields` instead.)categorycN[R"S[SS9 UR$)Nrrrp)r@rAr model_fieldsrFs rK __fields__ModelMetaclass.__fields__$s'  S %    rMc[US05$)zGet metadata about the fields defined on the model. Returns: A mapping of field names to [`FieldInfo`][pydantic.fields.FieldInfo] objects. rrrs rKrModelMetaclass.model_fields.st2B77rMc[US05$)zGet metadata about the computed fields defined on the model. Returns: A mapping of computed field names to [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects. rrrs rKmodel_computed_fields$ModelMetaclass.model_computed_fields7st;R@@rMcd>[[TU] 55nSU;aURS5 U$)Nr)listrD__dir__remove)rF attributesrJs rKrModelMetaclass.__dir__@s0%'/+, : %   l +rMrN)NTN)rrOrtuple[type[Any], ...]rdict[str, Any]rszPydanticGenericMetadata | Nonerboolr str | NonerrrQtype)rrOrQr)rrrrrQzdict[str, object])rrrQr)rrrQz6tuple[set[str], set[str], dict[str, ModelPrivateAttr]])rQzdict[str, FieldInfo])rQzdict[str, ComputedFieldInfo])rQz list[str])rSrTrUrVrtyping TYPE_CHECKINGr classmethodrr staticmethodrpropertyrrrrrrXrYrZs@rKrbrbOsIM48+/mNmN%mN" mN (F mN .2 mN)mNmN mNmN^    '%%c ; ;Wbfg!h!88AArMrbc[USS5cR0nURR5H$up4UR5nU[LdM XRU'M& [ USU5 gg)zThis function is meant to behave like a BaseModel method to initialise private attributes. It takes context as an argument since that's what pydantic-core passes when calling it. Args: self: The BaseModel instance. context: The context. rN)rrnr get_defaultrobject_setattr)rFrhpydantic_privater private_attrdefaults rKrgrgGskt+T2:"&"="="C"C"E D"..0G//)0&#F t35EF ;rMcfSU;aUS$[5n[US5nX2RLaU$g)zaGet the `model_post_init` method from the namespace or the class bases, or `None` if not defined.rlN)r&rrl)rrr8rls rKrrYsBI%*++(*I.u6GHO7778rMc *^SSKJmJn [5nU[ 5-n0nUR S05nSU;dSU;a [ S5e[5n [UR55GHupU S:XdU S:XaM[U [5(a>U RUS:Xa+S U;a%U RRUS 5(aMg[X5(dU RRS :XaU R!U 5 M[U T5(aVU RS 5(a[#S U <S 35e[%U 5(a[#SSU -<SU <S 35eXU 'X GM [X5(a>[%U 5(d.U R'S5=(d Sn [#SU <SU <S 35eU RS 5(aGMr[)U 5(a1X;d[+X5(d[-TU"U S95Xz'X GMGMX;aGMX;dGMX;a[/SU <S3SS9e[X5(a[/SU <S3SS9e[/SU SU <SU S3SS9e UR5Hup[)U 5(dMX;dMX;dM%[+U5(aM7X;dM>[1USS5S :wdMQ[U[25(aB[4R6"S5nUb)[9[;USS S!9UR<UR>S"9n[AU5(a,[CU5tnn[EU4S#jU5S5nUbUX}'MU"5X}'M U$!["[ 4a N]f=f)$aIterate over the namespace and: * gather private attributes * check for items which look like fields but are not (e.g. have no annotation) and warn. Args: namespace: The attribute dictionary of the class to be created. ignored_types: A tuple of ignore types. base_class_vars: A set of base class class variables. base_class_fields: A set of base class fields. Returns: A dict contains private attributes info. Raises: TypeError: If there is a `__root__` field in model. NameError: If private attribute name is invalid. PydanticUserError: - If a field does not have a type annotation. - If a field on base class was overridden by a non-annotated attribute. r)r5r7r__root__zUTo define root models, use `pydantic.RootModel` rather than a field called '__root__'rerrTrU functools__zXPrivate attributes must not use dunder names; use a single underscore prefix instead of rzJPrivate attributes must not use valid field names; use sunder names, e.g. _z instead of my_fieldz>Fields must not use names with leading underscores; e.g., use )rzField z defined on a base class was overridden by a non-annotated attribute. All field definitions, including overrides, require a type annotation.zmodel-field-overridden)codez requires a type annotationzmodel-field-missing-annotationz)A non-annotated attribute was detected: `z = z3`. All model fields require a type annotation; if `z` is not meant to be a field, you may be able to resolve this error by annotating it as a `ClassVar` or updating `model_config['ignored_types']`.NFT) is_argumentis_class)globalnslocalnsc3N># UHn[UT5(dMUv M g7frw)r?)rxrHr5s rKrz$inspect_namespace..s$\1JqJZ<[QQs% %)#fieldsr5r7r'default_ignored_typesr>rrrrr?rrTrU startswithrJadd NameErrorr!lstripr"r/r rrrOsys _getframer-r, f_globalsf_localsr.rnext)rrbase_class_varsbase_class_fieldsr7r4all_ignored_typesrraw_annotations ignored_namesvar_namevaluesuggested_nameann_nameann_typeframermetadatarr5s @rKrres47(*I%(=(??68mm$5r:O_$ i(?opp!eM  12 ~ %5I)I  ud # #  Il$;;)+""--i.GHH   1 1U__5O5OS^5^   h '  / 0 0""4((BBJQP%X..//2X~.@ XLXY[,1x (#  ) )2Eh2O2O%__S1?ZN,/|H make_hash_func..slmrMc>[T"UR55$![a' [T"[UR555s$f=frw)hashrKeyErrorr2)rFgetters rK hash_func!make_hash_func..hash_funcsJ At}}-. . A / >?@ @  As.AA)rFrrQint)roperator itemgetterr)rr;r:s @rKr0r0s;EHE\E\X #"9"9">">"@ AbmFA rMc [U5n[XX#US9upVXPlURR U5 UHOnUR R US5nUcM$UR[LdM9[XUR5 MQ g)a$Collect and set `cls.__pydantic_fields__` and `cls.__class_vars__`. Args: cls: BaseModel or dataclass. bases: Parents of the class, generally `cls.__bases__`. config_wrapper: The config wrapper instance. ns_resolver: Namespace resolver to use when getting model annotations. ) typevars_mapN) r%r rrmrrnrrrsetattr) rrrrrArrrGr(s rKrr s~*#.L-c.dpqF$j) **..q$7  6G!G CEMM *rMrc ,UR(a [X5 g[U5n[UUU5n[ [ UR SS9USS9nURX5n URURS9n URU 5n Xl[U UU=(d UR UR"U(aSOS U UR$5Ul[)X5UlS Ul[/S [ [0UR2UR4UR6UR8S 95Ulg ![a,n U(ae[XSU RS35 Sn A gSn A ff=f!URa [X5 gf=f) aFinish building a model class. This logic must be called after class has been created since validation functions must be bound and `get_type_hints` requires a class object. Args: cls: BaseModel or dataclass. cls_name: The model or dataclass name. config_wrapper: The config wrapper instance. raise_errors: Whether to raise errors. ns_resolver: The namespace resolver instance to use during schema building. create_model_module: The module of the class to be created, if created by `create_model`. Returns: `True` if the model is successfully completed, else `False`. Raises: PydanticUndefinedAnnotation: If `PydanticUndefinedAnnotation` occurs in`__get_pydantic_core_schema__` and `raise_errors=True`. F)from_dunder_get_core_schemaunpack)ref_moder=N)title create_modelr8T __signature__)r\rpopulate_by_nameextra) defer_buildr(r%r#r*rgenerate_schema__get_pydantic_core_schema__rr core_configrS clean_schemaCollectedInvalid__pydantic_core_schema__rrTrUplugin_settingsrr__pydantic_serializer__rr1r+rrrJrKrI) rrrrrrrA gen_schemahandlerschemaerOs rKrr+s:!!&)#.LJ + **NG 11#?!,,3<<,@K((0 $* !8 -s~~ -;&&"C#36"GC $C + '**+<< &&   C U '  166(!}5   & &&s*D<?E5< E2"E--E25FFcURR5H>upUR=ncM[U5nUR X5 [ XU5 M@ UR R5HnupUR=ncM[[UR5S5(aM<[X5R5nUR X5 [ XU5 Mp g)z8Set data descriptors on the class for deprecated fields.N__deprecated__) rrdeprecation_message_DeprecatedFieldDescriptorrrBrrrwrapped_property)rfield field_infomsgdesccomputed_field_infos rKrrs 44::<11 1C >-c2D   c ) C % = '*&F&F&L&L&N"';; ;S H34G4X4XY[kll-c3W3WXD   c ) C %'OrMcT\rSrSr%SrS\S'S S SjjrS SjrS SSjjrSS jr S r g)r\iaCRead-only data descriptor used to emit a runtime deprecation warning before accessing a deprecated field. Attributes: msg: The deprecation message to be emitted. wrapped_property: The property instance if the deprecated field is a computed field, or `None`. field_name: The name of the field being deprecated. rO field_nameNcXlX lgrw)r`r])rFr`r]s rKr#_DeprecatedFieldDescriptor.__init__s  0rMcX lgrw)rd)rFrrs rKr'_DeprecatedFieldDescriptor.__set_name__srMcbUc>URbURRSU5$[UR5e[R "UR [RSS9 URbURRX5$URUR$)Nrrp) r]__get__rrdr@rAr`builtinsDeprecationWarningr)rFrobj_types rKrj"_DeprecatedFieldDescriptor.__get__s ;$$0,,44T8DD 1 1 dhh ; ;J  ,((00? ?||DOO,,rMc,[UR5erw)rrd)rFrr(s rK__set__"_DeprecatedFieldDescriptor.__set__sT__--rM)rdr`r]rw)r`rOr]zproperty | NonerQrR)rrorrOrQrR)rzBaseModel | Nonermztype[BaseModel] | NonerQr)rrr(rrQr ) rSrTrUrVrWrrrrjrprXrNrMrKr\r\s"O1 -.rMr\c6\rSrSrSrSSjrS SjrS SjrSrg) _PydanticWeakRefiaWrapper for `weakref.ref` that enables `pickle` serialization. Cloudpickle fails to serialize `weakref.ref` objects due to an arcane error related to abstract base classes (`abc.ABC`). This class works around the issue by wrapping `weakref.ref` instead of subclassing it. See https://github.com/pydantic/pydantic/issues/6763 for context. Semantics: - If not pickled, behaves the same as a `weakref.ref`. - If pickled along with the referenced object, the same `weakref.ref` behavior will be maintained between them after unpickling. - If pickled without the referenced object, after unpickling the underlying reference will be cleared (`__call__` will always return `None`). cPUcSUlg[R"U5Ulgrw)_wrweakrefref)rFrs rKr_PydanticWeakRef.__init__s ;DH{{3'DHrMc>URcgUR5$rwrurs rK__call___PydanticWeakRef.__call__s 88 88: rMc[U"544$rw)rsrs rK __reduce___PydanticWeakRef.__reduce__s$&**rMrzN)rr)rQr)rQz4tuple[Callable, tuple[weakref.ReferenceType | None]]) rSrTrUrVrWrr{r~rXrNrMrKrsrss ( +rMrscUcg0nUR5Hup#[U5nXAU'M U$![a UnNf=f)aHTakes an input dictionary, and produces a new value that (invertibly) replaces the values with weakrefs. We can't just use a WeakValueDictionary because many types (including int, str, etc.) can't be stored as values in a WeakValueDictionary. The `unpack_lenient_weakvaluedict` function can be used to reverse this operation. N)rrsr)dresultrGrHproxys rKrrsX y F  $Q'Eq  M E s 2 AAcUcg0nUR5H0up#[U[5(aU"5nUbX1U'M*M,X1U'M2 U$)zAInverts the transform performed by `build_lenient_weakvaluedict`.N)rr?rs)rrrGrHs rKrrsWy F  a) * *A}q 1I  MrM)maxsizecSSKJn [[[[ [ U[/n[RS:aUR[R5 [U5$)Nr)r3) ) rr3rrrrrrr version_infoappendrr)r3rs rKrrsR* M 7"V112  rM)r\zLiteral[False]rQrr)rrrrrQzCallable[..., Any] | None) rrrrr"set[str]r#rrQzdict[str, ModelPrivateAttr])rrorrrQrR)rrorQr) rrorrrrrNsResolver | NonerQrR)rrorrOrrrrrrrrrQr)rrorQrR)rdict[str, Any] | NonerQr)rQr)jrW __future__r _annotationsrkr>rrr@rvabcrr rrtypesrrr r r r r pydantic_corerrtyping_extensionsrrrrerrorsrrplugin._schema_validatorrrr_configr _decoratorsrrrr_fieldsr r!r"_generate_schemar# _genericsr$r% _import_utilsr&r' _mock_val_serr(_namespace_utilsr)_schema_generation_sharedr* _signaturer+ _typing_extrar,r-r.r/r0_utilsr1r2rrr3r4r5r6PydanticModelFieldr7PydanticModelPrivateAttrmainr8rlrP __setattr__rrr:r^rbrgrrrr0rrrr\rsrrrrNrMrKrs!(2 (BB=VVC>O"ssYY,FM*(C39 GG4@ 3%x## )$ )!  T=OQikv