a hZ@s^dZddlmZddlZddlZddlmZddlmZddl m Z ddl m Z m Z mZddlmZdd lmZmZmZmZdd lmZdd lmZmZdd lmZdd lmZddlm Z ddl!m"Z"ddl#m$Z$m%Z%ddl&m'Z'ddl(m)Z)ddl*m+Z+m,Z,ddl-m.Z.ddl/m0Z0ddl1m2Z2erjddl3m4Z4ddl5m6Z6ddl7m8Z8ddl9m:Z:m;Z;ddld d!d"d#d$Z?e d%d&d'd(Z@dWd*d+d,d-d.d/d0ZAdd1d2d3d4d5d6d7d8d9ZBd*d:d-d;dd?d+d@dAdBZDddddCdDd4dEdFd+dGdHdIZEdJd3d>d?d+d7dKdLZFd:d,dMdNdOZGd:d,dMdPdQZHdRdSdTdUdVZIdS)XzmPrivate 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 get_origin)typing_objects)AnnotationSource)PydanticDeprecatedSince211)PydanticUserError) _generics _typing_extra) ConfigWrapper)extract_docstrings_from_cls)import_cached_base_modelimport_cached_field_info) NsResolver)Representation)can_be_positional BaseMetadata) FieldInfo) BaseModel)PydanticDataclassStandardDataclass)DecoratorInfosc@seZdZdZdZdS)PydanticMetadataz0Base class for annotation markers like `Strict`.N)__name__ __module__ __qualname____doc__ __slots__r(r(r(V/var/www/html/assistant/venv/lib/python3.9/site-packages/pydantic/_internal/_fields.pyr''sr'r r )metadatareturncKs t|S)zCreate a new `_PydanticGeneralMetadata` class with the given metadata. Args: **metadata: The metadata to add. Returns: The new `_PydanticGeneralMetadata` class. )_general_metadata_clsr/r(r(r.pydantic_general_metadata-s r3ztype[BaseMetadata])r0cCs"ddlm}Gdddt|}|S)zCDo it this way to avoid importing `annotated_types` at import time.rrc@seZdZdZddddZdS)z7_general_metadata_cls.._PydanticGeneralMetadataz,Pydantic general metadata like `max_digits`.r r2cSs ||_dS)N)__dict__)selfr/r(r(r.__init__Asz@_general_metadata_cls.._PydanticGeneralMetadata.__init__N)r)r*r+r,r6r(r(r(r._PydanticGeneralMetadata>sr7)annotated_typesr r')r r7r(r(r.r19s r1Fz type[Any]zdict[str, FieldInfo]boolNone)clsfields use_inspectr0cCs>t||d}|D]$\}}|jdur||vr|||_qdS)Nr=)ritems description)r;r<r=Z fields_docsann_name field_infor(r(r._update_fields_from_docstringsGs rC) typevars_mapztype[BaseModel]rzNsResolver | NonezMapping[TypeVar, Any] | Nonez%tuple[dict[str, FieldInfo], set[str]])r;config_wrapper ns_resolverrDr0c Cs4t}t}|j}i}t|D]}t|dd} r|| qtj||d} |j di} i} t } | D]\}\}}|dkrql|j D]}d}t |tr||du}nt |tr||}|r|D]J}t||rt||r|t|divstd|dt||d |d qd }|j D]J}t |trR||sh|d |jd f7}n||s ||f7}q td|d|jd|d|d tqt|r| |qlt||t}t|sql|jr|dkrtd|dt|di d}|D]}ddt |rt!|nd D}t||r||ur@q||vrNq|| vr\qtd|d|j"d|j"dtq|tur|| vs||vr|j#|t$j%d}|sd|_&||_'n t(||}nt)||t ||rt*|j+r|j+,d||_+|s t ||r |-n|}|j.||t$j%d}||_/|sPd|_&||_'nFd|j0vr|1stjd|d |d!|d"t2d#d$| |qlzt3||Wnt4yYn0|jd%}||j5vrt6d&|d'|jd(|| |<ql|r| 7D]}|j&r|8|q|j9r,t:|| | | fS))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. __pydantic_fields__N)rF__annotations__Z model_configFzField "z" conflicts with member z of protected namespace "z".r(z re.compile()z" in 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`Z__pydantic_generic_metadata__origincSsh|] }|jqSr(name).0fieldr(r(r. sz'collect_model_fields..z Field name "z" in "z"" shadows an attribute in parent ""_sourcefinalz 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[] = .`)category stacklevelZ__pydantic_decorators__zField z of class zf overrides symbol of same name in a parent class. This override with a computed_field is incompatible.);rr __bases__reversedgetattrupdaterZget_model_type_hintsr4getsetr?Zprotected_namespaces isinstancer matchstr startswithhasattr issubclass NameErrorpatternwarningswarnr) UserWarningis_classvar_annotationaddris_valid_field_nameZ__pydantic_root_model__ dataclasses is_dataclassr<r+from_annotationrCLASS _complete_original_annotationr#_warn_on_nested_alias_in_annotationrdefault__get__Z_copyfrom_annotated_attribute_original_assignmentZ _qualifiersZ is_requiredrdelattrAttributeErrorZcomputed_fields TypeErrorvaluesapply_typevars_mapuse_attribute_docstringsrC)r;rErFrDr# FieldInfo_basesZparent_fields_lookupbaseZ model_fieldsZ type_hintsrr<Z class_varsrAann_type evaluatedZprotected_namespaceZ ns_violationbZvalid_namespacesZpnZassigned_valueZgeneric_origindataclass_fieldsrBZoriginal_assignmentZ decoratorsrOr(r(r.collect_model_fieldsNs                            rr`)rrAr0cCsrt}t|dd}|rn|D]R}tt|rt|D]4}t||r6|jdur6t d|dt dSq6qdS)N__args__z `alias` specification on field "z5" must be set on outermost annotation to take effect.) rrZrZ is_annotatedrrget_argsr^aliasrfrgrh)rrAr"argsZanno_argZ anno_type_argr(r(r.rrs  rrrzMapping[TypeVar, Any])r;rFrDr0c Cst}i}|||jD]\}}|jr8|||<q |j}tj|jg|j R}t ||}|j } t ur|j|tjd} n|j|| tjd} | jdur| jn|| _| ||<q Wdn1s0Y|S)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. rRN)rpushrGr?rpr@r eval_typerqtypes_namespacer replace_typesrvrrnrroru) r;rFrDr}rebuilt_fieldsf_namerB existing_descannZassign new_fieldr(r(r.rebuild_model_fields-s&   (r)rFrDrEztype[StandardDataclass]zdict[Any, Any] | NonezConfigWrapper | None)r;rFrDrEr0c Cst}i}|pt}|j}t|jD]b}t|s6q$||4|D]\}} ||j divrjqL|j \} } t | j| | \} } t | rqL| js| jtjur| jtjurqLt| j|r | jjr| jjdurLtd|dddqL|j| | jtjd}| j|_n|j| | tjd}| |_| s4d|_| |_|||<|jturLtt||||rLt|||jqLWdq$1s~0Yq$|r| D]}|!|q|dur|j"rt#||t$|d  d |S) a|Collect the fields of a dataclass. Args: cls: dataclass. 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. config_wrapper: The config wrapper instance. Returns: The dataclass fields. rHFzDataclass field zD has init=False and init_var=True, but these are mutually exclusive.zclashing-init-and-init-var)coderRNZ__is_pydantic_dataclass__r>)%rrZ__dataclass_fields__rY__mro__rlrmrr?r4r\rrZ try_eval_typetyperiinitrsMISSINGdefault_factoryr^Zinit_varrrur DATACLASSrvrprqrrZsetattrrzr{r|rCrb)r;rFrDrEr}r<rrrAZdataclass_fieldglobalnslocalnsrrrBrOr(r(r.collect_dataclass_fieldsXsp            2  rztype[PydanticDataclass]c Cst}i}|||jD]r\}}|jr8|||<q |j}tj|jg|j R} t | |} |j | |j tjd} | jdur| jn|| _| ||<q Wdn1s0Y|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. rRN)rrrGr?rpr@rrrqrrrrurvrr) r;rErFrDr}rrrBrrrr(r(r.rebuild_dataclass_fieldss*   (r)rMr0cCs |d S)N_rarLr(r(r.rksrkcCs|do|d S)Nr__rrLr(r(r.is_valid_privateattr_namesrz3Callable[[], Any] | Callable[[dict[str, Any]], Any]z'TypeIs[Callable[[dict[str, Any]], Any]])rr0c Cs\z t|}Wnttfy$YdS0t|j}t|dkoZt|doZ|djt j uS)zMWhether the provided default factory callable has a validated data parameter.Frr) r ValueErrorrylist parametersrzlenrrsrempty)rsigrr(r(r.takes_validated_data_arguments  r)F)Jr, __future__rZ _annotationsrlrfcollections.abcrr functoolsrinspectrrrrer typingr r r r Z pydantic_corerZtyping_extensionsrrZtyping_inspectionrZtyping_inspection.introspectionrZpydanticrZpydantic.errorsrrr_configrZ_docs_extractionrZ _import_utilsrrZ_namespace_utilsr_reprr_utilsrr8r r<r"mainr#Z _dataclassesr$r%Z _decoratorsr&r'r3r1rCrrrrrrrkrrr(r(r(r.s\                      P.i-