KirdZddlmZddlZddlZddlZddlZddlZddl m Z ddl m Z m Z mZddlmZddlmZmZmZmZmZmZmZmZddlmZmZdd lmZmZmZm Z m!Z!dd l"m#Z#d d l$m%Z%m&Z&d d l'm(Z(d dlm)Z)m*Z*ddl+m,Z,ddl-m.Z.m/Z/m0Z0m1Z1ddl2m3Z3m4Z4m5Z5m6Z6ddl7m8Z8m9Z9ddl:m;Z;mZ>m?Z?ddl@mAZAddlBmCZCddlDmEZEddlFmGZGmHZHmIZImJZJddlKmLZLmMZMer!d dlNmOZPd dlNmQZQmRZRd dlNmSZTd dlUmVZVddl2mWZWneXZPeXZTeXjZZGd d!e[Z\d"d# d:d$Z]ed%Z^ed&ePeTe]f'Gd(d)e Z_d;d*Z`dd-Zcd?d.Zd d@d/Zed&d&dd"d0 dAd1ZfdBd2ZgGd3d4ZhGd5d6ZidCd7ZjdCd8Zke dDd9Zly)Ez"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) BaseModel)PydanticExtraInfoc$eZdZdZdfd ZxZS)_ModelNamespaceDictz{A dictionary subclass that intercepts attribute setting on model classes and warns about overriding of decorators. c|j|d}|rF||urBt|tr2tjd|d|j j ddt|!||S)N`z"` overrides an existing Pydantic `z ` decoratorr stacklevel) get isinstancer"warningswarndecorator_infodecorator_reprsuper __setitem__)selfkvexisting __class__s r/home/jay/workspace/scripts/.codegraph-venv/lib/python3.12/site-packages/pydantic/_internal/_model_construction.pyrKz_ModelNamespaceDict.__setitem__9skD) )jCZ.[ MMA389P9P9_9_8``kl  w"1a(()rMstrrNobjectreturnNone)__name__ __module__ __qualname____doc__rK __classcell__rPs@rQr?r?4s))rRr?Finitcy)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. Nr]s rQ NoInitFieldraDrR_TT)kw_only_defaultfield_specifiersceZdZ d d fd ZesddZeddZdfd Ze jZ e jZ e ddZ eedddd Zedd Zdfd ZxZS)ModelMetaclassNc  %&'|rtjdk\r6d|vr|d}n>ddlm} m} m} | |x} r| | | j }ni}n|jdi}|j|\} }}tj||||}|j|d<t|||j|| }|s|r1t||%%t%d.%fd }||d <n t |d <||d <i|||d <t#d t%(|L||||fi|}t)}|j*}t,|vrG|j/t,|j/|kr t1j2t5d dt7|j8dd |_|j<|j<urdnd |_i|_ tCjD|d|_#|jFjI||r ||_%n[t7|dijdd't7|ddxs'&&r'rtM&fd'Dsddl'm(}tS'fd&D}|'vrZ|&vrVdjU|Dcgc]}|jVc}}|jVd|d|jVd|d}t[|'|z}djU|Dcgc] }tY|c}}d |d!}d"|d#}t,|vrCdjU|Dcgc]}|jVc}|gz}|d$|jVd%|d&z }t[|dd&d'|_%d|_.|j_D]\}}|ja|||rtcte|_3t7|d(d} ti| tjr tm| } to| )}!tq|||!*|jFjrj_D"#cic]\}"}#|"|#jtc}#}"|_;|jxr t{|nt}|||!d|+|j~rd,|vr t||t%||di||Sd-D]}$|j|$d|jdijt%(|L||||fi|Scc}wcc}wcc}wcc}#}"w)/aMetaclass 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_configNc0t||||y)zWe 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_initz7ModelMetaclass.__new__..wrapped_model_post_inits 0g>0w?rRmodel_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__FT)replace_wrapped_methods__pydantic_generic_metadata__ parametersr`__parameters__c3&K|]}|v ywNr`).0xr}s rQ z)ModelMetaclass.__new__..s?kTUZ?ks)RootModelRootTypec3,K|] }|vs| ywrr`)rrparent_parameterss rQrz)ModelMetaclass.__new__..s.cQQbHbq.cs 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<rsr rUrV)Dsys version_info annotationlibrlrmrn FORWARDREFrD_collect_bases_datar for_model config_dictinspect_namespace ignored_typesget_model_post_initrrrrrJ__new__r-__mro__r indexrFrGrgetattr__init____pydantic_custom_init__rv__pydantic_post_init____pydantic_setattr_handlers__r!build__pydantic_decorators__update_from_configr|all root_modelrtuplejoinrWrS 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_annotationsrlrmrnannotatebase_field_names class_varsbase_private_attributesrprivate_attributesrucls BaseModel_mrormissing_parametersrparameters_str error_messagecombined_parametersgeneric_type_label bases_strnameobjrrrMrN instance_slotrtr}rrPs) @@@rQrzModelMetaclass.__new__Tsp6 7*%2&/0A&BOpo#DY#OOxO*@RXRcRc*d*,"+--0A2"FDGD[D[\aDb A j*A*44UIX^_N(6(B(BIn %!2?N,H,H*Vf" "%<+>y%+P(+734@5@4KI/03JI/0*4I& '2c5L2cPb2cI. /(%'/#xPY*d]c*deC13J++C#~#))G"4syy7L"L 1B ! 07s||E]_d/e+eC (++z/I/IIO`  &13C -*8*>*>s\`*aC '  ' ' : :> J-4Q1$+C1PRT$U$Y$YZfhj$k!$S*:DAVEV "3C?kYj?k)..c*.c)c&(,==BS[eBe*.HZ3[1AJJ3[)\"||n,-./WWZWcWcVddop~o@IJ&,$M22!/@BT.T+)-DW3XqCF3X)Y/>~>Na-P*88J7K1N&#%/ )- u2M!1::2MQcPd2d(eI)"OPSP\P\~]^_h^iiq rM$M22#",51 ).C %0557 , c  d+ ,34OPfPh4i16=cCbdh6i *D1#?@P#Q $6FGK S[ Y '*&A&A&Q&Q&W&W&Y0"a166 0C ,))$%"!&(< $$9)D%c51 #s 6 @ @J"i   !  MM+R 0 6 6 87?3%MfM Mg4\4Y3N>0s>SSSS$cd|jjd}|r ||vr||St|)zNThis is necessary to keep attribute access working for class attribute access.rx)__dict__rDAttributeError)rLitemrs rQ __getattr__zModelMetaclass.__getattr__s9!%!2!23K!L !d.@&@)$// & &rRctSr)r?)rrrs rQ __prepare__zModelMetaclass.__prepare__$s "$$rRcltjd|jddt||S)Nz>For performance reasons, virtual subclasses registered using 'zK.register()' are not supported in 'isinstance()' and 'issubclass()' checks.rrB)rFrGrYrJregister)rLsubclassrPs rQrzModelMetaclass.register,s? LTM^M^L_`M M w))rRc>t}t}t}i}|D]t}t||s||us|jt |dij |j|j |j|jv|||fS)N__pydantic_fields__)r-set issubclassupdaterkeysrwrx)rr< field_namesrrbases rQrz"ModelMetaclass._collect_bases_data7s,. # "u :< GD$ *t9/D""741F#K#P#P#RS!!$"5"56"))$*E*EF  G J(:::rRXThe `__fields__` attribute is deprecated, use the `model_fields` class property instead.)categorycTtjdtdt|diS)NrrrBr)rFrGrrrLs rQ __fields__zModelMetaclass.__fields__Fs+  f % t2B77rRcd|jvrytd|j}td|j}| |j}nd}t d|j Dxr|S)zWhether the fields were successfully collected (i.e. type hints were successfully resolved). This is a private attribute, not meant to be used outside Pydantic. rFdict[str, FieldInfo]zPydanticExtraInfo | NoneTc34K|]}|jywr) _complete)r field_infos rQrz>ModelMetaclass.__pydantic_fields_complete__..csOJ:''Os)rrr__pydantic_extra_info__completervalues)rL field_infospydantic_extra_infoextra_completes rQ__pydantic_fields_complete__z+ModelMetaclass.__pydantic_fields_complete__Rsp ! 5143K3KL "#=t?[?[\  *099N!NO+:L:L:NOObTbbrRc`tt| }d|vr|jd|S)Nr)listrJ__dir__remove)rL attributesrPs rQrzModelMetaclass.__dir__es0%'/+, : %   l +rR)NTN)rrSrtuple[type[Any], ...]rdict[str, Any]r|zPydanticGenericMetadata | Nonerboolr str | Nonerr rUtype)rrSrUr )rr rr rUzdict[str, object])rtype[_T]rUr)rrrUz6tuple[set[str], set[str], dict[str, ModelPrivateAttr]])rUr)rUr)rUz list[str])rWrXrYrr r classmethodrrr__instancecheck____subclasscheck__ staticmethodrpropertyrrrrr[r\s@rQrgrgRs IM48+/DNDN%DN" DN (F DN .2 DN)DNDN DNL  '%%*.... ; ;bmq88cc$rRrgct|ddi}|jjD]S\}}|jr"|j di|j |}n|j d}|t usO|||<Ut|d|yy)a This function is meant to behave like a BaseModel method to initialize 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. rNT)call_default_factoryvalidated_data)r)rrxr$default_factory_takes_validated_data get_defaultrrobject_setattr)rLrspydantic_privater private_attrdefaults rQrrrrlst+T2:"&"="="C"C"E 1 D,@@&22)->c>cRb>c3'222M//)0 & 1 t35EF;rRcbd|vr|dSt}t|d}||jur|Sy)zaGet the `model_post_init` method from the namespace or the class bases, or `None` if not defined.rvN)r-r#rv)rrr<rvs rQrrsDI%*++(*I.u6GHOi7778rRc ^ddlmm}t}|t z}i}d|vsd|vr t dt } t|jD]\} } | dk(s| dk(rt| tr8| j|dk(r&d|vr"| jj|dd rZt| |s| jjd k(r| j| t| rI| jd rt!d | d t#| rt!d d| zd| d | || <|| =t| |r2t#| s'| j%dxsd} t!d| d| d | jd r7t'| r/| |vst)|| rVt+|| || <|| =q| |vrw| |vs}| |vrt-d| ddt| |rt-d| ddt-d| d| d| dd|jD]\} }t'| s| |vs| | vst)|r(||vs-t/|ddd k7s>t|t0rFt3j4d}|/ t7t9|dd |j:|j<!}t?j@tC|r*tE|^}}tGfd"|Dd}|||| <||| <|S#t t f$rYgwxYw)#aLIterate 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 containing 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__'rprrXrYr 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)globalnslocalnsc3<K|]}t|s|ywr)rE)rrNr:s rQrz$inspect_namespace..s$\1JqJZ<[Q$\s)$fieldsr:r;r.default_ignored_typesrrrrrErrXrY startswithrPadd NameErrorr&lstripr'r4rrrrSr _getframer3r2 f_globalsf_localsr is_annotatedrrnext)rrrbase_class_varsbase_class_fieldsr;r9all_ignored_typesr ignored_namesvar_namevaluesuggested_nameann_nameann_typeframermetadatarr:s @rQrrs87(*I%(=(??68_$ i(?opp!eM  12;% ~ %5I)I  ud #  Il$;;)+""-->1J0K1.MN  0 1U__5O5OS^5^   h '  / 0""4(BBJQP%X.//2X~.@ XLXY[,1 x ((# y )2Eh2O%__S1?ZN,/|Hz make_hash_func..'rbrRc t|jS#t$r'tt|jcYSwxYwr)hashrKeyErrorr7)rLgetters rQ hash_funcz!make_hash_func..hash_func)sJ At}}-. . A / >?@ @  As-A A)rLr rUint)roperator itemgetterr)rrFrEs @rQr<r<&s;EHE\E\X #"9"9">">"@ AbmFA rRc2t|}t||||\}}}||_||_|jj ||D]K}|j j|d}|"|jtus5t|||jMy)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%rrrwrrxrrrsetattr) rrrrKr$rrrMr4s rQrr6s*#.L.B ^[|/+F %C"5Cj)  +**..q$7  6G!G CEMM * +rR)rcall_on_complete_hookris_force_rebuildc t|}|js: t||||\|_|_|s |jsy|jsJt|||} | j|} |j|j} | j| } |j j"j%D cic]\} }| |j&c}} |_t+|| |_t/| ||xs |j0|j2|rdnd| |j4| |_t9| | | |_t=d t?t@|jB|j|jD|jF |_$d |_%|r|jMy #t $r?}t j|} t|d| jd|r| |Yd}~d}~wwxYw#t $r'}|rt|d|jdYd}~yd}~wwxYw#t$rt|YywxYwcc}} w) 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`. is_force_rebuild: Whether the model is being force-rebuilt (if True, pre-built serializers and validators are not used, to avoid stale references). Returns: `True` if the model is successfully completed, else `False`. Raises: PydanticUndefinedAnnotation: If PydanticUndefinedAnnotation occurs in __get_pydantic_core_schema__ and `raise_errors=True`. )rrrKrANF)title create_modelr<) _use_prebuilt __signature__)r^r$validate_by_nameextraT)'r,rr(rrr(rfrom_name_errorr/rr)generate_schema core_configrW clean_schemar*rrrrrset_deprecated_descriptors__pydantic_core_schema__rrXrYplugin_settings__pydantic_validator__r__pydantic_serializer__r6rr1rrTrUrSr__pydantic_on_complete__)rrrrrMrrNrKeexc gen_schemaschemarXrMrNs rQrrXsG@*#.L  + + !CW-') D @C #S%@C$D$D////J ++C0!,,3<<,@K((0?B>Y>Y>i>i>o>o>q'rda166 'rC$s##)C !8 -s~~ -;&&** "C#36;ZjVj"kC + '**+<< &&   C!%C $$& S !-==a@C C1SXXJa 1q  !( '  q]+   (ssGF0 G;H.I0 G894G33G8; H+H&&H+.IIc|jjD]>\}}|jx}t|}|j ||t |||@|j jD]i\}}|jx}tt|jdr5t||j}|j ||t |||ky)z8Set data descriptors on the class for deprecated fields.N__deprecated__) rrdeprecation_message_DeprecatedFieldDescriptorrrLrhasattrr$wrapped_property)rfieldrmsgdesccomputed_field_infos rQrZrZs 44::<&z11 1C >-c2D   c5 ) C % & '*&F&F&L&L&N&""';; ;S H34G4X4XY[kl-c3F3W3WXD   c5 ) C %&rRc@eZdZUdZded<d d dZd dZd d dZd dZy)rgaWRead-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. rS field_nameNc ||_||_yr)rkri)rLrkris rQrz#_DeprecatedFieldDescriptor.__init__s 0rRc||_yr)ro)rLrrs rQrz'_DeprecatedFieldDescriptor.__set_name__s rRcN|=|j|jjd|St|jt j |j td|j|jj||S|j|jS)NrrB) ri__get__rrorFrGrkDeprecationWarningr)rLrobj_types rQrsz"_DeprecatedFieldDescriptor.__get__s ;$$0,,44T8DD 1 1 dhh 2qA  ,((00h? ?||DOO,,rRc,t|jr)rro)rLrr4s rQ__set__z"_DeprecatedFieldDescriptor.__set__sT__--rRr)rkrSrizproperty | NonerUrV)rryrrSrUrV)rzBaseModel | Noneruztype[BaseModel] | NonerUr )rr r4r rUr) rWrXrYrZrkrrrsrwr`rRrQrgrgs"O1 -.rRrgc(eZdZdZddZddZddZy) _PydanticWeakRefaWrapper for `weakref.ref` that enables `pickle` serialization. Cloudpickle fails to serialize weakref.ref objects due to an arcane error related to 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`). cL|d|_ytj||_yr)_wrweakrefref)rLrs rQrz_PydanticWeakRef.__init__s ;DH{{3'DHrRc<|jy|jSr)r{rs rQ__call__z_PydanticWeakRef.__call__%s 88 88: rRct|ffSr)ryrs rQ __reduce__z_PydanticWeakRef.__reduce__+s$&**rRN)rr )rUr )rUz4tuple[Callable, tuple[weakref.ReferenceType | None]])rWrXrYrZrrrr`rRrQryry s ( +rRryc|yi}|jD]\}} t|}|||<|S#t$r|}YwxYw)aXTakes 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)rryr)dresultrMrNproxys rQrr/sa y F 1 $Q'Eq  M E s 1 ??c|yi}|jD]*\}}t|tr|}| |||<&|||<,|S)zAInverts the transform performed by `build_lenient_weakvaluedict`.N)rrEry)rrrMrNs rQrrCsXy F 1 a) *A}q F1I  MrRcddlm}tttt t |tg}tjdk\r|jtjt|S)Nr)ComputedFieldInfo)ri ) r$rrr r r r"rrrappendtypingr)rrs rQr%r%SsR* M 7"V112  rR)r^zLiteral[False]rUr r)rrrrrUzCallable[..., Any] | None) rrrrrrr/set[str]r0rrUzdict[str, ModelPrivateAttr])rryrrrUrV)rryrUr )rryrr rr0rUrV)rryrr rr0rrrMrrrrNrrUr)rryrUrV)rdict[str, Any] | NonerUr)rUr)mrZ __future__r _annotationsrHrrrFr|abcrrrrrtypesrr 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<r=rT __setattr__rrr?rarcrgrrrrrr<rrrZrgryrrr%r`rRrQrs+(2 ++ZZZ=bb,C>O"ssoo@FM*(3 944@ *%x## )$ )$!   T]T=OQikv