&V.jǏrdZddlmZddlZddlZddlZddlZddlZddl Z ddl m Z ddl m Z mZddlmZddlmZmZmZmZmZmZmZddlmZmZdd lmZmZmZmZd d l m!Z!m"Z"d d l#m$Z$d d lm%Z%m&Z&ddl'm(Z(ddl)m*Z*m+Z+m,Z,m-Z-ddl.m/Z/m0Z0m1Z1ddl2m3Z3ddl4m5Z5m6Z6ddl7m8Z8m9Z9ddl:m;Z;ddlm?Z?ddl@mAZAddlBmCZCmDZDmEZEmFZFmGZGddlHmIZImJZJejrd dlLmMZMmNZNmOZOd dlLmPZQd dlLmRZSd dlTmUZUne&ZVeWZQeWZSeWjZYGdd eZZ[d!d" d9d#Z\ed$eQeSe\f%Gd&d'e Z]d:d(Z^d;d)Z_ dd,Zb d?d-Zcd$ddd. d@d/ZddAd0ZeGd1d2ZfGd3d4ZgdBd5ZhdBd6Zie d7dCd8Zjy)Dz"Private logic for creating models.) annotationsN)ABCMeta) lru_cachepartial) FunctionType)AnyCallableGenericLiteralNoReturnTypeVarcast)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) 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 hC:\xampp\htdocs\tradingbinance\backend\.venv\Lib\site-packages\pydantic/_internal/_model_construction.pyrEz_ModelNamespaceDict.__setitem__=scD) )jCZ.[ MMAaS B8CZCZCiCiBjjuv ww"1a(()rGstrrHobjectreturnNone)__name__ __module__ __qualname____doc__rE __classcell__rJs@rKr;r;8s))rLr;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. NrWs rK NoInitFieldr[EsrLT)kw_only_defaultfield_specifiersceZdZ d dfd Zdfd Zej sddZeddZ dfd Z e ddZ e edd dd Ze dd Ze dd Zdfd ZxZS)ModelMetaclassNc  !"|r|j|\}} } tj|||} | j|d<t || j | |} | s| r#t || d' fd } | |d<n t|d<| |d<i| | |d<|r||d<tdt#|(||||fi|}t}|j}t|vrG|jt|j|kr tj t#d d t%|j&d d  |_|j*|j*urdnd|_t/j0||_|r ||_n[t%|dij7dd"t%|ddxs"!!r"rt9!fd"Dsd dlm}t?"fd!D}|"vrZ|!vrVdjA|Dcgc]}|jBc}}|jBd|d|jBd|d}tG|"|z}djA|Dcgc] }tE|c}}d|d}d|d}t|vrCdjA|Dcgc]}|jBc}|gz}|d|jBd|dz }tG|dd!d |_d |_$| jKD]\}}|jM|||rtOtQ|_)t%|d!d}tU|tVr tY|}t[|"}t]||| || j^rd#|vr ta||tc||| d ||$|j2jdjKDcic]\}}||jfc}}|_4tk|t||di||Sd%D]}|jo|d|j7d&ijqt#|(||||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)rFcontextoriginal_model_post_inits rKwrapped_model_post_initz7ModelMetaclass.__new__..wrapped_model_post_initys0g>0w?rLmodel_post_init__class_vars____private_attributes____pydantic_generic_metadata__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 parametersrZ__parameters__c3&K|]}|v ywNrZ).0xros rK z)ModelMetaclass.__new__..s?kYjTUZYjs)RootModelRootTypec3,K|] }|vs| ywrrrZ)rsrtparent_parameterss rKruz)ModelMetaclass.__new__..s.c*QQbHbq*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): ...`))originargsro__pydantic_parent_namespace__)parent_namespace__hash__ raise_errors ns_resolvercreate_model_module)__pydantic_fields_set____pydantic_extra____pydantic_private____annotations__rFr9rdrrOrP)9_collect_bases_datar for_model config_dictinspect_namespace ignored_typesget_model_post_initrcrrD__new__r'__mro__r indexr@rArgetattr__init____pydantic_custom_init__rg__pydantic_post_init__rbuild__pydantic_decorators__rjr>all root_modelrvtuplejoinrQrM TypeError__pydantic_complete__items __set_name__build_lenient_weakvaluedictr1r~r?dictunpack_lenient_weakvaluedictr*set_model_fieldsfrozenset_default_hash_funccomplete_model_classcomputed_fieldsinfo__pydantic_computed_fields__set_deprecated_descriptors__pydantic_init_subclass__popclear)$mcscls_namebases namespacerj#__pydantic_reset_parent_namespace___create_model_modulekwargsbase_field_names class_varsbase_private_attributesconfig_wrapperprivate_attributesrfcls BaseModel_mrorvmissing_parametersrtparameters_str error_messagecombined_parametersgeneric_type_label bases_strnameobjrrrGrH instance_slotrerorxrJs$ @@@rKrzModelMetaclass.__new__Qs6 DGD[D[\aDb A j*A*44UIvNN(6(B(BIn %!2>77EU" "%<+>y%+P(+7@4KI/03JI/0*4I& '2c5L2cPb2cI. /,=Z 9:(%'/#xPY*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&,$M22!/@BT.T+)-DW3XDWqCFDW3X)Y/>~>Na-P*88J7K1N&#%/ )- u2Mu!1::u2MQcPd2d(eI)"OPSP\P\~]^_h^iiq rM$M22#",51 ).C %0557 c  d+834OPfPh4i16=cCbdh6i *D1#?@P#Q $6FGK S% E$$9)D%c51 "'$8  '*&A&A&Q&Q&W&W&Y0&Yda166 &Y0C , 's + #s 6 @ @J"i  !"i MM+R 0 6 6 87?3%MfM Mc4\4Y3NV0s6QQ Q 8Qct|}|jtfk(r|S|jj d}|s|Sd}|d|d}}|s|S|j d}tt|||h}|g}|ddD]} t| dij d} t| dij dd} | |vrA| |vrg| ret| jksJ|tfd| D} | | } |j| |j| xs| | |j| xs| | |d us|j| |S) NrjzUnexpected error occurred when generating MRO of generic subclass. Please report this issue on GitHub: https://github.com/pydantic/pydantic/issues.r|r}rorrZc3(K|] }| ywrrrZ)rsparam param_dicts rKruz%ModelMetaclass.mro..$s%Q[Ej&7[s)rDr __bases__rN__dict__r>rjrziprsetkeysrappendadd)r original_mrogeneric_metadataassert_err_msgr|r} target_paramsindexed_originsnew_mrobase base_origin base_params new_base_argsnew_baserrJs @rKrzModelMetaclass.mrosw{} ==VI % ;><<;K;KLk;l o X & V $ <<\J #mT23 !($'5 $D29$@_ac2d2h2hiq2rK/6t=\^`/a/e/efrtv/wKo-_,;':??+<<LnL< %%Q[%Q Q  .x(##K$748*##K$748 72;&t$1%4rLcd|jjd}|r ||vr||St|)zNThis is necessary to keep attribute access working for class attribute access.ri)rr>AttributeError)rFitemrs rK __getattr__zModelMetaclass.__getattr__;s9!%!2!23K!L !d.@&@)$// & &rLctSrr)r;)rr}rs rK __prepare__zModelMetaclass.__prepare__Bs "$$rLc>t|dxrt| |S)zsAvoid calling ABC _abc_subclasscheck unless we're pretty sure. See #3829 and python/cpython#92810 __pydantic_validator__)hasattrrD__instancecheck__)rFinstancerJs rKrz ModelMetaclass.__instancecheck__Fs# x!9:buw?XYa?bbrLc>t}t}t}i}|D]t}t||s||us|jt |dij |j|j |j|jv|||fS)N__pydantic_fields__)r'r issubclassupdaterrrhri)rr9 field_namesrrrs rKrz"ModelMetaclass._collect_bases_dataMs,. # "u :<D$ *t9/D""741F#K#P#P#RS!!$"5"56"))$*E*EF  J(:::rLEThe `__fields__` attribute is deprecated, use `model_fields` instead.)categorycRtjdtd|jS)Nrrrl)r@rAr model_fieldsrFs rK __fields__zModelMetaclass.__fields__\s'  S %    rLct|diS)zGet metadata about the fields defined on the model. Returns: A mapping of field names to [`FieldInfo`][pydantic.fields.FieldInfo] objects. rrrs rKrzModelMetaclass.model_fieldsfst2B77rLct|diS)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_fieldsz$ModelMetaclass.model_computed_fieldsost;R@@rLc`tt| }d|vr|jd|S)Nr)listrD__dir__remove)rF attributesrJs rKrzModelMetaclass.__dir__xs0%'/+, : %   l +rL)NTN)rrMrtuple[type[Any], ...]rdict[str, Any]rjzPydanticGenericMetadata | Nonerboolr str | NonerrrOtype)rOzlist[type[Any]])rrMrOr)r}rrrrOzdict[str, object])rrrOr)rrrOz6tuple[set[str], set[str], dict[str, ModelPrivateAttr]])rOzdict[str, FieldInfo])rOzdict[str, ComputedFieldInfo])rOz list[str])rQrRrSrrtyping TYPE_CHECKINGr classmethodrr staticmethodrpropertyrrrrrrUrVs@rKr_r_OsIM48+/oNoN%oN" oN (F oN .2 oN)oNoN oNb4l    '%%c ; ;Wbfg!h!88AArLr_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)rrir get_defaultrobject_setattr)rFrdpydantic_privater private_attrdefaults rKrcrcspt+T2:"&"="="C"C"E D,"..0G//)0 &#F t35EF ;rLcbd|vr|dSt}t|d}||jur|Sy)zaGet the `model_post_init` method from the namespace or the class bases, or `None` if not defined.rgN)r'rrg)rrr9rgs rKrrsDI%*++(*I.u6GHOi7778rLc 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+|| rSt-|| || <|| =n| |vrt| |vsz| |vrt/d| ddt| |rt/d| ddt/d| d| d| dd|jD]\} }t)| s| |vs| | vst+|r(||vs-t1|ddd k7s>t|t2rFt5j6d}|/ t9t;|dd !|j<|j>"}tA|r*tC|^}}tEfd#|Dd}|||| <||| <|S#t"t f$rYTwxYw)$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)r6r8r__root__zUTo define root models, use `pydantic.RootModel` rather than a field called '__root__'rarrRrS functools__zXPrivate attributes must not use dunder names; use a single underscore prefix instead of rzzJPrivate 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 )r zField 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|ywrr)r?)rsrHr6s rKruz$inspect_namespace..s$\1JqJZ<[Qs)#fieldsr6r8r(default_ignored_typesr>rrrrr?rrRrS startswithrJr NameErrorr"lstripr#r0rrrrMsys _getframer.r- f_globalsf_localsr/rnext)rrbase_class_varsbase_class_fieldsr8r5all_ignored_typesrraw_annotations ignored_namesvar_namevaluesuggested_nameann_nameann_typeframermetadatar r6s @rKrrs47(*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..3slmrLc t|jS#t$r'tt|jcYSwxYwrr)hashrKeyErrorr3)rFgetters rK hash_funcz!make_hash_func..hash_func5sJ At}}-. . A / >?@ @  As-A A)rFrrOint)roperator itemgetterr)rr<r;s @rKr2r22s;EHE\E\X #"9"9">">"@ AbmFA rLc$t|}t|||||\}}||_|jj ||D]K}|j j |d}|"|jtus5t|||jMy)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!rrhrrirr rsetattr) rrrrrArrrGr*s rKrrBs*#.L-c5.+dpqFJ$Cj) **..q$7  6G!G CEMM *rLrc $|jr t||yt|}t|||}t t |j d|d} |j||} |j|j} |j| } | |_t| ||xs |j |j"|rdnd | |j$|_t)| | |_d |_t/d t t0|j2|j4|j6|j8 |_y #t$r(} |rt||d| jdYd} ~ yd} ~ wwxYw#|j$rt||YywxYw) a&Finish 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_modelr9T __signature__)rXrpopulate_by_nameextra) defer_buildr)r&r$r+rgenerate_schema__get_pydantic_core_schema__rr core_configrQ clean_schemaCollectedInvalid__pydantic_core_schema__rrRrSplugin_settingsrr__pydantic_serializer__rr2r,rrrJrKrI) rrrrrrrA gen_schemahandlerschemaerOs rKrrcs:!!X&)#.LJ + **NG 11#w?!,,3<<,@K((0 $*C !8 -s~~ -;&&"C#36;"GC $C + '**+<< &&   C U '  X166(!}5   & &X&s*D=E1= E.E))E.1FFc|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_DeprecatedFieldDescriptorrrBrrr wrapped_property)rfield field_infomsgdesccomputed_field_infos rKrrs 44::<z11 1C >-c2D   c5 ) C % = '*&F&F&L&L&N""';; ;S H34G4X4XY[kl-c3F3W3WXD   c5 ) C %'OrLc@eZdZUdZded<d d dZd dZd d dZd dZy)r\aWRead-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. rM field_nameNc ||_||_yrr)r`r])rFr`r]s rKrz#_DeprecatedFieldDescriptor.__init__s 0rLc||_yrr)rd)rFrrs rKrz'_DeprecatedFieldDescriptor.__set_name__s rLcb|=|j|jjd|St|jt j |j tjd|j|jj||S|j|jS)Nrrl) r]__get__rrdr@rAr`builtinsDeprecationWarningr)rFrobj_types rKrhz"_DeprecatedFieldDescriptor.__get__s ;$$0,,44T8DD 1 1 dhh ; ;J  ,((00h? ?||DOO,,rLc,t|jrr)rrd)rFrr*s rK__set__z"_DeprecatedFieldDescriptor.__set__sT__--rLrr)r`rMr]zproperty | NonerOrP)rrkrrMrOrP)rzBaseModel | Nonerkztype[BaseModel] | NonerOr)rrr*rrOr ) rQrRrSrTrrrrhrmrZrLrKr\r\s"O1 -.rLr\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||_yrr)_wrweakrefref)rFrs rKrz_PydanticWeakRef.__init__ s ;DH{{3'DHrLc<|jy|jSrr)rqrs rK__call__z_PydanticWeakRef.__call__s 88 88: rLct|ffSrr)rors rK __reduce__z_PydanticWeakRef.__reduce__s$&**rLN)rr)rOr)rOz4tuple[Callable, tuple[weakref.ReferenceType | None]])rQrRrSrTrrurwrZrLrKroros ( +rLroc|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)rror)dresultrGrHproxys rKrrs\ 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?ro)ryrzrGrHs rKrr/sSy F 1 a) *A}q F1I  MrL)maxsizecddlm}tttt t |tg}tjdk\r|jtjt|S)Nr)r4) ) rr4rrrrrrr version_inforrr)r4rs rKrr?sR* M 7"V112  rL)rXzLiteral[False]rOrr)rrrrrOzCallable[..., Any] | None) rrrrr$set[str]r%rrOzdict[str, ModelPrivateAttr])rrkrrrOrP)rrkrOr) rrkrrrrrNsResolver | NonerOrP)rrkrrMrrrrrrrrrOr)rrkrOrP)rydict[str, Any] | NonerOr)rOr)krT __future__r _annotationsrir>rrr@rrabcrrrrtypesrrr r 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/r0r1_utilsr2r3rrr4r5r6r7PydanticModelFieldr8PydanticModelPrivateAttrmainr9rjrN __setattr__r rr;r[r_rcrrrr2rrrr\rorrrrZrLrKrs$(2 (KKK=VVC>O"ssYY,FM*(C39 GG4@ 3%x## )$ )!  T=OQikv