)iSrSSKJr SSKrSSKrSSKrSSKrSSKrSSK J r SSK J r J r Jr SSKJr SSKJrJrJrJrJrJrJrJr SSKJrJr SS KJrJrJrJ r J!r! SS K"J#r# S S K$J%r%J&r& S S K'J(r( S SKJ)r)J*r* SSK+J,r, SSK-J.r.J/r/J0r0J1r1 SSK2J3r3J4r4J5r5J6r6 SSK7J8r8J9r9 SSK:J;r;Jr>J?r? SSK@JArA SSKBJCrC SSKDJErE SSKFJGrGJHrHJIrIJJrJ SSKKJLrLJMrM \(aS SKNJOrP S SKNJQrQJRrR S SKNJSrT S SKUJVrV O\W"5rP\W"5rT\WRrY"SS \Z5r[S!S".S9S#jjr\\"S$5r]\"S%\P\T\\4S&9"S'S(\ 55r^S:S)jr_S;S*jr`SS-jrcS?S.jrdS%S%SS/.S@S0jjreSAS1jrf"S2S35rg"S4S55rhSBS6jriSBS7jrj\ SCS8j5rkg)Dz"Private logic for creating models.) annotationsN)ABCMeta)cachepartialwraps) FunctionType) TYPE_CHECKINGAnyCallableGenericLiteralNoReturnTypeVarcast)PydanticUndefinedSchemaSerializer) TypeAliasTypedataclass_transform deprecatedget_args get_origin)typing_objects)PydanticUndefinedAnnotationPydanticUserError)create_schema_validator)GenericBeforeBaseModelWarningPydanticDeprecatedSince20) ConfigWrapper)DecoratorInfosPydanticDescriptorProxyget_attribute_from_basesunwrap_wrapped_function)collect_model_fieldsis_valid_field_nameis_valid_privateattr_namerebuild_model_fields)GenerateSchemaInvalidSchemaError)PydanticGenericMetadataget_model_typevars_map)import_cached_base_modelimport_cached_field_info)set_model_mocks) NsResolver)generate_pydantic_signature)_make_forward_refeval_type_backportis_classvar_annotationparent_frame_namespace)LazyClassAttributeSafeGetItemProxy)Field) FieldInfoModelPrivateAttr) PrivateAttr) BaseModelc0^\rSrSrSrSU4SjjrSrU=r$)_ModelNamespaceDict3zsA dictionary subclass that intercepts attribute setting on model classes and warns about overriding of decorators. c>URUS5nU(aIX#LaE[U[5(a0[R"SUSUR R S3SS9 [TU]!X5$)N`z"` overrides an existing Pydantic `z ` decoratorr stacklevel) get isinstancer"warningswarndecorator_infodecorator_reprsuper __setitem__)selfkvexisting __class__s f/var/www/html/land-doc-ocr/venv/lib/python3.13/site-packages/pydantic/_internal/_model_construction.pyrK_ModelNamespaceDict.__setitem__8sjD) )jCZ.[.[ MMA389P9P9_9_8``kl  w"1(()rMstrrNobjectreturnNone)__name__ __module__ __qualname____firstlineno____doc__rK__static_attributes__ __classcell__rPs@rQr>r>3s))rSr>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. NrTras rQ NoInitFieldrdCsrS_TT)kw_only_defaultfield_specifiersc ^\rSrSrSSU4Sjjjr\(dSSjr\SSj5rSU4Sjjr \ Rr \ Rr \ SSj5r\\"SSS 9SS j55r\SS j5rSU4S jjrS rU=r$)ModelMetaclassQNc d >^%^&^'U(Ga[RS:a9SU;aUSnO?SSKJn Jn Jn U "U5=n (aU "XR S9nO0nOURS05nURU5upn[R"X#X5nURUS'[X8URX5nU(dU(a3[X25m%T%b[T%5S,U%4Sjj5nUUS 'O [ US 'XS '0UEUEUS '[#S [$T(U]L"XX#40UD65n[)5nUR*n[,U;aFUR/[,5UR/U5:a[0R2"[5S 5SS9 [7UR8SS5(+UlUR<UR<LaSOS Ul0Ul [BRD"U5Ul#URFRIU5 U(a UUl%GOv[7US05RSS5m'[7USS5=(d T'm&T&(Ga0T'(Ga([MU&4SjT'55(Gd SSK'J(n [SU'4SjT&55nUT';aUUT&;aOSRUUVs/sHnURVPM sn5nURVSUSURVSUS3nOT'U-nSRUUVs/sHn[YU5PM sn5nSUS3nS US!3n[,U;aFSRUUVs/sHnURVPM snU/-5nUS"URVS#US$3- n[[U5eSST&S%.Ul%SUl.UR_5HunnURaUU5 M U(a[c[e55Ul3[7US&S5n [iU [j5(a [mU 5n [oU S'9n![qUUU!S(9 URFRrR_5V"V#s0sHun"n#U"U#Rt_M sn#n"Ul;URx(a [{U5 O [}UUU!SUS)9 UR~(aS*U;a [UU5 [$UUG]"S0UD6 U$S+Hn$URU$S5 M URS05R5 [$T(U]L"XX#40UD6$s snfs snfs snfs sn#n"f)-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. )__annotations__r)Formatcall_annotate_function!get_annotate_from_class_namespace)format 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)rLcontextoriginal_model_post_inits rQwrapped_model_post_init7ModelMetaclass.__new__..wrapped_model_post_inits 0>0?rSmodel_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.rrB__pydantic_base_init__F__pydantic_generic_metadata__ parametersrT__parameters__c3,># UH oT;v M g7fNrT).0xrs rQ )ModelMetaclass.__new__..s?kYjTUZYjs)RootModelRootTypec36># UHoT;dM Uv M g7frrT)rrparent_parameterss rQrrs.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): ...`))originargsr__pydantic_parent_namespace__)parent_namespace)config_wrapper ns_resolver) raise_errorscreate_model_module__hash__)__pydantic_fields_set____pydantic_extra____pydantic_private__rLr<rvr rWrX)Dsys version_info annotationlibrorprq FORWARDREFrD_collect_bases_datar for_model config_dictinspect_namespace ignored_typesget_model_post_initrrurrJ__new__r-__mro__r indexrFrGrgetattr__init____pydantic_custom_init__rz__pydantic_post_init____pydantic_setattr_handlers__r!build__pydantic_decorators__update_from_configrall root_modelrtuplejoinrYrU TypeError__pydantic_complete__items __set_name__build_lenient_weakvaluedictr5rrEdictunpack_lenient_weakvaluedictr0set_model_fieldscomputed_fieldsinfo__pydantic_computed_fields__ defer_buildr/complete_model_classfrozenset_default_hash_func__pydantic_init_subclass__popclear))mcscls_namebases namespacer#__pydantic_reset_parent_namespace___create_model_modulekwargsraw_annotationsrorprqannotatebase_field_names class_varsbase_private_attributesrprivate_attributesrxcls BaseModel_mrormissing_parametersrparameters_str error_messagecombined_parametersgeneric_type_label bases_strnameobjrrrMrN instance_slotrwrrrPs) @@@rQrModelMetaclass.__new__SsV6 7*%2&/0A&BOpo#DY#OOxO*@RcRc*d*,"+--0A2"FDGD[D[\aDb A *A*44U_N(6(B(BIn %!2N,H,H*" "%<+>y+P(+734@5@4KI/03JI/0*4& '2c5L2cPb2cI. /(%'/#*d]c*deC13J++C#~#))G"4syy7L"L 1B ! 07s||E]_d/e+eC (++z/I/IIO`  &13C -*8*>*>s*CC '  ' ' : :> J-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[ Y '*&A&A&Q&Q&W&W&Y0&Yda166 &Y0C ,))$%"!&(< $$9)D%c51 #s 6 @ @J"i  !"i MM+R 0 6 6 87?3%MfM Mg4\4Y3N>0s1TT"T' T,cnURRS5nU(a X;aX!$[U5e)zNThis is necessary to keep attribute access working for class attribute access.r|)__dict__rDAttributeError)rLitemrs rQ __getattr__ModelMetaclass.__getattr__s4!%!2!23K!L !d&@)// & &rSc[5$r)r>)rrrs rQ __prepare__ModelMetaclass.__prepare__#s "$$rSch>[R"SURS3SS9 [TU]U5$)Nz>For performance reasons, virtual subclasses registered using 'zK.register()' are not supported in 'isinstance()' and 'issubclass()' checks.rrB)rFrGr[rJregister)rLsubclassrPs rQrModelMetaclass.register+s? LTM^M^L_`M M w))rScL[5n[5n[5n0nUH{n[XQ5(dMXQLdMUR[ US05R 55 URUR 5 URUR5 M} X#U4$)N__pydantic_fields__)r-set issubclassupdaterkeysr{r|)rr< field_namesrrbases rQr"ModelMetaclass._collect_bases_data6s,. # "u :<D$**t/D""741F#K#P#P#RS!!$"5"56"))$*E*EF  (:::rSXThe `__fields__` attribute is deprecated, use the `model_fields` class property instead.)categorycP[R"S[SS9 [US05$)NrrrBr)rFrGrrrLs rQ __fields__ModelMetaclass.__fields__Es+  f % t2B77rScSUR;ag[SUR5n[SUR 555$)zWhether the fields where successfully collected (i.e. type hints were successfully resolves). This is a private attribute, not meant to be used outside Pydantic. rFdict[str, FieldInfo]c38# UHoRv M g7fr) _complete)r field_infos rQr>ModelMetaclass.__pydantic_fields_complete__..\sO:NJ'':Ns)rrrrvalues)rL field_infoss rQ__pydantic_fields_complete__+ModelMetaclass.__pydantic_fields_complete__Qs@ ! 5143K3KL O+:L:L:NOOOrScd>[[TU] 55nSU;aURS5 U$)Nr)listrJ__dir__remove)rL attributesrPs rQrModelMetaclass.__dir__^s0%'/+, : %   l +rSrT)NTN)rrUrtuple[type[Any], ...]rdict[str, Any]rzPydanticGenericMetadata | Nonerboolr str | Nonerr rWtype)rrUrWr )rr rr rWzdict[str, object])rtype[_T]rWr)rr rWz6tuple[set[str], set[str], dict[str, ModelPrivateAttr]])rWr)rWr)rWz list[str])rYrZr[r\rr r classmethodrrr__instancecheck____subclasscheck__ staticmethodrpropertyrrrrr^r_r`s@rQririQsIM48+/DNDN%DN" DN (F DN .2 DN)DNDN DNDNL  '%%*.... ; ;bmq88 P PrSric[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)rr|r get_defaultrobject_setattr)rLrvpydantic_privater private_attrdefaults rQrurueskt+T2:"&"="="C"C"E D"..0G//)0&#F t35EF ;rScfSU;aUS$[5n[US5nX2RLaU$g)zaGet the `model_post_init` method from the namespace or the class bases, or `None` if not defined.rzN)r-r#rz)rrr<rzs rQrrwsBI%*++(*I.u6GHO7778rSc 8^SSKJmJn [5nU[ 5-n0nSU;dSU;a [ S5e[ 5n [UR55GH upU S:XdU S:XaM[U [5(aAU RUS:Xa.SU;a(U RRUSS 35(aMj[X5(dU RRS :XaU RU 5 M[U T5(aVU RS 5(a[!S U <S 35e[#U 5(a[!S SU -<SU <S 35eXU 'X GM[X5(a>[#U 5(d.U R%S5=(d Sn [!SU <SU <S 35eU RS 5(aGMu['U 5(a1X;d[)X5(d[+TU"U S95X'X GMGMX;aGMX;dGMX;a[-SU <S3SS9e[X5(a[-SU <S3SS9e[-SU SU <SU S3SS9e UR5GHup['U 5(dMX;dMX;dM&[)U5(aM8X;dM?[/USS5S :wdMR[U[05(aB[2R4"S5nUb)[7[9USSS 9UR:UR<S!9n[>R@"[CU55(a,[EU5tnn[GU4S"jU5S5nUbUX'MU"5X'GM U$![ [ 4a Nrf=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. raw_annotations: The (non-evaluated) annotations of the model. 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)r:r;__root__zUTo define root models, use `pydantic.RootModel` rather than a field called '__root__'rsrrZr[r functools__zXPrivate attributes must not use dunder names; use a single underscore prefix instead of zJPrivate 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 g7fr)rE)rrNr:s rQr$inspect_namespace..s$\1JqJZ<[QQs% %)$fieldsr:r;r.default_ignored_typesrrrrrErrZr[ startswithrPadd NameErrorr&lstripr'r4rrrrUr _getframer3r2 f_globalsf_localsr is_annotatedrrnext)rrrbase_class_varsbase_class_fieldsr;r9all_ignored_typesr ignored_namesvar_namevaluesuggested_nameann_nameann_typeframer"metadatarr:s @rQrrs87(*I%(=(??68_$ i(?opp!eM  12 ~ %5I)I  ud # #  Il$;;)+""-->1J0K1.MNN   1 1U__5O5OS^5^   h '  / 0 0""4((BBJQP%X..//2X~.@ XLXY[,1x (#  ) )2Eh2O2O%__S1?ZN,/|H(NNNc[US5n[U5nUS[R1;d[ USS5UR :XaX0lgg)Nr__code__)r#make_hash_funcrVrrrB)rrbase_hash_func new_hash_funcs rQrr sN-eZ@N"3'M$00GNJX\4]anawaw4w% 5xrSc^UR(a+[R"URR56OSmSU4SjjnU$)Ncg)NrrT)r"s rQ make_hash_func..slmrSc>[T"UR55$![a' [T"[UR555s$f=fr)hashrKeyErrorr7)rLgetters rQ hash_func!make_hash_func..hash_funcsJ At}}-. . A / >?@ @  As.AA)rLr rWint)roperator itemgetterr)rrNrMs @rQrCrCs;EHE\E\X #"9"9">">"@ AbmFA rSc[U5n[XX#S9upEX@lURR U5 UHOnUR R US5nUcM$UR[LdM9[XUR5 MQ g)zCollect and set `cls.__pydantic_fields__` and `cls.__class_vars__`. Args: cls: BaseModel or dataclass. config_wrapper: The config wrapper instance. ns_resolver: Namespace resolver to use when getting model annotations. ) typevars_mapN) r,r%rr{rr|rrrsetattr)rrrrTr+rrMr;s rQrr)s{*#.L-c;jF$j) **..q$7  6G!G CEMM *rS)rcall_on_complete_hookrc [U5nUR(d>[UUUUS9UlU(dUR(dgUR(de[UUU5n U RU5n URURS9n U RU 5n URR R#5V V s0sHupXR$_M sn n Ul[)U5 Xl[-U UU=(d UR.UR0U(aSOSU UR25Ul[7X5Ul[;S[=[>UR@URURBURDS 95Ul#S Ul$U(aURK5 g ![aDn[ R "U5n[USURS35 U(aXeSnAGNSnAff=f![ a,nU(ae[USURS35 SnAgSnAff=f![a [U5 gf=fs sn n 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. config_wrapper: The config wrapper instance. ns_resolver: The namespace resolver instance to use during schema building. raise_errors: Whether to raise errors. call_on_complete_hook: Whether to call the `__pydantic_on_complete__` hook. 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`. )rrrTrANF)title create_modelr< __signature__)rbr+validate_by_nameextraT)&r,rr(rr/rfrom_name_errorr/rr)generate_schema core_configrY clean_schemar*rrrrrset_deprecated_descriptors__pydantic_core_schema__rrZr[plugin_settings__pydantic_validator__r__pydantic_serializer__r6rr1rr[r\rZr__pydantic_on_complete__)rrrrrVrrTeexc gen_schemaschemar_rMrNs rQrrHs-:*#.L  + + !&:-') 'C #C$D$D////J ++C0!,,3<<,@K((0?B>Y>Y>i>i>o>o>q'r>qda66 >q'rC$s##) !8 -s~~ -;&&"C#36"GC + '**+<< &&   C!%C $$& Q !-==a@C C1SXXJa 1  !( '  q]+   (ssGF;)H I I ; H 9HH  I"H==IIIcURR5H>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_DeprecatedFieldDescriptorrrUrhasattrr$wrapped_property)rfieldrmsgdesccomputed_field_infos rQraras 44::<11 1C >-c2D   c ) C % = '*&F&F&L&L&N"';; ;S H34G4X4XY[kll-c3W3WXD   c ) C %'OrScT\rSrSr%SrS\S'S S SjjrS SjrS SSjjrSS jr S r g)rniaCRead-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. rU field_nameNcXlX lgr)rrrp)rLrrrps rQr#_DeprecatedFieldDescriptor.__init__s  0rScX lgr)rv)rLrrs rQr'_DeprecatedFieldDescriptor.__set_name__srScNUc>URbURRSU5$[UR5e[R "UR [SS9 URbURRX5$URUR$)NrrB) rp__get__rrvrFrGrrDeprecationWarningr)rLrobj_types rQr|"_DeprecatedFieldDescriptor.__get__s ;$$0,,44T8DD 1 1 dhh 2qA  ,((00? ?||DOO,,rSc,[UR5er)rrv)rLrr;s rQ__set__"_DeprecatedFieldDescriptor.__set__sT__--rS)rvrrrpr)rrrUrpzproperty | NonerWrX)rr}rrUrWrX)rzBaseModel | Noner~ztype[BaseModel] | NonerWr )rr r;r rWr) rYrZr[r\r]rnrrr|rr^rTrSrQrnrns"O1 -.rSrnc6\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"U5Ulgr)_wrweakrefref)rLrs rQr_PydanticWeakRef.__init__ s ;DH{{3'DHrSc>URcgUR5$rrrs rQ__call___PydanticWeakRef.__call__s 88 88: rSc[U"544$r)rrs rQ __reduce___PydanticWeakRef.__reduce__s$&**rSrN)rr )rWr )rWz4tuple[Callable, tuple[weakref.ReferenceType | None]]) rYrZr[r\r]rrrr^rTrSrQrrs ( +rSrcUcg0nUR5Hup#[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)rrr)dresultrMrNproxys rQrrsX 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)rrEr)rrrMrNs rQrr/sWy F  a) * *A}q 1I  MrScSSKJn [[[[ [ U[/n[RS:aUR[R5 [U5$)Nr)ComputedFieldInfo)rl ) r+rrrrrr"rrrappendtypingr)rrs rQr,r,?sR* M 7"V112  rS)rbzLiteral[False]rWr r)rr rr rWzCallable[..., Any] | None) rr rr rr r6set[str]r7rrWzdict[str, ModelPrivateAttr])rr}rr rWrX)rr}rWr )rr}rr rzNsResolver | NonerWrX)rr}rr rr0rrrVrrrrWr)rr}rWrX)rdict[str, Any] | NonerWr)rWr )lr] __future__r _annotationsrQrrrFrabcrr rrrtypesrr r r r r rrr pydantic_corerrtyping_extensionsrrrrrtyping_inspectionrerrorsrrplugin._schema_validatorrrr_configr _decoratorsr!r"r#r$_fieldsr%r&r'r(_generate_schemar)r* _genericsr+r, _import_utilsr-r. _mock_val_serr/_namespace_utilsr0 _signaturer1 _typing_extrar2r3r4r5_utilsr6r7r+r8PydanticModelFieldr9r:r;PydanticModelPrivateAttrmainr<rV __setattr__rrr>rdrerirurrrrCrrrarnrrrr,rTrSrQrs(2 ++ZZZ=bb,C>O"ssoo@FM*(3 944@ %x## )$ )$!   T]T=OQikv