a y{Jh-@s0UdZddlmZddlZddlZddlZddlmZm Z m Z ddl m Z ddl mZddlmZmZmZmZmZmZddlmZmZdd lmZmZd d lmZmZejrd Zd e d<dZ!d e d<ddl"m#Z#e$e%e&e'e(e)e*ej+eeeej,eee-j.e/j.hZ0de d<e1e2e3e4e5ee e hZ6de d<dddddZ7ddddddZ8ddddd d!Z9dd"d#d$d%Z:d&dd'd(d)Z;ed*Zed4Z?e'd5d6d7d8d9d:d;Z@Gdd?d@ZCnGdAd@d@ZCedBZDdBdBdCdDdEZEeFZGdFdFddGdHdIZHdS)JzBucket of reusable internal utilities. This should be reduced as much as possible with functions only used in one place, moved to that place. ) annotationsN) OrderedDict defaultdictdeque)deepcopy) zip_longest)BuiltinFunctionTypeCodeType FunctionType GeneratorType LambdaType ModuleType)AnyTypeVar) TypeAlias TypeGuard)_repr _typing_extraz3typing.Mapping[int, Any] | typing.Mapping[str, Any]rMappingIntStrAnyz1typing.AbstractSet[int] | typing.AbstractSet[str]AbstractSetIntStr BaseModelzset[type[Any]]IMMUTABLE_NON_COLLECTIONS_TYPESBUILTIN_COLLECTIONSrboolvreturncCst|ttttttfSN) isinstancelisttupleset frozensetr rrr'K/var/www/shaz/venv/lib/python3.9/site-packages/pydantic/_internal/_utils.py sequence_like>sr)z(type[Any] | tuple[type[Any], ...] | None)oclass_or_tuplercCs&z t||WSty YdS0dSNF)r! TypeError)r*r+r'r'r(lenient_isinstanceBs  r.)clsr+rcCsBzt|tot||WSty<t|tjr6YdSYn0dSr,)r!type issubclassr-rZ WithArgsTypes)r/r+r'r'r(lenient_issubclassIs   r2zTypeGuard[type[BaseModel]])r/rcCsddlm}t||o||uS)zReturns true if cls is a _proper_ subclass of BaseModel, and provides proper type-checking, unlike raw calls to lenient_issubclass. rr)mainrr2)r/rr'r'r(is_model_classRs r4str) identifierrcCs|ot| S)zChecks 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)r6r'r'r(is_valid_identifier[sr:KeyTypezdict[KeyType, Any])mappingupdating_mappingsrcGsd|}|D]R}|D]D\}}||vrTt||trTt|trTt|||||<q|||<qq |Sr )copyitemsr!dict deep_update)r<r=Zupdated_mappingZupdating_mappingkrr'r'r(rAfs  rAzdict[Any, Any]None)r<updatercKs|dd|DdS)NcSsi|]\}}|dur||qSr r').0rBrr'r'r( rz#update_not_none..)rDr?)r<rDr'r'r(update_not_noneqsrHT) name_factoryzlist[T] | tuple[T, ...]ztyping.Callable[[T], str]zlist[T]) input_listrJrcCsJg}g}|D]8}||}||vr6||||q ||||<q |S)zMake a list unique while maintaining order. We update the list if another one with the same name is set (e.g. model validator overridden in subclass). )appendindex)rKrJresultZ result_namesrZv_namer'r'r( unique_listxs   rOc@seZdZdZdZddddddZdd d d d Zdd d d dZdddddZddddddZ e d,ddd ddddZ e ddddd Z e ddd!d"d#Ze dd d$d%d&Zd'd(d)d*Zd+S)- ValueItemszOClass for more convenient calculation of excluded or included fields on values.)_items_typerz$AbstractSetIntStr | MappingIntStrAnyrC)valuer?rcCs2||}t|ttfr(||t|}||_dSr ) _coerce_itemsr!r"r#_normalize_indexeslenrQ)selfrSr?r'r'r(__init__s zValueItems.__init__r)itemrcCs||j|S)zWCheck if item is fully excluded. :param item: key or index of a value )is_truerQgetrWrYr'r'r( is_excludedszValueItems.is_excludedcCs ||jvS)z`Check if value is contained in self._items. :param item: key or index of value rQr\r'r'r( is_includedszValueItems.is_includedz int | strz+AbstractSetIntStr | MappingIntStrAny | None)ercCs|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)rQr[rZ)rWr`rYr'r'r( for_elements zValueItems.for_elementrintzdict[int | str, Any])r?v_lengthrc Cs i}d}|D]\}}t|tjsPt|tjsP||sPtd|d|j|dkrd||}qt|t svtd|dkr||n|}| || |||<q|s|S||rt |D]}| |dq|St |D]*}| |i}||s| ||||<q|S)a]: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.)r?r!typingMapping AbstractSetrZr- __class__ _coerce_valuerbmerger[range setdefault) rWr?rcZnormalized_itemsZ all_itemsirZ normalized_inormalized_itemr'r'r(rUs2 "       zValueItems._normalize_indexesF)baseoverride intersectrcs||dur S|s2dur6S|rL|rHSS|rvfddDfddD}ntfddD}i}|D]0}|j|||d}|dur|||<q|S)aHMerge 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`. Ncsg|]}|vr|qSr'r'rErB)rpr'r( rGz$ValueItems.merge..csg|]}|vr|qSr'r'rrror'r(rsrGcsg|]}|vr|qSr'r'rrrtr'r(rsrG)rq)rirZr"rjr[)r/rorprqZ merge_keysZmergedrBZ merged_itemr')rorpr(rjs"    & zValueItems.merge)r?rcCsFt|tjrn4t|tjr(t|d}nt|dd}td||S)N.rhz???z!Unexpected type of exclude value )r!rerfrgr@fromkeysgetattrr-)r? class_namer'r'r(rTs   zValueItems._coerce_items)rSrcCs |dus||r|S||Sr )rZrT)r/rSr'r'r(riszValueItems._coerce_valuercCs|dup|duS)NT.r'r&r'r'r(rZ szValueItems.is_truez_repr.ReprArgs)rcCs d|jfgSr r^)rWr'r'r( __repr_args__szValueItems.__repr_args__N)F)__name__ __module__ __qualname____doc__ __slots__rXr]r_rarU classmethodrj staticmethodrTrirZrxr'r'r'r(rPs %% rPnamerSrcCsdSr r'rrSr'r'r(ClassAttributesrc@s8eZdZdZdZddddddZdd dd d d Zd S)rz(Hide class attribute from its instances.rr5rrCrcCs||_||_dSr r)rWrrSr'r'r(rX szClassAttribute.__init__z type[Any])instanceownerrcCs*|dur|jSt|jd|jddS)Nz attribute of z is class-only)rSAttributeErrorrry)rWrrr'r'r(__get__$szClassAttribute.__get__N)ryrzr{r|r}rXrr'r'r'r(rsObj)objrc CsZ|j}|tvr|Sz&|s6|tvr6|tur,|n|WSWntttfyPYn0t|S)zReturn 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. ) rhrrr#r>r- ValueError RuntimeErrorr)robj_typer'r'r(smart_deepcopy-s rztyping.Iterable[Any])leftrightrcCs*t||tdD]\}}||urdSqdS)aCheck 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)rrZ left_itemZ right_itemr'r'r( all_identicalCs r)Ir| __future__rZ _annotationsr8reweakref collectionsrrrr>r itertoolsrtypesrr r r r r rrtyping_extensionsrrrr TYPE_CHECKINGr__annotations__rr3rrbfloatcomplexr5rbytesr0ZNoneTyperefNotImplementedrhEllipsisrr"r$r#r%r@rr)r.r2r4r:r;rArHrIrOZRepresentationrPrrrobjectrrr'r'r'r(sz