iE{dZddlmZddlZddlZddlmZddlm Z ddl m Z m Z ddl mZddlmZmZmZmZmZdd lmZdd lmZdd lmZdd lmZdd lmZddlm Z ddl!m"Z"m#Z#ddl$m%Z%ddl&m'Z'ddl(m)Z)m*Z*ddl+m,Z,ddl-m.Z.ddl/m0Z0ddl1m2Z2m3Z3er ddl4m5Z5ddl6m7Z7ddl8m9Z9ddl:m;Z;mZ>Gdde0Z?ej@djie,Gd d!ZAdkd&ZBe dld(ZCdmd1ZDdndod9ZEdpd?ZFdqdBZGdrdEZHhdFZIhdGZJddHdsdOZKdtdRZLdudTZMdddUdvdYZNdwd[ZOdxd]ZPdxd^ZQdydbZRdd2dcdzdiZSdS){zmPrivate logic related to fields (the `Field()` function and `FieldInfo` class), and arguments to `Annotated`.) annotationsN)Mapping)cache) Parameterismethoddescriptor)Pattern) TYPE_CHECKINGAnyCallableTypeVarcast)PydanticUndefined)TypeIs)AnnotationSource)PydanticDeprecatedSince211)PydanticUserError)AliasGenerator) _generics _typing_extra) ConfigWrapper)extract_docstrings_from_cls)import_cached_base_modelimport_cached_field_info) slots_true) NsResolver)Representation)can_be_positionalget_first_not_none BaseMetadata) FieldInfo) BaseModel)PydanticDataclassStandardDataclass)DecoratorInfosceZdZdZdZdS)PydanticMetadataz0Base class for annotation markers like `Strict`.N)__name__ __module__ __qualname____doc__ __slots__r*`/var/www/html/crypto-bot/backend/venv/lib/python3.11/site-packages/pydantic/_internal/_fields.pyr)r)'s::IIIr0r)c$eZdZUded<ded<dS)PydanticExtraInfor annotationboolcompleteN)r+r,r-__annotations__r*r0r1r3r3-s$OOONNNNNr0r3metadatar returnr"c 0t|S)zCreate a new `_PydanticGeneralMetadata` class with the given metadata. Args: **metadata: The metadata to add. Returns: The new `_PydanticGeneralMetadata` class. )_general_metadata_cls)r8s r1pydantic_general_metadatar<4s # " "8 , ,,r0type[BaseMetadata]c:ddlm}Gddt|}|S)zCDo it this way to avoid importing `annotated_types` at import time.rr!ceZdZdZddZdS)7_general_metadata_cls.._PydanticGeneralMetadataz,Pydantic general metadata like `max_digits`.r8r c||_dSN)__dict__)selfr8s r1__init__z@_general_metadata_cls.._PydanticGeneralMetadata.__init__Hs $DMMMr0N)r8r )r+r,r-r.rEr*r0r1_PydanticGeneralMetadatar@Es.:: % % % % % %r0rF)annotated_typesr"r))r"rFs r1r;r;@sK-,,,,,%%%%%#3\%%% $#r0protected_namespacestuple[str | Pattern[str], ...]ann_namestrbasestuple[type[Any], ...]cls_nameNonec Rt}|D]}d}t|tr||du}n*t|tr||}|r5|D]\}t ||rJt||r|t|divs'td|dt||d|d]g}|D]y} t| tr4| |s| d| j dK|| s| d | d zd d |t|d krd nd} tjd|d|d|d| d t ddS)NF__pydantic_fields__Field z conflicts with member z of protected namespace .z re.compile()'(z, rz,)z in z$ conflicts with protected namespace zX. You may be able to solve this by setting the 'protected_namespaces' configuration to  stacklevel)r isinstancermatchrK startswithhasattr issubclassgetattr ValueErrorappendpatternjoinlenwarningswarn UserWarning) rHrJrLrNr$protected_namespace ns_violationbvalid_namespacespnvalid_namespaces_strs r1_check_protected_namespacesrnNse )**I3   )7 3 3 D.44X>>dJLL +S 1 1 D#../BCCL    1h''&q)44WQPegiEjEj9j9j(PXPPPQS[H\H\PP7JPPP /1 .??B!"g..?!xx11S,334Q"*4Q4Q4QRRR'22266?,33IIII>>>'u4995E+F+F'uPSTdPePeijPjPjps'u'u$ DXDDXDD]pDDmADDD 7  r0Fcls type[Any]fieldsdict[str, FieldInfo] use_inspectr5ct||}|D]\}}|j||vr |||_dS)Nrs)ritems description)rorqrs fields_docsrJ field_infos r1_update_fields_from_docstringsrzys[-c{KKKK & ;;*  ! )h+.E.E%0%:J ";;r0title_generatorCallable[[str, FieldInfo], str] field_nameryr#c|jD|||}t|tstd|d|j||_dSdS)Nzfield_title_generator  must return str, not )titlerZrK TypeError __class__)r{r}ryrs r1*_apply_field_title_generator_to_field_inforsj  J77%%% om_mm\a\kmmnn n   r0alias_generator%Callable[[str], str] | AliasGeneratorc|j!|jdks|j|j|jd\}}}t |t r||\}}}nIt|r:||}t |tstd|d|j |j |jdkrd|_|jdkr1t|||_t|||_||_|j||_|jt|||_|jt|||_dSdSdS)avApply an alias generator to aliases on a `FieldInfo` instance if appropriate. Args: alias_generator: A callable that takes a string and returns a string, or an `AliasGenerator` instance. field_name: The name of the field from which to generate the alias. field_info: The `FieldInfo` instance to which the alias generator is (maybe) applied. Nr)NNNzalias_generator r) alias_priorityaliasvalidation_aliasserialization_aliasrZrgenerate_aliasescallablerKrrr )rr}ryrrrs r1$_apply_alias_generator_to_field_infors !)  $ ) )   #  & .  ) 17G4!4 o~ 6 6 m;J;[;[\f;g;g 8E#%8%8 o & & m#OJ//EeS)) m k? k kZ_Zi k klll  $ , 0IQ0N0N()J %  $ ) )-?@SUZ-[-[J **<=Mu*U*UJ '$J    #$J   ) 1-?@SUZ-[-[J *  & .*<=Mu*U*UJ ' ' '; 2 18 / .r0config_wrapperrc|jp|j}|t||||jt|j||dSdS)apUpdate the `FieldInfo` instance from the configuration set on the model it belongs to. This will apply the title and alias generators from the configuration. Args: config_wrapper: The configuration from the model. field_name: The field name the `FieldInfo` instance is attached to. field_info: The `FieldInfo` instance to update. N)field_title_generatorrrr)rr}ryrs r1update_field_from_configrs\'<d@d(23H*V`aaa%1,^-KZYcddddd21r0>copydictjson_iter_calculate_keys_copy_and_set_values> schemafrom_ormvalidate construct parse_obj parse_raw _get_value parse_file schema_jsonupdate_forward_refs) typevars_maptype[BaseModel] ns_resolverrrMapping[TypeVar, Any] | None?tuple[dict[str, FieldInfo], PydanticExtraInfo | None, set[str]]c t}t|j}i}t|D]*}t |ddx}r||+t j||} t j|} i} t} | D]x\} \}}| dkrt|j | ||j t j|r| | Wt || t t urYt#fdt$Ds1t'dr(t#fdt(Drt t+| s|jr| d krt/d | d |D]}t'|| r| | vrt |d id }||ur@dt3j|rt3j|ndD}| |vryt9jd| d|jd|jdt>dt urp| | vs| |vr3| |tBj"}||_#|sd|_$n;|| %}|rtM|||d}n |}ntO|r@tQj)r,j)*d|}|_)|j+d<|,|tBj"}|_-||_#|sd|_$nZd|j.vrQ|/s=t9jd| d| d| dt`d | |  tc|| n#td$rYnwxYw|j3d!}| |j4vrtkd"| d#|j d$|| | <|j$rtm|| |z|j7rtq|| d}d%| vr| d%\}}ts||&}| || fS)'aCollect the fields and class variables names of a nascent Pydantic model. The fields collection process is *lenient*, meaning it won't error if string annotations fail to evaluate. If this happens, the original annotation (and assigned value, if any) is stored on the created `FieldInfo` instance. The `rebuild_model_fields()` should be called at a later point (e.g. when rebuilding the model), and will make use of these stored attributes. Args: cls: BaseModel or dataclass. config_wrapper: The config wrapper instance. ns_resolver: Namespace resolver to use when getting model annotations. typevars_map: A dictionary mapping type variables to their concrete types. Returns: A three-tuple containing the model fields, the `PydanticExtraInfo` instance if the `__pydantic_extra__` annotation is set, and class variables names. Raises: NameError: - If there is a conflict between a field name and protected namespaces. - If there is a field other than `root` in `RootModel`. - If a field shadows an attribute in the parent model. rQN)r model_config)rHrJrLrNc3>K|]}t|duVdSrB)r_.0 depr_name BaseModel_assigned_values r1 z'collect_model_fields..&s4qq9 It44Fqqqqqqr0__func__c3fK|]+}tt|dddjuV,dS)Nr)r_rrs r1rz'collect_model_fields..*sX!GJ 4@@*dSSWeWnnr0rootzUnexpected field with name z4; only 'root' is allowed as a field of a `RootModel`__pydantic_generic_metadata__originch|] }|j Sr*name)rfields r1 z'collect_model_fields..Gs'$$$#(EJ$$$r0r*z Field name "z" in "z"" shadows an attribute in parent ""rX_sourceFTrrlenientdefaultfinalz Annotation z= is marked as final and has a default value. Pydantic treats zz as a class variable, but it will be considered as a normal field in V3 to be aligned with dataclasses. If you still want zV to be considered as a class variable, annotate it as: `ClassVar[] = .`)categoryrY__pydantic_decorators__rRz of class zf overrides symbol of same name in a parent class. This override with a computed_field is incompatible.__pydantic_extra__r4r6):rr __bases__reversedr_updaterget_model_type_hintssafe_get_annotationssetrvrnrHr+is_classvar_annotationaddrany_deprecated_method_namesr]_deprecated_classmethod_namesis_valid_field_name__pydantic_root_model__ NameErrorget dataclasses is_dataclassrqrerfr-rgfrom_annotationrCLASS_original_annotation _complete_copy_recreate_field_inforZrr__get___attributes_setfrom_annotated_attribute_original_assignment _qualifiers is_requiredrdelattrAttributeErrorrCcomputed_fieldsrruse_attribute_docstringsrzr3)rorrr FieldInfo_rLparent_fields_lookupbase model_fields type_hintscls_annotationsrq class_varsrJann_type evaluatedgeneric_origindataclass_fieldsryparent_field_infor decoratorspydantic_extra_infoannr6rrs @@r1collect_model_fieldsrs@*++J)++J ME1366"4)>EE E< 6 ' ' 5 5 53C[QQQJ$8==O#%F55J+5+;+;+=+=SKSK''8Y ~ % % #!/!D\       / 9 9  NN8 $ $ $  h0ABB !2 2 2 qqqqqXpqqq q q 3  33 3 %B 3/N"8,,    & 8v+=+=nhnnn   DtX&& ?22").Mr!R!R!V!VW_!`!`>))$$ITIabfIgIg-o[-?-E-E-Emo$$$ /// -8--33C--)---  . . .?**h>R.R.R (77JZJ`7aa 2: / 1+0J( %9$B$H$H$J$J!  3!5){Q]gk"""JJ"3JJ.*55 D:L^Mc:d:d D )088sCC)0&5J5VI11\iI $#  r0)rrtype[StandardDataclass]NsResolver | Nonedict[Any, Any] | Nonec t}i}|p t}|j}t|jD]}t j|s||5|D]\}} tj |} || vr|j \} } tj | j | | \} }tj| r\| js'| jt jur| jt jurt'| j|rd| jjr$| jjdurt+d|dd|| | jt.j}| j|_n)|| | t.j}| |_|sd|_| |_|||<t9||||jt:ur5t't=||||rt?|||j dddn #1swxYwY|r,| D]}|!||j"r!tG||tI|d |S) a|Collect the fields of a dataclass. Args: cls: dataclass. config_wrapper: The config wrapper instance. ns_resolver: Namespace resolver to use when getting dataclass annotations. Defaults to an empty instance. typevars_map: A dictionary mapping type variables to their concrete types. Returns: The dataclass fields. FzDataclass field zD has init=False and init_var=True, but these are mutually exclusive.zclashing-init-and-init-var)coderN__is_pydantic_dataclass__ru)%rr__dataclass_fields__r__mro__rrrrvrrrrtyperinitrMISSINGdefault_factoryrZinit_varrrr DATACLASSrrrrrr_setattrvaluesapply_typevars_maprrzr])rorrrrrqrrrJdataclass_field base_annsglobalnslocalnsrrryrs r1collect_dataclass_fieldsrsT&*++J#%F-K/ %%;?;?'--     d # #7 ?7 ?-=-C-C-E-E6 ?6 ?)/)>tDD 9,,$/$?!'&3&A/BVX`bi&j&j#) 7AA(,'/;3FFF'7;;NNNo5zBBF&.7!*275@@"3!B8!B!B!B%A### !!+!D!D /"9CSC]"E""J7F6MJ33!+!D!D /;K;U"E""J7FJ3 ?+0J(6>J3#-x (:NNN%->>>:C:66 DD>C:+=>>>m6 ?7 ?7 ?7 ?7 ?7 ?7 ?7 ?7 ?7 ?7 ?7 ?7 ?7 ?7 ?7 ?r3]]__ 3 3E  $ $\ 2 2 2 2. &  $C)DEEE      Ms)F,H""H& )H& type[PydanticDataclass]ct}i}||5|jD]\}}|jr|||<|j}t j|jg|j R} tj | |} | | |j tj} | j| jn|| _t!||| | ||< dddn #1swxYwY|S)aRebuild the (already present) dataclass fields by trying to reevaluate annotations. This function should be called whenever a dataclass with incomplete fields is encountered. Raises: NameError: If one of the annotations failed to evaluate. Note: This function *doesn't* mutate the dataclass fields in place, as it can be called during schema generation, where you don't want to mutate other dataclass's fields. rN)rrrQrvrrwrrrrrrrrrrr) rorrrrrrryrrrs r1rebuild_dataclass_fieldsr {so$*++J+-N   #  33"%"9"?"?"A"A 3 3 FJ# 3)3v&& * 6 #-3 0 -c<@@&??3,6@ BKAVAb (=(=hu %(KKK)2v&&' 3333333333333333, sB7C**C.1C.rc.|d S)N_r\rs r1rrss## ##r0cX|do|d S)Nr"__r#rs r1is_valid_privateattr_namer&s( ??3   =(=(=$==r0r3Callable[[], Any] | Callable[[dict[str, Any]], Any]'TypeIs[Callable[[dict[str, Any]], Any]]c, tj|}n#ttf$rYdSwxYwt |j}t|dko-t|do|dj tj uS)zMWhether the provided default factory callable has a validated data parameter.Frr) rsignature_no_evalr`rlist parametersrrdrrrempty)rsigr,s r1takes_validated_data_argumentr/s-o>>  "uu cn++--..J z??a  q$5jm$D$D qTUI^bkbqIqqs ,,)validated_datacall_default_factoryr:Callable[[], Any] | Callable[[dict[str, Any]], Any] | Noner0dict[str, Any] | Noner1cddlm}| ||S|rVt|r,td|}|t d||Std|}|St S)zMResolve the default value using either a static default or a default_factory.r)smart_deepcopyN)rzCallable[[dict[str, Any]], Any]zpThe default factory requires the 'validated_data' argument, which was not provided when calling 'get_default()'.zCallable[[], Any])_utilsr5r/r r`r)rrr0r1r5facs r1resolve_default_valuer8s'&&&&&~g&&&  ( I I I 8/JJC% G3~&& &*O<rQs`ss222222######11111111>>>>>>>>>>>>>>++++++$$$$$$<<<<<<//////------$$$$$$&&&&&&&&""""""999999MMMMMMMM++++++((((((!!!!!!99999999,,,,,,,""""""      BBBBBBBB++++++~ $$$$%$ - - - - $ $ $ $((((V;;;;; ! ! ! !/V/V/V/Vdeeee"hgg ! ! !&26 Q3Q3Q3Q3Q3Q3h,.,.,.,.^))))`&**. iiiiiiX++++\$$$$>>>> r r r r(-1!& r0