U #i1@sbUdZddlmZddlZddlZddlZddlZddlm Z m Z m Z ddl m Z ddlmZddlmZmZmZmZmZmZddlmZmZmZdd lmZmZd d lmZmZd d l m!Z!ej"rd Z#de$d<dZ%de$d<ddl&m'Z'e(e)e*e+e,e-e.ej/eeeej0eee1j2e3j2hZ4de$d<e5e6e7e8e9e e e hZ:de$d<dddddZ;ddddddZd'dd(d)d*Z?ed+Z@d,d,d,d-d.d/ZAd0dd1d2d3d4ZBed5ZCe+d6d7d8d9d:d;d<ZDGd=d>d>ejEZFej"rd'd5d5d?d@dAZGnGdBdAdAZGedCZHdCdCdDdEdFZIeJZKdGdGddHdIdJZLejMdKdLGdMdNdNZNdS)OzBucket 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)AnyMappingTypeVar) TypeAlias TypeGuard)_repr _typing_extra)import_cached_base_modelz3typing.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(a/var/www/html/me.goteku.com/backend/venv/lib/python3.8/site-packages/pydantic/_internal/_utils.py sequence_likeAsr*z(type[Any] | tuple[type[Any], ...] | None)oclass_or_tupler cCs(z t||WStk r"YdSXdSNF)r" TypeError)r+r,r(r(r)lenient_isinstanceEs r/)clsr,r cCsDzt|tot||WStk r>t|tjr8YdSYnXdSr-)r"type issubclassr.rZ WithArgsTypes)r0r,r(r(r)lenient_issubclassLs  r3zTypeGuard[type[BaseModel]])r0r cCst}t||o||k S)zReturns true if cls is a _proper_ subclass of BaseModel, and provides proper type-checking, unlike raw calls to lenient_issubclass. )rr3)r0rr(r(r)is_model_classUsr4str) identifierr cCs|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_mappingsr cGsd|}|D]R}|D]D\}}||krTt||trTt|trTt|||||<q|||<qq |Sr!)copyitemsr"dict deep_update)r<r=Zupdated_mappingZupdating_mappingkrr(r(r)rAis  rAzdict[Any, Any]None)r<updater cKs|dd|DdS)NcSsi|]\}}|dk r||qSr!r().0rBrr(r(r) usz#update_not_none..)rDr?)r<rDr(r(r)update_not_nonetsrGT) name_factoryzlist[T] | tuple[T, ...]ztyping.Callable[[T], str]zlist[T]) input_listrIr cCsJg}g}|D]8}||}||kr6||||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)rJrIresultZ result_namesrZv_namer(r(r) unique_list{s   rNc@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?r cCs2||}t|ttfr(||t|}||_dSr!) _coerce_itemsr"r#r$_normalize_indexeslenrP)selfrRr?r(r(r)__init__s zValueItems.__init__r)itemr cCs||j|S)zWCheck if item is fully excluded. :param item: key or index of a value )is_truerPgetrVrXr(r(r) is_excludedszValueItems.is_excludedcCs ||jkS)z`Check if value is contained in self._items. :param item: key or index of value rPr[r(r(r) is_includedszValueItems.is_includedz int | strz+AbstractSetIntStr | MappingIntStrAny | None)er cCs|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)rPrZrY)rVr_rXr(r(r) for_elements zValueItems.for_elementrintzdict[int | str, Any])r?v_lengthr c 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"typingr AbstractSetrYr. __class__ _coerce_valueramergerZrange setdefault) rVr?rbZnormalized_itemsZ all_itemsirZ normalized_inormalized_itemr(r(r)rTs2 "       zValueItems._normalize_indexesF)baseoverride intersectr cs||dkr S|s2dkr6S|rL|rHSS|rvfddDfddD}ntfddD}i}|D]0}|j|||d}|dk r|||<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|]}|kr|qSr(r(rErB)rnr(r) sz$ValueItems.merge..csg|]}|kr|qSr(r(rprmr(r)rqscsg|]}|kr|qSr(r(rprrr(r)rqs)ro)rgrYr#rhrZ)r0rmrnroZ merge_keysZmergedrBZ merged_itemr()rmrnr)rhs"    & zValueItems.merge)r?r cCsFt|tjrn4t|tjr(t|d}nt|dd}td||S)N.rfz???z!Unexpected type of exclude value )r"rdrrer@fromkeysgetattrr.)r? class_namer(r(r)rSs   zValueItems._coerce_items)rRr cCs |dks||r|S||Sr!)rYrS)r0rRr(r(r)rg szValueItems._coerce_valuercCs|dkp|dkS)NT.r(r'r(r(r)rYszValueItems.is_truez_repr.ReprArgs)r cCs d|jfgSr!r])rVr(r(r) __repr_args__szValueItems.__repr_args__N)F)__name__ __module__ __qualname____doc__ __slots__rWr\r^r`rT classmethodrh staticmethodrSrgrYrvr(r(r(r)rOs %% rOnamerRr cCsdSr!r(rrRr(r(r)ClassAttributerc@s8eZdZdZdZddddddZdd dd d d Zd S)rz(Hide class attribute from its instances.rr5rrCr~cCs||_||_dSr!r)rVrrRr(r(r)rW"szClassAttribute.__init__z type[Any])instanceownerr cCs*|dkr|jSt|jd|jddS)Nz attribute of z is class-only)rRAttributeErrorrrw)rVrrr(r(r)__get__&szClassAttribute.__get__N)rwrxryrzr{rWrr(r(r(r)rsObj)objr c Cs\|j}|tkr|Sz&|s6|tkr6|tkr,|n|WSWntttfk rRYnXt|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. ) rfrrr$r>r. ValueError RuntimeErrorr)robj_typer(r(r)smart_deepcopy/s rztyping.Iterable[Any])leftrightr cCs*t||tdD]\}}||k rdSqdS)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 _SENTINEL)rrZ left_itemZ right_itemr(r(r) all_identicalEs rT)frozenc@sDeZdZUdZdZded<ddddd Zejr@dd dd d Z d S)SafeGetItemProxyzWrapper redirecting `__getitem__` to `get` with a sentinel value as default This makes is safe to use in `operator.itemgetter` when some keys may be missing )wrappedzMapping[str, Any]rr5r)keyr cCs|j|tSr!)rrZrrVrr(r(r) __getitem__aszSafeGetItemProxy.__getitem__rcCs |j|Sr!)r __contains__rr(r(r)rjszSafeGetItemProxy.__contains__N) rwrxryrzr{__annotations__rrd TYPE_CHECKINGrr(r(r(r)rTs r)Orz __future__rZ _annotations dataclassesr8rdweakref collectionsrrrr>r itertoolsrtypesrr r r r r rrrtyping_extensionsrrrrZ _import_utilsrrrrrmainrrafloatcomplexr5rbytesr1ZNoneTyperefNotImplementedrfEllipsisrr#r%r$r&r@rr*r/r3r4r:r;rArGrHrNZRepresentationrOrrrobjectrr dataclassrr(r(r(r)s