/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@mAZAddlBmCZCGdde3ZDejd d !Gd"d#ZFejd d !Gd$d%ZGd>d&ZHe d?d'ZI d@d(ZJdAdBd*ZK dCd+ZL dDd,ZMdEd-ZNhd.ZOhd/ZPe dFd0ZQddd1 dGd2ZR dHd3ZSed4 dId5ZTddd6 dJd7ZU dKd8ZVdLd9ZWdLd:ZX dMd;ZYdd)d< dNd=ZZy)OzmPrivate 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)DecoratorInfosceZdZdZdZy)PydanticMetadataz0Base class for annotation markers like `Strict`.N)__name__ __module__ __qualname____doc__ __slots__r/]/root/repos/pocs/video-evals/.venv/lib/python3.12/site-packages/pydantic/_internal/_fields.pyr.r.'s :Ir5r.T)slotskw_onlyc"eZdZUded<ded<y)PydanticExtraInfoz TypeForm[Any] annotationboolcompleteN)r0r1r2__annotations__r/r5r6r:r:-s Nr5r:cdeZdZUdZded< ded< ded< ded < ded < ded < d ed <y)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@3sL43lL((k!!, [/Gr5r@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 r6pydantic_general_metadatarLSs # "8 ,,r5c2ddlm}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__)selfrKs r6__init__z@_general_metadata_cls.._PydanticGeneralMetadata.__init__gs $DMr5N)rKr )r0r1r2r3rTr/r5r6_PydanticGeneralMetadatarOds : %r5rU)annotated_typesr&r.)r&rUs r6rJrJ_s-%#3\% $#r5c 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 r6_check_protected_namespacesrzms )*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 r5Fct||}|jD]!\}}|j||vs|||_#y)N use_inspect)ritems description)clsfieldsr} fields_docsrq field_infos r6_update_fields_from_docstringsrsH-c{KK & ;*  ! ! )h+.E%0%:J ";r5c|j<|||}t|tstd|d|j||_yy)Nzfield_title_generator  must return str, not )titlerarc TypeError __class__)title_generator field_namerrs r6*_apply_field_title_generator_to_field_inforsV  J7%%4_4EE[\a\k\k[lmn n   r5c|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 r) alias_priorityaliasvalidation_aliasserialization_aliasrargenerate_aliasescallablercrrr#)alias_generatorrrrrrs r6$_apply_alias_generator_to_field_inforsh !!)  $ $ )    #  & & .  ) ) 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 2r5c|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_generatorrrr)config_wrapperrrrs r6update_field_from_configrsS'<<d@d@d(23H*V`a%%1,^-K-KZYcd2r5>copydictjson_iter_calculate_keys_copy_and_set_values> schemafrom_ormvalidate construct parse_obj parse_raw _get_value parse_file schema_jsonupdate_forward_refscttfdtDtfdtDfS)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. c3TK|]}t|dxt!ywrQrgid).0name BaseModel_methods r6 z4_deprecated_base_model_method_ids.. s0 'R\^bdhJi@i?vBvJ s((c3hK|])}tt|dddx t+yw)N__func__r)rrrfuncs r6rz4_deprecated_base_model_method_ids.. s:  D$ ?TRR_ tH s/2)r frozenset_deprecated_method_names_deprecated_classmethod_names)rrrs@@@r6!_deprecated_base_model_method_idsrsC*+J #;    5   r5) typevars_mapnamespace_infoc  (t}ddlm(m}|j}i}t |D]#} t | ddx} s|j| %tj||} tj|} i} |d| vr tddd | vr|js td d |jD]]}| j|}|tj|d r/t!d ||j"|| |<t%||_|j&D]h}|| vr||j(vrtd|dd|j"|}t+||rtd|ddtd|d|d|ddi}t-\}}t/}| j1D]\}\}}|d k(rt3|j4|||j6tj|r|j9|Zt;|s|t=|r|| vr|| vr||j>vr||j@vr||jBvr|t |dddk7rld}tEjFtI|r"tK|^}}tM(fd|Dd}|t!d |}|jO|||| |<"t ||tP}|tPur/tS||vst |ddx}tS||vrtP}|jTr|dk7rtd|dd|D]} tW| |s|| vrt |d ijd!}| |ur6tYjZ| rtYj| nd"Dchc]}|j\}}||vr~t_j`d#|d$|jbd%| jbd&tdd'(|tPurd|| vs||vr4|jg|thjj)} || _6|s"d*| _7n||jq}!|rts|!||d+,} n|!} nt+||rGtu|jvr2|jvjyd|}"|"|_;|"|jzd-<|j}||thjj)} || _?|| _6|sd*| _7nWd.| jvrI| js9t_j`d/|d0|d1|d2td'3|j9| t%|||j"d4}#||#jvrtd|d5|j6d6| ||<| jnst||| |jr t||d}$d7| vrd}%d7| vr|D]} t | d8d}%|%n|%=|r8|%jr,ttj|%j|d+9}$n0|%}$n-| d7\}&}'|'rtj|&|}&t|&|'9}$||$|| fScc}w#t$rYwxYw):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( PrivateAttrrXN) ns_resolver__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()defaultrYz 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']`.)rprqrrrsr1 functoolsc3<K|]}t|s|ywrQ)ra)rvr(s r6rz'collect_model_fields..s(`q 1N^@_(`srrootzUnexpected 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 ""r__sourceFT)rrlenientrfinalz 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[] = .`)categoryr`__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=)Nrrr(r __bases__reversedrgupdaterget_model_type_hintssafe_get_annotationsrrHrEgetis_classvar_annotationr rRdelattrrFrGrarsetr~rzrpr0addis_valid_field_nameis_valid_privateattr_namerArBrDr is_annotatedrrnext __set_name__rr__pydantic_root_model__re dataclasses is_dataclassrrmrnr2rofrom_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_rrrparent_fields_lookupbase model_fields type_hintscls_annotationsrAvar_namehintvaluerdeprecated_method_idsdeprecated_classmethod_func_ids class_varsrqann_type evaluated private_attr_rKassigned_value assigned_funcgeneric_originfielddataclass_fieldsrparent_field_infor decoratorspydantic_extra_infoparent_extra_infoannr=r(s) @r6collect_model_fieldsrsB*+J6 MME136"4)>E E< E ' ' 5633C[QJ$88=O68!  (#gnr  _ ,^5Y5Y#r6  '99 'H>>(+D|=#G#GQ#P044F \_\h\hiq\rHs/t"8,X& ''77 H?*>:::'XL)]^1 LL*E%,'XL(CDKk(?zUIV,,4:6jk:  ,$&F=^=`::5J+5+;+;+=fK''8Y ~ % #!/!D!D\\    / / 9 NN8 $ "8,*-h7/$66N$E$EEN$@$@@N$@$@@HlD9[H9= !..z(/CD#+H#5LA#'(`H(`bf#gL'#'(:KM#JL))#x8/;"8,  h0AB !2 2 ~ "7 7#*.*d"KKX}%)HH/N  & &8v+=#-h\9mn   DtX&?2").Mr!R!V!VW_!`>)JUIaIabfIg[-?-?-Emo$#(EJJ$ $// "8*F33C3C2DE))*!- + 8 . .?*h>R.R (77JZJ`J`7a 2: / +0J( %9$B$H$H$J!  !5){Q]gk"J"3J.*5:L^McMc:d )0088sC)0&?GG &x    $^Xz JMfKP..&sF348z)6:  6 $+D2KT$R!$0   ( 1 : :&7(667H7S7SUab!'# '8#&';Y?c li}|jd}|j|5|jjD]\}}|jr|||<|j }|a|jj |x} D|j|5tj| j g|j}dddt|||d|} t||| | ||<|j|jjsxtj|jjg|j} tj | |} tj| g|j} t#| d} n |j} ddd|| fS#1swYxYw#1swY| fSxYw)a^Rebuild the (already present) model fields by trying to reevaluate annotations. This function should be called whenever a model with incomplete fields is encountered. Returns: A two-tuple, the first element being the rebuilt fields, the second element being the rebuild `PydanticExtraInfo` instance, if available. 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. rNF)rrrr;Tr)rpushrXr~rrrr eval_typetypes_namespacerrrr=r;rrr:) rrrrrebuilt_fieldsrf_namerr; origin_field new_fieldrrebuilt_extra_infos r6rebuild_model_fieldsrGs,,.N  . .x 8F   # 1="%"9"9"?"?"A 3 FJ##)3v&'<< %6;U;U;Y;YZ`;a+a<*n%))&1%2%<%<(==&(88&  1 +!-!)  )K)2v&= 3@  & & 23;V;V;_;_))++66,,C))#|5J5J5VI11\iI #  r5)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-varrrN__is_pydantic_dataclass__r|)%rr __dataclass_fields__r__mro__rrrr~rrrrtyperinitrMISSINGdefault_factoryrainit_varrrr DATACLASSrrrrrrgsetattrvaluesapply_typevars_maprrre)rrrrrrr rrqdataclass_field base_annsglobalnslocalnsrrrr s r6collect_dataclass_fieldsr1s&*+J#%F-K// %;?''-    d #7 ?-=-C-C-E6 ?)/)>>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:+=+=>m6 ?7 ?7 ? ;?z]]_ 3E  $ $\ 2  3 ..&  $C)DEE   MS7 ?7 ?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)rrrXr~rrrrrrrrrrrr)r) rrrrrrrrrrrs r6rebuild_dataclass_fieldsr31s$*+J+-N   # 3"%"9"9"?"?"A 3 FJ##)3v& * 6 6 #--33 00 --c<@&??33,66@ BKAVAVAb (=(=hu %(K)2v&' 33, -3, s CDDc&|jd S)Nrrdrs r6rr_ss# ##r5cL|jdxr|jd S)Nr__r5r6s r6rrcs" ??3  =(=$==r5c tj|}t |j j }t|dk(xr/t|dxr|djtjuS#ttf$rYywxYw)zMWhether the provided default factory callable has a validated data parameter.Frr) rsignature_no_evalrhrlist parametersr+rlr"rrempty)r'sigr<s r6takes_validated_data_argumentr?gs--o> cnn++-.J z?a  q$5jm$D qTUI^I^bkbqbqIqq  "sA99B  B )validated_datacall_default_factoryc| t|S|r6|r!td|}| td||Std|}|StS)zMResolve the default value using either a static default or a default_factory.zCallable[[dict[str, Any]], Any]zpThe default factory requires the 'validated_data' argument, which was not provided when calling 'get_default()'.zCallable[[], Any])r$r rhr)rr'-default_factory_takes_validated_data_argumentr@rAfacs r6resolve_default_valuerEwshg&& 88/JC% G~& &*Orcs:s2-144+DD,</-$&"9M(!II,4 B+~ T401 T40HH1H> - $ $(8(( !( (  (V; !4 ! ! !/V:/VHK/VYb/Vde"h !22604 pG pG!pGpG / pG . pGbpGf K. K."K. K. ( K. ; K.h( ---(-  -  --h&**. i i"i# i ( i  iX+ +"+ + ( +  +\$> rH r, r*-1!&  P4?  *    r5