jqhdZddlmZddlZddlZddlZddlZddlZddl Z ddl m Z ddl m Z mZddlmZddlmZmZmZmZmZddlZddlmZmZdd lmZmZd d lmZmZd d lm Z d d lm!Z!m"Z"ddl#m$Z$ddl%m&Z&m'Z'm(Z(m)Z)ddl*m+Z+m,Z,m-Z-ddl.m/Z/ddl0m1Z1m2Z2ddl3m4Z4m5Z5ddl6m7Z7ddl8m9Z9ddl:m;Z;ddlZ>m?Z?m@Z@mAZAmBZBddlCmDZDmEZEddlFmGZGejrd dlImJZKd dlImLZLmMZMd dlImNZOd dlPmQZQne"ZReSZKeSZOeSjZUGdd eVZWd!d" d9d#ZXed$eKeOeXf%Gd&d'e ZYd:d(ZZd;d)Z[ dd,Z^ d?d-Z_d$dd. d@d/Z`dAd0ZaGd1d2ZbGd3d4ZcdBd5ZddBd6Zee d7dCd8Zfy)Dz"Private logic for creating models.) annotationsN)ABCMeta) lru_cachepartial) FunctionType)AnyCallableGenericLiteralNoReturn)PydanticUndefinedSchemaSerializer)dataclass_transform deprecated)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)CallbackGetCoreSchemaHandler)generate_pydantic_signature)_make_forward_refeval_type_backport is_annotated is_classvarmerge_cls_and_parent_nsparent_frame_namespace)ClassAttributeSafeGetItemProxy)ValidateCallWrapper)Field) FieldInfoModelPrivateAttr) PrivateAttr) BaseModelc$eZdZdZdfd ZxZS)_ModelNamespaceDictz{A dictionary subclass that intercepts attribute setting on model classes and warns about overriding of decorators. c|j|d}|rD||ur@t|tr0tjd|d|j j dt|!||S)N`z"` overrides an existing Pydantic `z ` decorator) get isinstancerwarningswarndecorator_infodecorator_reprsuper __setitem__)selfkvexisting __class__s s/home/oem/CyberBrain26-unified/dev-env/.venv/lib/python3.12/site-packages/pydantic/_internal/_model_construction.pyrAz_ModelNamespaceDict.__setitem__?scD) )jCZ.[ MMAaS B8CZCZCiCiBjjuv ww"1a(()rCstrrDobjectreturnNone)__name__ __module__ __qualname____doc__rA __classcell__rFs@rGr7r7:s))rHr7Finitcy)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. NrSs rG NoInitFieldrWGrHT)kw_only_defaultfield_specifiersceZdZ d d fd Zej sd dZeddZdfd Z e ddZ e e dddd Zdfd ZxZS)ModelMetaclassNc  !"|r|j|\}} } tj|||} | j|d<t || j | |} | s| r#t || d% fd } | |d<n t|d<| |d<i| | |d<t#|$||||fi|}t}|j}t|vrG|jt|j|kr tjt!dd t#|j$d d  |_|j(|j(urdnd|_t-j.||_|r ||_n[t#|d ij5d d"t#|ddxs"!!r"rt7!fd"Dsddlm}t="fd!D}|"vrZ|!vrVdj?|Dcgc]}|j@c}}|j@d|d|j@d|d}tE|"|z}dj?|Dcgc] }tC|c}}d|d}d|d}t|vrCdj?|Dcgc]}|j@c}|gz}|d|j@d|dz }tE|dd!d|_d |_#| jID]\}}|jK|||rtMtO|_(t#|d d}tS|tTr tW|}tY||}t[||| || j\rd!|vr t_||ta||| d ||"|j0jbjIDcic]\}}||jdc}}|_3ti|t||di||Sd#D]}|jm|d|j5d$ijot#|$||||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. model_configNc0t||||y)zWe need to both initialize private attributes and call the user-defined model_post_init method. N)init_private_attributes)rBcontextoriginal_model_post_inits rGwrapped_model_post_initz7ModelMetaclass.__new__..wrapped_model_post_init{s0g>0w?rHmodel_post_init__class_vars____private_attributes__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__ parametersrV__parameters__c3&K|]}|v ywNrV).0xrks rG z)ModelMetaclass.__new__..s?kTUZ?ks)RootModelRootTypec3,K|] }|vs| ywrnrV)rorpparent_parameterss rGrqz)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): ...`))originargsrk__pydantic_parent_namespace____hash__) raise_errorstypes_namespacecreate_model_module)__pydantic_fields_set____pydantic_extra____pydantic_private____annotations__rBr5rarrKrL)8_collect_bases_datar for_model config_dictinspect_namespace ignored_typesget_model_post_initr`r@__new__r#__mro__r indexr<r=rgetattr__init____pydantic_custom_init__rd__pydantic_post_init__rbuild__pydantic_decorators__rjr:all root_modelrrtuplejoinrMrI TypeError__pydantic_complete__items __set_name__build_lenient_weakvaluedictr-rzr;dictunpack_lenient_weakvaluedictr,set_model_fieldsfrozenset_default_hash_funccomplete_model_classcomputed_fieldsinfomodel_computed_fieldsset_deprecated_descriptors__pydantic_init_subclass__popclear)$mcscls_namebases namespacerj#__pydantic_reset_parent_namespace___create_model_modulekwargsbase_field_names class_varsbase_private_attributesconfig_wrapperprivate_attributesrcclsr5mrorrmissing_parametersrpparameters_str error_messagecombined_parametersgeneric_type_label bases_strnameobjparent_namespacer}rCrD instance_slotrbrkrtrFs$ @@@rGrzModelMetaclass.__new__Ss6 DGD[D[\aDb A j*A*44UIvNN(6(B(BIn %!2>77EU" "%<+>y%+P(+7@4KI/03JI/0*4I& '2c5L2cPb2cI. /#(7?3%#]V\#]C02I++C#~#))G"4syy7K"K 1B ! 07s||E]_d/e+eC (141D1D HaHa1agxC &*8*>*>s*CC '-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+ ,34OPfPh4i1&s,KTR *D1#?@P#Q 5c;KLO S% I$$9)D%c51 " /$8  @C?Z?Z?j?j?p?p?r(stq!AFF(sC % &s + #s 6 @ @J"i   !  MM+R 0 6 6 87?3%MfM M]4\4Y3NT)ts%P/P4<P9'P>cd|jjd}|r ||vr||St|)zNThis is necessary to keep attribute access working for class attribute access.rf)__dict__r:AttributeError)rBitemrs rG __getattr__zModelMetaclass.__getattr__s9!%!2!23K!L !d.@&@)$// & &rHctSrn)r7)rryrs rG __prepare__zModelMetaclass.__prepare__s "$$rHc>t|dxrt| |S)zsAvoid calling ABC _abc_subclasscheck unless we're pretty sure. See #3829 and python/cpython#92810 __pydantic_validator__)hasattrr@__instancecheck__)rBinstancerFs rGrz ModelMetaclass.__instancecheck__ s# x!9:buw?XYa?bbrHc>t}t}t}i}|D]t}t||s||us|jt |dij |j|j |j|jv|||fS)N model_fields)r#set issubclassupdaterkeysrerf)rr5 field_namesrrbases rGrz"ModelMetaclass._collect_bases_datas,. # "u :< GD$ *t9/D""74#D#I#I#KL!!$"5"56"))$*E*EF  G J(:::rHEThe `__fields__` attribute is deprecated, use `model_fields` instead.)categorycNtjdt|jS)Nr)r<r=rrrBs rG __fields__zModelMetaclass.__fields__"s$  SUn    rHc`tt| }d|vr|jd|S)Nr)listr@__dir__remove)rB attributesrFs rGrzModelMetaclass.__dir__*s0%'/+, : %   l +rH)NTN)rrIrtuple[type[Any], ...]rdict[str, Any]rjzPydanticGenericMetadata | Nonerboolr str | NonerrrKtype)rrIrKr)ryrrrrKzdict[str, object])rrrKr)rrrKz6tuple[set[str], set[str], dict[str, ModelPrivateAttr]])rKzdict[str, FieldInfo])rKz list[str])rMrNrOrtyping TYPE_CHECKINGr classmethodrr staticmethodrpropertyrrrrQrRs@rGr\r\QsIM48+/iNiN%iN" iN (F iN .2 iN)iNiN iNV    '%%c ; ;Wbfg!h! rHr\ct|ddPi}|jjD]#\}}|j}|tus|||<%t |d|yy)a This 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)rrfr get_defaultr object_setattr)rBrapydantic_privater private_attrdefaults rGr`r`1stt+T2:"&"="="C"C"E 1 D,"..0G//)0 & 1 t35EF ;rHcbd|vr|dSt}t|d}||jur|Sy)zaGet the `model_post_init` method from the namespace or the class bases, or `None` if not defined.rdN)r#rrd)rrr5rds rGrrCsDI%*++(*I.u6GHOi7778rHc Vddlmm}t}|t z}i}|j di}d|vsd|vr t dt} t|jD]\} } | dk(s| dk(rt| tr5| j|dk(r#d |vr| jj|d rWt| |s| jjd k(r| j!| t| rI| jd rt#d | d t%| rt#dd| zd| d | || <|| =t| |r2t%| s'| j'dxsd} t#d| d| d | jd r4t)| r%| |vst+|| rS|| || <|| =d| |vrj| |vsp| |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?|r4tAjB|^}}tEfd#|Dd}|||| <||| <|S#t"t f$rY^wxYw)$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)r3r4r__root__zUTo define root models, use `pydantic.RootModel` rather than a field called '__root__'r^rrNrO functools__zXPrivate attributes must not use dunder names; use a single underscore prefix instead of rvzJPrivate 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|ywrn)r;)rorDr3s rGrqz$inspect_namespace..s$\1JqJZ<[Q$\s)#fieldsr3r4r$default_ignored_typesr:rrrrr;rrNrO startswithrFadd NameErrorrlstriprr+rrrIsys _getframer)r( f_globalsf_localsr*typing_extensionsget_argsnext)rrbase_class_varsbase_class_fieldsr4r2all_ignored_typesrraw_annotations ignored_namesvar_namevaluesuggested_nameann_nameann_typeframermetadatarr3s @rGrrOs47(*I%(=(??68mm$5r:O_$ i(?opp!eM  12;% ~ %5I)I  ud #  Il$;;)+""--i.GH  0 1U__5O5OS^5^   h '  / 0""4(BBJQP%X.//2X~.@ XLXY[,1 x ((# y )2Eh2O%__S1?ZN,/|Hz make_hash_func..rXrHc t|jS#t$r'tt|jcYSwxYwrn)hashrKeyErrorr/)rBgetters rG hash_funcz!make_hash_func..hash_funcsJ At}}-. . A / >?@ @  As-A A)rBrrKint)roperator itemgetterr)rr!r s @rGrrs;>A>N>NX #"2"2"7"7"9 :T_FA rHc$t|}t|||||\}}||_|jj ||D]K}|j j |d}|"|jtus5t|||jMy)a.Collect and set `cls.model_fields` and `cls.__class_vars__`. Args: cls: BaseModel or dataclass. bases: Parents of the class, generally `cls.__bases__`. config_wrapper: The config wrapper instance. types_namespace: Optional extra namespace to look for types in. ) typevars_mapN) r"rrrerrfrrr setattr) rrrr}r&rrrCrs rGrrs*#.L-c5./htuFJCj)  +**..q$7  6G!G CEMM * +rH)r|r~c t|}t|||}tt|jd|d}|j rd|j vr t||y |j||} |j|} |j| } | |_t| ||xs |j |j"|rdnd | |j$|_t)| | |_d |_t/d t1|j2|j4| |_y #t$r(} |rt||d| jdYd} ~ yd} ~ wwxYw#|j$rt||YywxYw) 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. types_namespace: Optional extra namespace to look for types in. 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_modemodelr9N create_modelr5T __signature__)rTrr)r"r r&rgenerate_schema defer_buildexperimental_defer_build_moder%__get_pydantic_core_schema__rr core_config clean_schemaCollectedInvalid__pydantic_core_schema__rrNrOplugin_settingsrr__pydantic_serializer__rr.r'rrr.) rrrr|r}r~r& gen_schemahandlerschemaer3s rGrrs:*#.LJ + **NG !!g1]1]&]X&11#w?!,,S1K((0 $*C !8 -s~~ -;&&"C#36;"GC $C'#c>N>N_mnC E '  X166(!}5   & &X&s*$D&E& E/EEE87E8c|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_DeprecatedFieldDescriptorrr'rrrwrapped_property)rfield field_infomsgdesccomputed_field_infos rGrrgs --335&z11 1C >-c2D   c5 ) C % & '*&?&?&E&E&G&""';; ;S H34G4X4XY[kl-c3F3W3WXD   c5 ) C %&rHc@eZdZUdZded<d d dZd dZd d dZd dZy)r@aMData 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. rI field_nameNc ||_||_yrn)rDrA)rBrDrAs rGrz#_DeprecatedFieldDescriptor.__init__s 0rHc||_yrn)rH)rBrrs rGrz'_DeprecatedFieldDescriptor.__set_name__s rHc|t|jtj|jt j d|j|jj||S|j|jS)Nrrg) rrHr<r=rDbuiltinsDeprecationWarningrA__get__r)rBrobj_types rGrNz"_DeprecatedFieldDescriptor.__get__sh ; 1 1 dhh ; ;J  ,((00h? ?||DOO,,rHc,t|jrn)rrH)rBrrs rG__set__z"_DeprecatedFieldDescriptor.__set__sT__--rHrn)rDrIrAzproperty | NonerKrL)rtype[BaseModel]rrIrKrL)rzBaseModel | NonerOztype[BaseModel] | NonerKr)rrrrrKr ) rMrNrOrPrrrrNrQrVrHrGr@r@zs"O1-.rHr@c(eZdZdZddZddZddZy) _PydanticWeakRefaWrapper 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`). cL|d|_ytj||_yrn)_wrweakrefref)rBrs rGrz_PydanticWeakRef.__init__s ;DH{{3'DHrHc<|jy|jSrn)rVrs rG__call__z_PydanticWeakRef.__call__s 88 88: rHct|ffSrn)rTrs rG __reduce__z_PydanticWeakRef.__reduce__s$&**rHN)rr)rKr)rKz4tuple[Callable, tuple[weakref.ReferenceType | None]])rMrNrOrPrrZr\rVrHrGrTrTs ( +rHrTc|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)rrTr)dresultrCrDproxys rGrrsa y F 1 $Q'Eq  M E s 1 ??c|yi}|jD]*\}}t|tr|}| |||<&|||<,|S)zAInverts the transform performed by `build_lenient_weakvaluedict`.N)rr;rT)r^r_rCrDs rGrrsXy F 1 a) *A}q F1I  MrH)maxsizecPddlm}tttt t |tfS)NrComputedFieldInfo)rrerrrrrr0rds rGrrs&*  rH)rTzLiteral[False]rKrr)rrrrrKzCallable[..., Any] | None) rrrrr set[str]r rfrKzdict[str, ModelPrivateAttr])rrRrrrKrL)rrRrKr) rrRrrrrr}rrKrL)rrRrrIrrr|rr}dict[str, Any] | Noner~rrKr)rrRrKrL)r^rgrKrg)rKr)grP __future__r _annotationsrLr#rrr<rWabcrrrrtypesrrr r r r r pydantic_corer rrrerrorsrrplugin._schema_validatorrrr_configr _decoratorsrrrr_fieldsrrr_generate_schemar _genericsr!r" _import_utilsr#r$ _mock_val_serr%_schema_generation_sharedr& _signaturer' _typing_extrar(r)r*r+r,r-_utilsr.r/_validate_callr0rrr1PydanticModelFieldr2r3r4PydanticModelPrivateAttrmainr5rMrJ __setattr__rrr7rWr\r`rrrrrrrr@rTrrrrVrHrGrs(2 (<<==C>O"ssYY,FM*C35/ 44@ 3%x## )$ )!  T=OQikv