o 7ήci@sUddlZddlZddlZddlmZmZmZddlmZddl m Z m Z ddl m Z mZmZmZmZmZddlmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&ddl'm(Z(dd l)m*Z*dd lm+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2dd l3m4Z4erdd l5m6Z6dd l7m8Z8ddl9m:Z:ddl;mZ>ddl?m@Z@ddlmAZAmBZBmCZCmDZDmEZEee&ee#ee#eFefe#eFeeffZGdZHdZIeJeKeLeFeMeNeOe+ee eejPeeeQjReSjRhZTe"e$eeUd<eVeWeXeYeZeeehZ[e"e$eeUd<deFdefddZ\ddde&eFdeJdeFfdd Z]dedeMfd!d"Z^d#ee$d$d%eFddfd&d'Z_d(ed)e&e$ee#e$ed*fdfdeMfd+d,Z`d-ed)e&e$ee#e$ed*fdfdeMfd.d/ZadeMfd0d1Zbd2eFdeMfd3d4Zce%d5Zdd6eedefd7eedefdeedeffd8d9Zed6eeefd:eddfd;d<Zfd=d>d?eKd@eKdAeKdeMfdBdCZgdDedEdFeeFdGfdHe$dIddJfdKdLZhdMe&e$d$e$dNfde$d$fdOdPZidQeFdeFfdRdSZjdQeFdeFfdTdUZke%dVZleFdWdXe&eele#eld*ffdYeelgeFfdeelfdZd[ZmGd\d]d]eFZnGd^d_d_ZoGd`dadaeoZpGdbdcdceoZqGdddedeZrdfdgdhdidjdkdldmdnZsdodpdeFfdqdrZte%dsZudMeudeufdtduZvdveFdeMfdwdxZwhdyZxdveFdeMfdzd{ZyezZ{d|eed}eedeMfd~dZ|dMe deFde fddZ}deeFdeFdeFfddZ~dedeFde#eFe#eFd*fffddZde$edeFde#eFe#e#eFd*fd*fffddZe%dZe%dZerGdddeZeeefZdSGdddeZZdS)N) OrderedDict defaultdictdeque)deepcopy)islice zip_longest)BuiltinFunctionTypeCodeType FunctionType GeneratorType LambdaType ModuleType) TYPE_CHECKING AbstractSetAnyCallable CollectionDict GeneratorIterableIteratorListMappingMutableMappingNoReturnOptionalSetTupleTypeTypeVarUnion) Annotated) ConfigError)NoneType WithArgsTypesall_literal_valuesdisplay_as_typeget_args get_originis_literal_typeis_union) version_info) Signature)Path) BaseConfig) Dataclass) ModelField BaseModel)AbstractSetIntStr DictIntStrAnyIntStrMappingIntStrAnyReprArgs) import_string sequence_likevalidate_field_namelenient_isinstancelenient_issubclass in_ipythonis_valid_identifier deep_updateupdate_not_nonealmost_equal_floats get_modelto_camelis_valid_fieldsmart_deepcopy PyObjectStrRepresentation GetterDict ValueItemsr,ClassAttribute path_typeROOT_KEYget_unique_discriminator_alias"get_discriminator_alias_and_valuesDUNDER_ATTRIBUTES LimitedDict__root__IMMUTABLE_NON_COLLECTIONS_TYPESBUILTIN_COLLECTIONS dotted_pathreturnc Csddlm}z |ddd\}}Wnty(}z td|d|d}~ww||}zt||WStyK}z td |d |d |d}~ww) z Stolen approximately from django. Import a dotted module path and return the attribute/class designated by the last name in the path. Raise ImportError if the import fails. r) import_module .r""z!" doesn't look like a module pathNzModule "z" does not define a "z " attribute) importlibrWstriprsplit ValueError ImportErrorgetattrAttributeError)rUrW module_path class_nameemodulerf5/tmp/pip-target-vg8gfxp4/lib/python/pydantic/utils.pyr9{s  r9P)max_lenvricCstdtt|trt||dkr|d|ddSz|}Wnty4|j|}Ynwt||krE|d|dd}|S)z` Truncate a value and add a unicode ellipsis (three dots) to the end if it was too long z:`truncate` is no-longer used by pydantic and is deprecatedNu…r") warningswarnDeprecationWarning isinstancestrlen__repr__ TypeError __class__)rjrirfrfrgtruncates    rvcCst|ttttttfSN)rplisttupleset frozensetr rrjrfrfrgr:sr:basesr3 field_namecCs0|D]}t||drtd|d|dqdS)zZ Ensure that the field's name does not shadow an existing attribute of the model. Nz Field name "zI" shadows a BaseModel attribute; use a different field name with "alias='z'".)r` NameError)r}r~baserfrfrgr;s r;oclass_or_tuple.cCs"zt||WStyYdSwNF)rprt)rrrfrfrgr<s   r<clscCs8z t|to t||WStyt|trYdSwr)rptype issubclassrtr%)rrrfrfrgr=s  r=cCs$ztdWdStyYdSw)zU Check whether we're in an ipython environment, including jupyter notebooks. __IPYTHON__FT)evalrrfrfrfrgr>s   r> identifiercCs|o t| S)z Checks that a string is a valid identifier and not a Python keyword. :param identifier: The identifier to test. :return: True if the identifier is valid. ) isidentifierkeyword iskeyword)rrfrfrgr?sr?KeyTypemappingupdating_mappingscGsd|}|D])}|D]"\}}||vr*t||tr*t|tr*t|||||<q |||<q q|Srw)copyitemsrpdictr@)rrupdated_mappingupdating_mappingkrjrfrfrgr@s  r@updatecKs|dd|DdS)NcSsi|] \}}|dur||qSrwrf).0rrjrfrfrg sz#update_not_none..)rr)rrrfrfrgrAsrAg:0yE>)deltavalue_1value_2rcCst|||kS)z4 Return True if two floats are almost equal )abs)rrrrfrfrgrBsrBinit).Nfieldsr1configr/r-cCstddlm}m}m}ddlm}||j}i}d} d} t|ddD]} | j | j ur.| } q#| || j <q#| rw|j } | D]9\} }|j}| |vsL||vrMq=t|s]| rZt| rZ| }nd} q=|jsed|jini}|||jfd |ji|||<q=|j|jurd} | r| rd |jfd |j fg}d d |D|krd}n| j }||vr|d7}||vs| j|d||<|t|ddS)z: Generate signature for model based on its fields r) Parameterr- signaturer")ExtraNFTdefault annotation__pydantic_self__datacSsg|]}|j|jfqSrf)namekind)rprfrfrg z,generate_model_signature.. extra_data_r) parametersreturn_annotation)inspectrr-rrrrvaluesrr VAR_KEYWORDrallow_population_by_field_nameraliasr?requiredr KEYWORD_ONLYrextraallowPOSITIONAL_OR_KEYWORDreplacerx)rrrrr-rrpresent_params merged_paramsvar_kw use_var_kwparam allow_namesr~field param_namekwargsdefault_model_signature var_kw_namerfrfrggenerate_model_signaturesX     robjr0cCsDddlm}z|j}Wn ty|}Ynwt||s td|S)Nr"r2z7Unsupported type, must be either BaseModel or dataclass)mainr3__pydantic_model__rarrt)rr3 model_clsrfrfrgrC.s    rCstringcCsddd|dDS)Ncss|]}|VqdSrw) capitalize)rwordrfrfrg <szto_camel..r)joinsplit)rrfrfrgrD;rDcCs4t|dkrt|}|d|ddS|S)Nr"r)rrrDlower)r pascal_stringrfrfrgto_lower_camel?s rT) name_factory input_listrcCsJg}g}|D]}||}||vr||||q||||<q|S)z Make a list unique while maintaining order. We update the list if another one with the same name is set (e.g. root validator overridden in subclass) )appendindex)rrresult result_namesrjv_namerfrfrg unique_listIs   rc@seZdZdZdefddZdS)rGz String class where repr doesn't include quotes. Useful with Representation when you want to return a string representation of something that valid (or pseudo-valid) python. rVcCt|Srw)rqselfrfrfrgrsfszPyObjectStr.__repr__N)__name__ __module__ __qualname____doc__rqrsrfrfrfrgrG`srGc @seZdZUdZeZeedfed<dddZ defdd Z d edefd d Z d e e ge fde dee ddffddZdefddZdefddZdddZdS)rHz Mixin to provide __str__, __repr__, and __pretty__ methods. See #884 for more details. __pretty__ is used by [devtools](https://python-devtools.helpmanual.io/) to provide human readable representations of objects. . __slots__rVr8cs"fddjD}dd|DS)a6 Returns the attributes to show in __str__, __repr__, and __pretty__ this is generally overridden. Can either return: * name - value pairs, e.g.: `[('foo_name', 'foo'), ('bar_name', ['b', 'a', 'r'])]` * or, just values, e.g.: `[(None, 'foo'), (None, ['b', 'a', 'r'])]` c3s|] }|t|fVqdSrw)r`)rsrrfrgr|z/Representation.__repr_args__..cSs g|] \}}|dur||fqSrwrfrarjrfrfrgr}s z0Representation.__repr_args__..)r)rattrsrfrrg __repr_args__tszRepresentation.__repr_args__cCs|jjS)zA Name of the instance's class, used in __repr__. )rurrrfrfrg __repr_name__szRepresentation.__repr_name__join_strcCs|dd|DS)Ncss2|]\}}|durt|n|d|VqdS)N=)reprrrfrfrgrs0z.Representation.__repr_str__..)rr)rrrfrfrg __repr_str__szRepresentation.__repr_str__fmtrNcks`|dVdV|D]\}}|dur|dV||VdVdVqdVdVdS) z Used by devtools (https://python-devtools.helpmanual.io/) to provide a human readable representations of objects (r"Nr,r))rr)rrrrvaluerfrfrg __pretty__s   zRepresentation.__pretty__cCs |dS)NrX)rrrfrfrg__str__ zRepresentation.__str__cCs|d|ddS)Nr, r)rrrrfrfrgrsrzRepresentation.__repr__RichReprResultccs2|D]\}}|dur|Vq||fVqdS)zGet fields for Rich libraryN)r)rr field_reprrfrfrg __rich_repr__s  zRepresentation.__rich_repr__rVr8)rVr)rrrrryrrrq__annotations__rrrrrrrrrsrrfrfrfrgrHjs   *rHc@seZdZdZdZdefddZdedefdd Zd%ded edefd d Z de efddZ de efddZ de efddZdeeeeffddZdeefddZdefddZdedefddZdedefddZd&d!d"Zdefd#d$Zd S)'rIz Hack to make object's smell just enough like dicts for validate_model. We can't inherit from Mapping[str, Any] because it upsets cython so we have to implement all methods ourselves. _objrcCs ||_dSrwr)rrrfrfrg__init__rzGetterDict.__init__keyrVc Cs2zt|j|WSty}zt||d}~wwrw)r`rraKeyError)rrrdrfrfrg __getitem__s  zGetterDict.__getitem__NrcCst|j||Srw)r`r)rrrrfrfrggetzGetterDict.getcCstS)zn We don't want to get any other attributes of obj if the model didn't explicitly ask for them )rzrrfrfrg extra_keysszGetterDict.extra_keyscCr)z Keys of the pseudo dictionary, uses a list not set so order information can be maintained like python dictionaries. )rxrrfrfrgkeysszGetterDict.keyscsfddDS)Ncsg|]}|qSrfrfrrrrfrgrsz%GetterDict.values..rfrrfrrgrzGetterDict.valuesccs |D] }|||fVqdSrw)r)rrrfrfrgrszGetterDict.itemsccs&t|jD] }|ds|VqdS)Nr)dirr startswith)rrrfrfrg__iter__s  zGetterDict.__iter__cCstdd|DS)Ncss|]}dVqdS)r"Nrf)rrrfrfrgrsz%GetterDict.__len__..)sumrrfrfrg__len__r zGetterDict.__len__itemcCs ||vSrw)r rrrfrfrg __contains__ zGetterDict.__contains__othercCst|t|kSrw)rr)rrrfrfrg__eq__szGetterDict.__eq__r8cCsdt|fgSrw)rrrfrfrgrr zGetterDict.__repr_args__cCsdt|jdS)Nz GetterDict[])r'rrrfrfrgrr zGetterDict.__repr_name__rwr)rrrrrrrrqrrrr rr rrrrrintrboolrrrrrfrfrfrgrIs  rIc @seZdZdZdZdededddfdd Zd edefd d Z d edefd dZ ddde edfddZ ddde ddfddZed(dedededefddZededddfddZededefd d!Zed"edefd#d$Zd)d&d'ZdS)*rJzY Class for more convenient calculation of excluded or included fields on values. )_items_typerr)r4r7rVNcCs2||}t|ttfr||t|}||_dSrw) _coerce_itemsrprxry_normalize_indexesrrr)rrrrfrfrgrs  zValueItems.__init__rcCs||j|S)z` Check if item is fully excluded. :param item: key or index of a value )is_truerrrrfrfrg is_excludedszValueItems.is_excludedcCs ||jvS)zh Check if value is contained in self._items :param item: key or index of value rrrfrfrg is_includeds zValueItems.is_includedrdr6cCs|j|}||s |SdS)z :param e: key or index of element on value :return: raw values for element if self._items is dict and contain needed element N)rrr )rrdrrfrfrg for_elements zValueItems.for_elementr7v_lengthr5c Csi}d}|D]F\}}t|ts&t|ts&||s&td|d|j|dkr0||}qt|ts9td|dkrA||n|}| || |||<q|sS|S||rgt |D]}| |dq\|St |D]}| |i}||s| ||||<qk|S)af :param items: dict or set of indexes which will be normalized :param v_length: length of sequence indexes of which will be >>> self._normalize_indexes({0: True, -2: True, -1: True}, 4) {0: True, 2: True, 3: True} >>> self._normalize_indexes({'__all__': True}, 4) {0: True, 1: True, 2: True, 3: True} Nz,Unexpected type of exclude value for index "z" __all__zExcluding fields from a sequence of sub-models or dicts must be performed index-wise: expected integer keys or keyword "__all__"r.) rrprrr rtru _coerce_valuermergerrange setdefault) rrr%normalized_items all_itemsirj normalized_inormalized_itemrfrfrgr s4        zValueItems._normalize_indexesFroverride intersectcs||durS|sdurS|r&|r$SS|r;fddDfddD}n tfddD}i}|D]}|j|||d}|durd|||<qL|S)ae Merge a ``base`` item with an ``override`` item. Both ``base`` and ``override`` are converted to dictionaries if possible. Sets are converted to dictionaries with the sets entries as keys and Ellipsis as values. Each key-value pair existing in ``base`` is merged with ``override``, while the rest of the key-value pairs are updated recursively with this function. Merging takes place based on the "union" of keys if ``intersect`` is set to ``False`` (default) and on the intersection of keys if ``intersect`` is set to ``True``. Ncg|]}|vr|qSrfrfr )r0rfrgrNrz$ValueItems.merge..cr2rfrfr rrfrgrNrcsg|]}|vr|qSrfrfr r3rfrgrPr)r1)r'r rxr(r)rrr0r1 merge_keysmergedr merged_itemrf)rr0rgr(3s$    &zValueItems.mergecCsJt|tr |St|trt|d}|St|dd}t|d||S)N.ruz???z!Unexpected type of exclude value )rprrrfromkeysr` assert_never)rrcrfrfrgrZs   zValueItems._coerce_itemscCs |dus ||r |S||Srw)r r)rrrfrfrgr'hs zValueItems._coerce_valuerjcCs|dup|duS)NT.rfr|rfrfrgr nszValueItems.is_truer8cCs d|jfgSrwr"rrfrfrgrrrzValueItems.__repr_args__)Fr)rrrrrrr rrr!r#rr$rr classmethodr( staticmethodrr'r rrfrfrfrgrJs" '& rJc@sDeZdZdZdZdededdfddZd ed eeddfd d Z dS) rKz1 Hide class attribute from its instances rrrrrVNcCs||_||_dSrwr;)rrrrfrfrgrs zClassAttribute.__init__instanceownercCs&|dur|jSt|jd|jd)Nz attribute of z is class-only)rrarr)rr<r=rfrfrg__get__szClassAttribute.__get__) rrrrrrqrrrr>rfrfrfrgrKvs rK directoryfilez mount pointsymlinkz block devicez char deviceFIFOsocket)is_diris_fileis_mount is_symlinkis_block_deviceis_char_deviceis_fifo is_socketrr.cCs:|sJdtD]\}}t||r|Sq dS)z0 Find out what sort of thing a path is. zpath does not existunknown)exists path_typesrr`)rmethodrrfrfrgrLs  rLObjc Csj|j}|tvr |Sz|s|tvr!|tur|WS|WSWt|SWt|Stttfy4Yt|Sw)z Return type as is for immutable built-in types Use obj.copy() for built-in empty collections Use copy.deepcopy() for non-empty collections and unknown objects ) rurSrTryrrtr^ RuntimeErrorr)robj_typerfrfrgrFs rFrcCs|dsdSt|kS)NrT)rrMrrfrfrgrEs rE>rrr __classcell____orig_bases____orig_class__rcCst| o|tvSrw)rErPrrfrfrgis_valid_private_namer rVleftrightcCs*t||tdD] \}}||urdSqdS)a Check that the items of `left` are the same objects as those in `right`. >>> a, b = object(), object() >>> all_identical([a, b, a], [a, b, a]) True >>> all_identical([a, b, [a]], [a, b, [a]]) # new list object, while "equal" is not "identical" False ) fillvalueFT)r_EMPTY)rWrX left_item right_itemrfrfrg all_identicals  r]msgcCst|)z Helper to make sure that we have covered all possible types. This is mostly useful for ``mypy``, docs: https://mypy.readthedocs.io/en/latest/literal_types.html#exhaustive-checks )rt)rr^rfrfrgr8sr8 all_aliasesdiscriminator_keycCs<t|}t|dkrtd|ddt|d|S)zNValidate that all aliases are the same and if that's the case return the aliasr"zAliases for discriminator z must be the same (got rr)rzrrr#rsortedpop)r_r`unique_aliasesrfrfrgrNs  rNtpc CsVt|dd}t|turt|d}t|dr|j}tt|r2t||\}}|tdd|DfS|r[|j t j }t||\}}t t |dkrUtd|d t|||dfSz|j |j }Wn-tyy}z td |jd |d }~wty}z td |jd||d }~wwt|std|d|jd|j |jt|fS)z Get alias and all valid values in the `Literal` type of the discriminator field `tp` can be a `BaseModel` class or directly an `Annotated` `Union` of many. __custom_root_type__Frrcss|] }|D]}|VqqdSrwrf)rrrjrfrfrgrrz5get_discriminator_alias_and_values..r"zField z& is not the same for all submodels of zType z* is not a valid `BaseModel` or `dataclass`NzModel z% needs a discriminator field for key z of model z needs to be a `Literal`)r`r)r!r(hasattrrr+_get_union_alias_and_all_valuesry __fields__rMtype_rrrzr#r'rartrrr*rr&)rdr` is_root_modelr all_values union_typet_discriminator_typerdrfrfrgrOs8       rOrlcs0fddt|D}t|\}}t||fS)Ncsg|]}t|qSrf)rO)rtr`rfrgr"sz3_get_union_alias_and_all_values..)r(ziprN)rlr`zipped_aliases_valuesr_rkrfrorgrgs rgKTVTc@seZdZddefddZdS)rQ size_limitcCdSrwrfrrurfrfrgr-sLimitedDict.__init__Nrt)rrrrrrfrfrfrgrQ,srQcsTeZdZdZddeffdd Zdededd ffd d Zd edefd dZZ S)rQa) Limit the size/length of a dict used for caching to avoid unlimited increase in memory usage. Since the dict is ordered, and we always remove elements from the beginning, this is effectively a FIFO cache. Annoying inheriting from `MutableMapping` breaks cython. rtrucs||_tdSrw)rusuperrrwrurfrgr;srx_LimitedDict__key_LimitedDict__valuerVNcs`t||t||jkr,t||j|jd}t|d|}|D]}||=q&dSdS)N )rz __setitem__rrrurxr )rr|r}excess to_removerr{rfrgr?szLimitedDict.__setitem__argscGrvrwrf)rrrfrfrg__class_getitem__GszLimitedDict.__class_getitem__ry) rrrrrrrrrrSrfrfr{rgrQ2s )rrmweakref collectionsrrrrr itertoolsrrtypesrr r r r r typingrrrrrrrrrrrrrrrrrrr typing_extensionsr!errorsr#r$r%r&r'r(r)r*r+versionr,rr-pathlibr.rr/ dataclassesr0rr1rr3r4r5r6r7r8rqrr&rMrfloatcomplexrbytesrrefNotImplementedruEllipsisrSrrxrzryr{rrTr9rvr:r;r<r=r>r?rr@rArBrrCrDrrrrGrHrIrJrKrNrLrPrFrErPrVobjectrZr]r8rNrOrgrrrsrQrfrfrfrgs   T  (       * 0 0   .   &A    <>    & )