j˚dZddlmZddlZddlZddlmZmZddl m Z ddl m Z m Z ddlmZddlmZmZmZmZdd lmZdd lmZmZmZmZdd lmZdd lmZdd l m!Z!ddl"m#Z#ddl$m%Z%ddl&m'Z'm(Z(ddl)m*Z*ddl+m,Z,ddl-m.Z.m/Z/ddl0m1Z1ddl2m3Z3ddl4m5Z5m6Z6m7Z7er"ddl8m9Z9ddl:m;Z;mZ>ddl?m@Z@mAZAddlBmCZCGdde3ZDejEd d !Gd"d#ZFejEd d !Gd$d%ZGdtd*ZHe dud,ZIdvd5ZJdwdxd=ZKdydCZLdzdFZMd{dIZNhdJZOhdKZPe d|dMZQdddNd}dWZRd~dZZSdd\ZTddd]ddaZUddcZVddeZWddfZXddjZYdd6dkddsZZdS)zmPrivate logic related to fields (the `Field()` function and `FieldInfo` class), and arguments to `Annotated`.) annotationsN)CallableMapping)cache) Parameterismethoddescriptor)Pattern) TYPE_CHECKINGAnyTypeVarcast)PydanticUndefined)TypeFormTypeIsget_args get_origin)typing_objects)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_nonesmart_deepcopy BaseMetadata) FieldInfoModelPrivateAttr) BaseModel)PydanticDataclassStandardDataclass)DecoratorInfosceZdZdZdZdS)PydanticMetadataz0Base class for annotation markers like `Strict`.N)__name__ __module__ __qualname____doc__ __slots__r/JC:\Projects\Muse2API\.venv\Lib\site-packages\pydantic/_internal/_fields.pyr.r.'s::IIIr5r.T)slotskw_onlyc$eZdZUded<ded<dS)PydanticExtraInfoz TypeForm[Any] annotationboolcompleteN)r0r1r2__annotations__r/r5r6r:r:-s%NNNNNr5r:cfeZdZUdZded< ded< ded< ded < ded < ded < d ed <dS)ModelNamespaceInfoahInformation gathered by inspecting the namespace of a model class before it is created. Decisions requiring the (possibly unevaluatable at class creation time) annotations (such as whether a sunder-named attribute is a private attribute or a class variable) are deferred to `collect_model_fields()`, where evaluated annotations are available. zdict[str, ModelPrivateAttr]private_attributeszset[str] ignored_namestuple[type[Any], ...] ignored_typesz list[str]private_candidatesfield_candidatesbase_field_namesr<model_config_assignedN)r0r1r2r3r>r/r5r6r@r@3s4333lL((((k!!!!, [/GGr5r@metadatar 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)rIs r6pydantic_general_metadatarMSs # " "8 , ,,r5type[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`.rIr c||_dSN)__dict__)selfrIs r6__init__z@_general_metadata_cls.._PydanticGeneralMetadata.__init__gs $DMMMr5N)rIr )r0r1r2r3rVr/r5r6_PydanticGeneralMetadatarQds.:: % % % % % %r5rW)annotated_typesr&r.)r&rWs r6rLrL_sK-,,,,,%%%%%#3\%%% $#r5protected_namespacestuple[str | Pattern[str], ...]ann_namestrbasesrCcls_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 isinstancer matchr\ startswithhasattr issubclassgetattr ValueErrorappendpatternjoinlenwarningswarn UserWarning) rYr[r]r^r)protected_namespace ns_violationbvalid_namespacespnvalid_namespaces_strs r6_check_protected_namespacesr~mse )**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  r5Fcls type[Any]fieldsdict[str, FieldInfo] use_inspectr<ct||}|D]\}}|j||vr |||_dS)Nr)ritems description)rrr fields_docsr[ field_infos r6_update_fields_from_docstringsrs[-c{KKKK & ;;*  ! )h+.E.E%0%:J ";;r5title_generatorCallable[[str, FieldInfo], str] field_namerr'c|jD|||}t|tstd|d|j||_dSdS)Nzfield_title_generator  must return str, not )titlerjr\ TypeError __class__)rrrrs r6*_apply_field_title_generator_to_field_inforsj  J77%%% om_mm\a\kmmnn n   r5alias_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_aliasrjrgenerate_aliasescallabler\rrr#)rrrrrrs r6$_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 / .r5config_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)rrrrs r6update_field_from_configrs\'<d@d(23H*V`aaa%1,^-KZYcddddd21r5>copydictjson_iter_calculate_keys_copy_and_set_values> schemafrom_ormvalidate construct parse_obj parse_raw _get_value parse_file schema_jsonupdate_forward_refs%tuple[frozenset[int], frozenset[int]]cttfdtDtfdtDfS)a]IDs of the deprecated `BaseModel` methods (and the underlying functions of the deprecated classmethods). These are used to check if an assigned field value is one of the deprecated methods by identity. The `BaseModel` class (and thus the methods) stays alive for the lifetime of the process, so the IDs are guaranteed to be stable. c3\K|]&}t|dxtV'dSrSroid).0name BaseModel_methods r6 z4_deprecated_base_model_method_ids.. sK  'R\^bdhJiJi@i?vBvJJ?v?v?v?v  r5c3zK|]5}tt|dddx$tV6dS)N__func__r)rrrfuncs r6rz4_deprecated_base_model_method_ids.. sX   D$ ? ?TRRR_ tHH____  r5)r frozenset_deprecated_method_names_deprecated_classmethod_names)rrrs@@@r6!_deprecated_base_model_method_idsrs*++J     #;           5      r5) typevars_mapnamespace_infotype[BaseModel] ns_resolverr rMapping[TypeVar, Any] | NonerModelNamespaceInfo | None\tuple[dict[str, FieldInfo], PydanticExtraInfo | None, set[str], dict[str, ModelPrivateAttr]]c p 't}ddlm'm}|j}i}t |D]*} t | ddx} r|| +tj ||} tj |} i} |d| vrtddd | vr|j std d |j D]k}| |}|tj|d s8t!d ||j|| |<t%||l|jD]q}|| vr||jvrtd|dd|j|}t+||rtd|ddtd|d|d|ddi}t-\}}t/}| D],\}\}}|d krt3|j|||jtj|r||Wt;|s|t=|r|| vr|| vr||jvr||j vr||j!vrt |dddkrd}tEj#tI|r-tK|^}}tM'fd|Dd}|t!d |}|'|||| |<6t ||tP}|tPur||_5|sd+|_6nZd/|j?vrQ|@s=t]j/d0|d1|d2|d3td(4|| t%||n#t$rYnwxYw|jd5}"||"jCvrtd|d6|jd7|||<|j6rt|||.|jFrt||d}#d8| vrd}$d8| vr|D]} t | d9d}$|$n|$6|r1|$jHr*ttjK|$jL|d,:}#n6|$}#n3| d8\}%}&|&rtjK|%|}%t|%|&:}#||#|| fS);aZCollect the fields, class variables names and private attributes 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. namespace_info: The result of inspecting the class namespace before the class was created. Returns: A four-tuple containing the model fields, the `PydanticExtraInfo` instance if the `__pydantic_extra__` annotation is set, the class variables names, and the private attributes discovered from the namespace and annotations. Raises: NameError: If there is a conflict between a field name and protected namespaces. PydanticUserError: If there is a field other than `root` in `RootModel`, or if one of the namespace checks performed with `namespace_info` fails. r)r( PrivateAttrraN)r__root__zUTo define root models, use `pydantic.RootModel` rather than a field called '__root__'code model_configz``model_config` cannot be used as a model field name. Use `model_config` for model configuration.zmodel-config-invalid-field-namerr()defaultrbz defined on a base class was overridden by a non-annotated attribute. All field definitions, including overrides, require a type annotation.zmodel-field-overriddenz 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']`.)rYr[r]r^r1 functoolsc3<K|]}t||VdSrS)rj)rvr(s r6rz'collect_model_fields..s3(`(`q 1N^@_@_(`(`(`(`(`(`(`r5rrootzUnexpected field with name z4; only 'root' is allowed as a field of a `RootModel`__pydantic_generic_metadata__originch|] }|j Sr/r)rfields r6 z'collect_model_fields..s'$$$#(EJ$$$r5r/z Field name "z" in "z"" shadows an attribute in parent ""rh_sourceFTrrlenientrfinalz 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__z of class zf overrides symbol of same name in a parent class. This override with a computed_field is incompatible.__pydantic_extra____pydantic_extra_info__r;r=)Mrrr(r __bases__reversedroupdaterget_model_type_hintssafe_get_annotationsrrHrEgetis_classvar_annotationr rTdelattrrFrGrjrsetrr~rYr0addis_valid_field_nameis_valid_privateattr_namerArBrDr is_annotatedrrnext __set_name__rr__pydantic_root_model__rm dataclasses is_dataclassrurvr2rwfrom_annotationrCLASS_original_annotation _complete_copy_recreate_field_inforr__get___attributes_setfrom_annotated_attribute_original_assignment _qualifiers is_requiredrAttributeErrorcomputed_fieldsrruse_attribute_docstringsrr=r:r replace_typesr;)(rrrrr FieldInfo_rr]parent_fields_lookupbase model_fields type_hintscls_annotationsrAvar_namehintvaluerdeprecated_method_idsdeprecated_classmethod_func_ids class_varsr[ann_type evaluated private_attr_rIassigned_value assigned_funcgeneric_origindataclass_fieldsrparent_field_infor decoratorspydantic_extra_infoparent_extra_infoannr=r(s( @r6collect_model_fieldsr"s B*++J66666666 ME1366"4)>EE E< 6 ' ' 5 5 53C[QQQJ$8==O68!  ( (#gnr  _ , ,^5Y ,#r6  '9 ' 'H>>(++D|=#GQ#P#P|044F \_\hiq\rHsHsHs/t/t"8,X&&&&7  H?**>:::'^X^^^1 L*E%,, 'DXDDDKk(kkkUkk,4kkk: $&F=^=`=`::55J+5+;+;+=+=fKfK''8Y ~ % % #!/!D\       / 9 9  NN8 $ $ $ "8,, *-h77+//$666N$EEEN$@@@N$@@@HlD99[HH9= !.z(/C/CDDh#+H#5#5LA#'(`(`(`(`H(`(`(`bf#g#gL'#'(:KKMM#J#JL))#x888/;"8,  h0ABB !2 2 2 ~  "7 7 7#*.*d"K"KKX}%%)HHH/N  & 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 $#  r5)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-varrrN__is_pydantic_dataclass__r)%rr __dataclass_fields__r__mro__rrr&rrrr(r/typerinitrMISSINGdefault_factoryrjinit_varrrr DATACLASSrrrrrrosetattrvaluesapply_typevars_maprrrm)rrrrr rrr r[dataclass_field base_annsglobalnslocalnsrrrrs r6collect_dataclass_fieldsrFsT&*++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)rr&rarrrrr'rr(rrrrrr>r) rrrrr r)r*rr0r!r+s r6rebuild_dataclass_fieldsrIso$*++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)Nrrlrs r6rrDss## ##r5cX|do|d S)Nr__rKrs r6rrHs( ??3   =(=(=$==r5r<3Callable[[], 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_evalrprlist parametersr@rtr"rrempty)r<sigrSs r6takes_validated_data_argumentrVLs-o>>  "uu cn++--..J z??a  q$5jm$D$D qTUI^bkbqIqqs ,,)validated_datacall_default_factoryr:Callable[[], Any] | Callable[[dict[str, Any]], Any] | None-default_factory_takes_validated_data_argument bool | NonerWdict[str, Any] | NonerXc|t|S|rH|r,td|}|td||Std|}|StS)zMResolve the default value using either a static default or a default_factory.NzCallable[[dict[str, Any]], Any]zpThe default factory requires the 'validated_data' argument, which was not provided when calling 'get_default()'.zCallable[[], Any])r$r rpr)rr<rZrWrXfacs r6resolve_default_valuer_\sg&&&  8 8/JJC% G3~&& &*O<rxsss222222--------11111111444444444444++++++DDDDDDDDDDDD,,,,,,<<<<<<//////------$$$$$$&&&&&&&&""""""999999MMMMMMMM((((((!!!!!!IIIIIIIIII,,,,,,,44444444      BBBBBBBB++++++~ T400010 T4000HHHHHHH10H> - - - - $ $ $ $((((V;;;;; ! ! ! !/V/V/V/Vdeeee"hgg ! ! !22604 pGpGpGpGpGpGf 4.4.4.4.n))))`&**. iiiiiiX++++\$$$$>>>> r r r r*-1!& r5