hmdZddlmZddlZddlZddlmZddlmZddl m Z ddl m Z m Z mZddlmZdd lmZmZmZmZdd lmZdd lmZdd lmZdd lmZddlmZddl m!Z!ddl"m#Z#m$Z$ddl%m&Z&ddl'm(Z(ddl)m*Z*m+Z+ddl,m-Z-ddl.m/Z/ddl0m1Z1m2Z2er ddl3m4Z4ddl5m6Z6ddl7m8Z8ddl9m:Z:m;Z;ddld2d Z?e d3d!Z@ d4d"ZAd5d6d#ZB d7d$ZC d8d%ZDd9d&ZEhd'ZFhd(ZGdd) d:d*ZH d;d+ZIddd, dd/ZLd>d0ZM d?d1ZNy)@zmPrivate logic related to fields (the `Field()` function and `FieldInfo` class), and arguments to `Annotated`.) annotationsN)Mapping)copy)cache) Parameterismethoddescriptor signature)Pattern) TYPE_CHECKINGAnyCallableTypeVar)PydanticUndefined)TypeIs)AnnotationSource)PydanticDeprecatedSince211)PydanticUserError)AliasGenerator) _generics _typing_extra) ConfigWrapper)extract_docstrings_from_cls)import_cached_base_modelimport_cached_field_info) NsResolver)Representation)can_be_positionalget_first_not_none BaseMetadata) FieldInfo) BaseModel)PydanticDataclassStandardDataclass)DecoratorInfosceZdZdZdZy)PydanticMetadataz0Base class for annotation markers like `Strict`.N)__name__ __module__ __qualname____doc__ __slots__r*?D:\jyotish\venv\Lib\site-packages\pydantic/_internal/_fields.pyr)r)'s :Ir0r)c "t|S)zCreate a new `_PydanticGeneralMetadata` class with the given metadata. Args: **metadata: The metadata to add. Returns: The new `_PydanticGeneralMetadata` class. )_general_metadata_cls)metadatas r1pydantic_general_metadatar5-s # "8 ,,r0c2ddlm}Gddt|}|S)zCDo it this way to avoid importing `annotated_types` at import time.rr!ceZdZdZddZy)7_general_metadata_cls.._PydanticGeneralMetadataz,Pydantic general metadata like `max_digits`.c||_yN)__dict__)selfr4s r1__init__z@_general_metadata_cls.._PydanticGeneralMetadata.__init__As $DMr0N)r4r )r+r,r-r.r=r*r0r1_PydanticGeneralMetadatar8>s : %r0r>)annotated_typesr"r))r"r>s r1r3r39s-%#3\% $#r0c t}|D]\}d}t|tr|j|du}n!t|tr|j |}|sN|D]I}t ||st||r|t|divr,td|dt||d|dg}|D]k} t| tr2| j|r%|jd| jdE|j | rW|jd | d md d j|t|d k(rd nd} tjd|d|d|d| d t d_y)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 isinstancer matchstr startswithhasattr issubclassgetattr ValueErrorappendpatternjoinlenwarningswarn UserWarning) protected_namespacesann_namebasescls_namer$protected_namespace ns_violationbvalid_namespacespnvalid_namespaces_strs r1_check_protected_namespacesrcGs )*I3 )7 3.44X>dJL +S 1#../BCL 1h'&q)4WQPegiEj9j($XL0GPQS[H\G]67J6MQP/1 .B!"g.!xx1,33k"**q4QR'2226,33at1I> /*+4995E+F*GPSTdPeijPjpsGt'u$ XLXL8\]p\stlmAlBBCD 7 4r0ct||}|jD]!\}}|j||vs|||_#y)N use_inspect)ritems description)clsfieldsrf fields_docsrZ field_infos r1_update_fields_from_docstringsrmrsC-c{KK & *  ! ! )h+.E%0%:J "!/r0c|j<|||}t|tstd|d|j||_yy)Nzfield_title_generator  must return str, not )titlerJrL TypeError __class__)title_generator field_namerlrps r1*_apply_field_title_generator_to_field_inforuysV  J7%%4_4EE[\a\k\k[lmn n   r0c|j4|jdks%|j|j |jd\}}}t |t r|j |\}}}n>t|r3||}t |tstd|d|j|j|jdkrd|_|jdk(r)t|||_t|||_||_|j||_|jt|||_|jt|||_yyy)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 ro) alias_priorityaliasvalidation_aliasserialization_aliasrJrgenerate_aliasescallablerLrqrrr )alias_generatorrtrlrxryrzs r1$_apply_alias_generator_to_field_infor~sh !!)  $ $ )    #  & & .  ) ) 17G4!4 o~ 6;J;[;[\f;g 8E#%8 o &#J/EeS)"2?2CCYZ_ZiZiYj kll  $ $ , 0I0IQ0N()J %  $ $ )-?@SUZ-[J **<=Mu*UJ '$J     #$J   ) ) 1-?@SUZ-[J *  & & .*<=Mu*UJ ' /9 2r0c|jxs |j}| t||||jt|j||yy)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_generatorrur}r~)config_wrapperrtrlrs r1update_field_from_configrsS'<<d@d@d(23H*V`a%%1,^-K-KZYcd2r0>rdictjson_iter_calculate_keys_copy_and_set_values> schemafrom_ormvalidate construct parse_obj parse_raw _get_value parse_file schema_jsonupdate_forward_refs) typevars_mapc t}t|j}i}t|D]#}t |ddx}s|j |%t j||} t j|} i} t} | jD];\} \}}| dk(rt|j| ||jt j|r| j| Zt || t t urDt#fdt$Ds%t'drt#fdt(Drt t+| s|j,r| d k7rt/d | d t |d ij1d }|D]}t3j4|rt3j6|ndDchc]}|j8}}t'|| sS||urX| |vr]| | vrbt;j<d| d|j>d|j>dt@dt urK| | vs| |vr4|jC|tDjF}|sd|_$||_%ntM|| }ntO|rGtQjRr2jRjUd|}|_)|jVd<|jY|tDjF}|_-|sd|_$||_%nWd|j\vrI|j_s9t;j<d| d| d| dt`d| j|  tc|| |jfd}| |jhvrtkd| d |jd!|| | <|jHs/tm|| |>|r3| joD] }|jHs|jq|"|jrr tu|| | | fScc}w#td$rYwxYw)"a*Collect 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 two-tuple containing model fields 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. rAN) ns_resolver model_config)rYrZr[r\c3<K|]}t|duywr:)rP.0 depr_name BaseModel_assigned_values r1 z'collect_model_fields..s"qXp9 It4FXps__func__c3fK|](}tt|dddju*yw)Nr)rPrrs r1rz'collect_model_fields..#s7%B GJ 4@*dSWeWnWnn%Bs.1rootzUnexpected field with name z4; only 'root' is allowed as a field of a `RootModel`__pydantic_generic_metadata__originr*z Field name "z" in "z"" shadows an attribute in parent ""rH_sourceFdefaultfinalz 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[] = .`)categoryrI__pydantic_decorators__rBz of class zf overrides symbol of same name in a parent class. This override with a computed_field is incompatible.);rr __bases__reversedrPupdaterget_model_type_hintssafe_get_annotationssetrgrcrYr+is_classvar_annotationaddrany_deprecated_method_namesrN_deprecated_classmethod_namesis_valid_field_name__pydantic_root_model__ NameErrorget dataclasses is_dataclassrjnamerVrWr-rXfrom_annotationrCLASS _complete_original_annotationrrJrr__get___attributes_setfrom_annotated_attribute_original_assignment _qualifiers is_requiredrdelattrAttributeErrorr;computed_fieldsrqrvaluesapply_typevars_mapuse_attribute_docstringsrm)rirrr FieldInfo_r[parent_fields_lookupbase model_fields type_hintsrrj class_varsrZann_type evaluatedgeneric_originfielddataclass_fieldsrlr decoratorsrrs @@r1collect_model_fieldsrst>*+J)+J MME13"4)>E E< E ' ' 5 33C[QJ 44S9K#%F5J+5+;+;+=''8Y ~ % #!/!D!D\\    / / 9 NN8 $  h0AB !2 2 qXpq q 3%B/N"8,   & &8v+=-h\9mn  !&ErJNNxXDEPE]E]^bEc););D)Aik)k )ku )k  tX&>)//;. "8*F33C3C2DE))*!- %2 . .;&(:N*N (77JZJ`J`7a  +0J(7?J3""6x"@A .*5:L^McMc:d )0088sC)0&?GG &x    $^Xz JU,>X]]_E((6%..&sF3 : M \"  sP.5 P33 P?>P?ct}i}|j|5|jjD]\}}|jr|||<|j }t j|jg|j} tj| |} |jx} tur"|j| tj } n"|j#| | tj } | j | j n|| _t%||| | ||< ddd|S#1swY|SxYw)aRebuild the (already present) model fields by trying to reevaluate annotations. This function should be called whenever a model with incomplete fields is encountered. Raises: NameError: If one of the annotations failed to evaluate. Note: This function *doesn't* mutate the model fields in place, as it can be called during schema generation, where you don't want to mutate other model's fields. rN)rpushrArgrrhr eval_typertypes_namespacer replace_typesrrrrrrr) rirrrrrebuilt_fieldsf_namerl existing_descannassign new_fields r1rebuild_model_fieldsrs2$*+J+-N   # "%"9"9"?"?"A FJ##)3v& * 6 6 #--33 00 --c<@(===FBSS * : :3HXH^H^ : _I * C CCYiYoYo C pIAJAVAVAb (=(=hu %(K)2v&%#B * + * s D D33D=)rrc lt}i}|xs t}|j}t|jD]}t j |s|j|5|jD]\}} tj|} || vr!|j\} } tj| j| | \} }tj| rj| js9| j t j"ur| j$t j"urt'| j |r| j j(r+| j jdurt+d|dd|j-| | j t.j0}| j |_n)|j-| | t.j0}| |_|sd|_| |_|||<t9||||j t:ust't=||||st?|||j  ddd|r&|jAD]}|jC||jDrtG||tI|d |S#1swYwxYw) 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__re)%rr__dataclass_fields__r__mro__rrrrgrrr try_eval_typetyperinitrMISSINGdefault_factoryrJinit_varrrr DATACLASSrrrrrrPsetattrrrrrmrN)rirrrrrjrrrZdataclass_field base_annsglobalnslocalnsrrrlrs r1collect_dataclass_fieldsrs&*+J#%F-K// %''-    d #-=-C-C-E)/)>>tD 9,$/$?$?!'&3&A&A/BVBVX`bi&j#) 77A(,,'//;3F3FF'77;;N;NNo55zB&..77*22775@"3"28*=A!B%A# !!+!D!D /"9"9CSC]C]"E"J7F6M6MJ3!+!D!D /;K;U;U"E"J7FJ3 +0J(6>J3#-x (:N%%->>:C:6 DC:+=+=>m.F$ # &z]]_E  $ $\ 2 % ..&  $C)DEE   MS$ #s'F2J)J)4J))J3 c(t}i}|j|5|jjD]\}}|jr|||<|j }t j|jg|j} tj| |} |j| |jtj} | j | j n|| _t!||| | ||< ddd|S#1swY|SxYw)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)rrrArgrrhrrrrrrrrrrr) rirrrrrrrlrrrs r1rebuild_dataclass_fieldsr9s$*+J+-N   # "%"9"9"?"?"A FJ##)3v& * 6 6 #--33 00 --c<@&??33,66@ BKAVAVAb (=(=hu %(K)2v&'#B , - , s CDDc&|jd S)N_rMrs r1rrgss# ##r0cL|jdxr|jd S)Nr__rrs r1is_valid_privateattr_namerks" ??3  =(=$==r0c t|}t|jj }t |dk(xr/t|dxr|djtjuS#ttf$rYywxYw)zMWhether the provided default factory callable has a validated data parameter.Frr) r rQrqlist parametersrrUrrrempty)rsigrs r1takes_validated_data_argumentros( cnn++-.J z?a  q$5jm$D qTUI^I^bkbqbqIqq  "s A//BB)r4r returnr")rztype[BaseMetadata]) rYztuple[str | Pattern[str], ...]rZrLr[ztuple[type[Any], ...]r\rLrNone)F)riz type[Any]rjdict[str, FieldInfo]rfboolrr)rszCallable[[str, FieldInfo], str]rtrLrlr#)r}z%Callable[[str], str] | AliasGeneratorrtrLrlr#)rrrtrLrlr#rr) ritype[BaseModel]rrrNsResolver | NonerzMapping[TypeVar, Any] | Nonerz%tuple[dict[str, FieldInfo], set[str]]) rir rrrrrMapping[TypeVar, Any]rr) riztype[StandardDataclass]rrrr rzdict[Any, Any] | Nonerr) riztype[PydanticDataclass]rrrrrr rr)rrLrr )rz3Callable[[], Any] | Callable[[dict[str, Any]], Any]rz'TypeIs[Callable[[dict[str, Any]], Any]])Or. __future__r _annotationsrrVcollections.abcrr functoolsrinspectrrr rer typingr r r r pydantic_corertyping_extensionsrtyping_inspection.introspectionrpydanticrpydantic.errorsraliasesrrr_configr_docs_extractionr _import_utilsrr_namespace_utilsr_reprr_utilsrr r?r"rjr#mainr$ _dataclassesr%r& _decoratorsr'r)r5r3rcrmrur~rrrrrrrrrrr*r0r1r$s)s2#<<88+$</-$&"9M(!9," B+~ - $ $(8(( !( (  (V; !4 ! ! !/V:/VHK/VYb/Vde"h !&26 D D!D#D / D + DN* *"* * ( *  *b&**. i i"i# i ( i  iX+ +"+ + ( +  +\$> rH r, rr0