RPfh7dZddlmZddlZddlZddlZddlmZddlm Z ddl m Z m Z ddl mZddlmZd d lmZd d lmZd d lmZd d lmZd dlmZmZmZmZe rddlmZddlm Z ddl!m"Z"d dl#m$Z$d dl%m&Z& d# d$dZ'GddeZ(d%dZ)e dd&dZ*d'dZ+dd d(dZ,d)dZ-ddd d*d Z.d+d!Z/d+d"Z0y),zmPrivate logic related to fields (the `Field()` function and `FieldInfo` class), and arguments to `Annotated`.) annotationsN)copy) lru_cache) TYPE_CHECKINGAny)PydanticUndefined)PydanticUserError) _typing_extra) ConfigWrapper)extract_docstrings_from_cls)Representation)get_cls_type_hints_lenientget_type_hints is_classvar is_finalvar BaseMetadata FieldInfo BaseModel)StandardDataclass)DecoratorInfosct|dd}d}|r tj|j}t ||||S#t$rYwxYw)aGets type hints for an object by inferring the global namespace. It uses the `typing.get_type_hints`, The only thing that we do here is fetching global namespace from `obj.__module__` if it is not `None`. Args: obj: The object to get its type hints. localns: The local namespaces. include_extras: Whether to recursively include annotation metadata. Returns: The object type hints. __module__N)globalnslocalnsinclude_extras)getattrsysmodules__dict__KeyErrorr)objrr module_namers T/var/www/fastapitest/venv/lib/python3.12/site-packages/pydantic/_internal/_fields.pyget_type_hints_infer_globalnsr)s[$#|T2K&*H {{;/88H #'R` aa   s? A  A ceZdZdZdZy)PydanticMetadataz0Base class for annotation markers like `Strict`.N)__name__r __qualname____doc__ __slots__r,r(r+r+;s :Ir1r+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 r(pydantic_general_metadatar5As # "8 ,,r1)maxsizec2ddlm}Gddt|}|S)zCDo it this way to avoid importing `annotated_types` at import time.rrceZdZdZddZy)7_general_metadata_cls.._PydanticGeneralMetadataz,Pydantic general metadata like `max_digits`.c||_yN)r$)selfr4s r(__init__z@_general_metadata_cls.._PydanticGeneralMetadata.__init__Us $DMr1N)r4r)r-rr.r/r=r,r1r(_PydanticGeneralMetadatar9Rs : %r1r>)annotated_typesrr+)rr>s r(r3r3Ms-%#3\% $#r1c|jr@t|}|jD]!\}}|j||vs|||_#yyr;)use_attribute_docstringsr items description)clsfieldsconfig_wrapper fields_docsann_name field_infos r(_update_fields_from_docstringsrJ[sT..1#6 $*LLN ? Hj%%-(k2I)4X)> & ?/r1) typevars_mapc ddlm}t||}|jj di}i}t } |j D]d\} dk(r |jD]} j| s|D]N} t| sddl m } t| | r| jvr1tddt| d| d t!fd |jD}t#j$dd | d |d t&t)| r| j+t-| t|t.r| j+t1s|j2rdk7rtddt|dij d}|D]}t5j6|rt5j|ndDchc]}|j8}}t|sS||urX|vr]|vrbt#j$dd|j:d|j:dt& t|t.}|t.urt< |j>| |} tA||jd}|jJvr tMd||<g|r'|jOD]}|jQ||tS||||| fScc}w#t<$rYzwxYw#t<$rt|vr|jB| }nZi}|jDdddD]}|jGt|di |vrtI|}n|jB| }YwxYw)a[Collect the fields of a nascent pydantic model. Also collect the names of any ClassVars present in the type hints. The returned value is a tuple of two items: the fields dict, and the set of ClassVar names. 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_map: A dictionary mapping type variables to their concrete types. Returns: A tuple contains fields and class variables. 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. rr__annotations__ model_configrzField "z" conflicts with member z of protected namespace "z".c3FK|]}j|r|ywr; startswith).0xrHs r( z'collect_model_fields..s$-hNaNabcNd-s!!z)" has conflict with protected namespace "z_". You may be able to resolve this warning by setting `model_config['protected_namespaces'] = z`.rootzUnexpected 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 ""N model_fields__pydantic_decorators__z0you can't override a field with a computed field)*rErrr$getsetrBprotected_namespacesrQhasattrmainr issubclassrZ NameErrorr!tuplewarningswarn UserWarningradd_is_finalvar_with_default_valris_valid_field_name__pydantic_root_model__ dataclasses is_dataclassnamer.AttributeErrorfrom_annotated_attributedelattrfrom_annotation __bases__updatercomputed_fields ValueErrorvaluesapply_typevars_maprJ)rDbasesrFtypes_namespacerKr type_hintsrrE class_varsann_typeprotected_namespacebrvalid_namespacesgeneric_originbasefielddataclass_fieldsdefaultrImodel_fields_lookuprS decoratorsrHs @r(collect_model_fieldsrcs <#+CAJ,,""#4b9K#%F5J(..0h&( ~ % #1#F#F  ""#67Aq(+4 *1i 8X=W"+")(3KGTUW_L`Ka";)//;. "8*F33C3C2DE))*!-% 0 c8->?G++$$,*<;;HgNJ X& &)\\2K%L z11 1OP P%xQh&T]]_ DE  $ $\? C D#3? : I h"  3 E;&6Y66x@ =?#tt,OA'..wq."/MNO22"&&9(&C!DJ ";!:!:8!DJ# Es+K.L8 K33 K?>K?A:M?>M?cddlm}t|sy|turyt ||r|j tur |j yy)NrrFT)rErrr isinstancerdefault_factory)type_valrs r(rhrhsC" u  ! ! C #8I)IcNaNaNir1)rKrFcddlm}i}|j}tt |}t j j|j}|i|j|xsi}|jD]J\} } tj| j||} t| r4| js;| j t"j$k(r| j&t"j$k(r{t)| j |r^| j j*r*| j jdurt-d| dd|j.| | j } n|j.| | } | || <| j t0ust)t3|| | |s4t5|| | j M|r'|j7D]} | j9||| t;||||S)aFCollect the fields of a dataclass. Args: cls: dataclass. types_namespace: Optional extra namespace to look for types in. typevars_map: A dictionary mapping type variables to their concrete types. config_wrapper: The config wrapper instance. Returns: The dataclass fields. rrFzDataclass field zD has init=False and init_var=True, but these are mutually exclusive.zclashing-init-and-init-var)code)rEr__dataclass_fields__dictvarsr"r#r\rr$rBr eval_type_lenienttyperinitrrkMISSINGrrinit_varr rorr!setattrrvrwrJ)rDryrKrFrrEr cls_localns source_modulerHdataclass_fieldr|rIrs r(collect_dataclass_fieldsr s$##%F585M5MtCy/KKKOOCNN3M O]33O8M2O%5%;%;%= 7!/ 22?3G3GZef x  $$'';+>+>>//;3F3FF  o--y 9&&//"**//58+*8*4xy9 ;;;HoF]F]^J;;;HoVJ%x   %6 6:gcS[]gFhjs;t C:#5#5 6A 7D]]_ DE  $ $\? C D!&sFNC Mr1c&|jd S)N_rPrms r(ririSss# ##r1cL|jdxr|jd S)Nr__rPrs r(is_valid_privateattr_namerWs" ??3  =(=$==r1)NF)r&rrdict[str, Any] | Noner boolreturnzdict[str, Any])r4rrr)rztype[BaseMetadata])rD type[Any]rEdict[str, FieldInfo]rFr rNone) rDztype[BaseModel]rxztuple[type[Any], ...]rFr ryrrKdict[Any, Any] | Nonerz%tuple[dict[str, FieldInfo], set[str]])rrrrrr) rDztype[StandardDataclass]ryrrKrrFzConfigWrapper | Nonerr)rmstrrr)1r/ __future__r _annotationsrkr"rdr functoolsrtypingrr pydantic_corerpydantic.errorsr r _configr _docs_extractionr _reprrrrrrr?rrErr`r _dataclassesr _decoratorsrr)r+r5r3rJrrhrrirr,r1r(rsGs2 %+-"9!__," /+ &* b b "bb b:~ - 4 $ $?+/ X X X"X+ X ( X+Xv "+/+/ E E*E( E ) E  EP$>r1