U EZh4@sUdZddlmZddlZddlZddlZddlZddlm Z m Z m Z ddl m Z ddlmZddlmZddlmZdd lmZmZmZmZmZmZdd lmZmZmZmZdd lm Z m!Z!d d l"m#Z#m$Z$d dl%m&Z&ej'rdZ(de)d<dZ*de)d<ddl+m,Z,e-e.e/e0e1e2e3e$j4eeeej5eee6j7e8j7hZ9de)d<e:e;ee e e hZ?de)d<dddddZ@dddd d!ZAdd"dd#d$d%ZBdddd&d'd(ZCdd)d*d+d,ZDd-dd.d/d0ZEed1ZFd2d2d2d3d4d5ZGd6dd7d8d9d:ZHed;ZIe0d<d=d>d?d@dAdBZJGdCdDdDe#jKZLej'r4d-dEd;dFdGdHZMnGdIdHdHZMedJZNdJdJdKdLdMZOePZQdNdNddOdPdQZRejSdRdSGdTdUdUZTdS)VzBucket 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)cached_property) Parameter) zip_longest)BuiltinFunctionTypeCodeType FunctionType GeneratorType LambdaType ModuleType)AnyCallableMappingTypeVar) 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_COLLECTIONSrbool)paramreturncCs|jtjtjfkS)aZReturn whether the parameter accepts a positional argument. ```python {test="skip" lint="skip"} def func(a, /, b, *, c): pass params = inspect.signature(func).parameters can_be_positional(params['a']) #> True can_be_positional(params['b']) #> True can_be_positional(params['c']) #> False ``` )kindrPOSITIONAL_ONLYPOSITIONAL_OR_KEYWORD)r!r&`/home/aprabhat/apps/x.techxrdev.in/venv/lib/python3.8/site-packages/pydantic/_internal/_utils.pycan_be_positionalCsr(rvr"cCst|ttttttfSN) isinstancelisttupleset frozensetr rr*r&r&r' sequence_likeVsr2z(type[Any] | tuple[type[Any], ...] | None)oclass_or_tupler"cCs(z t||WStk r"YdSXdSNF)r, TypeError)r3r4r&r&r'lenient_isinstanceZs r7)clsr4r"cCsDzt|tot||WStk r>t|tjr8YdSYnXdSr5)r,type issubclassr6rZ WithArgsTypes)r8r4r&r&r'lenient_issubclassas  r;zTypeGuard[type[BaseModel]])r8r"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. )rr;)r8rr&r&r'is_model_classjsr<str) 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)r>r&r&r'is_valid_identifierssrBKeyTypezdict[KeyType, Any])mappingupdating_mappingsr"cGsd|}|D]R}|D]D\}}||krTt||trTt|trTt|||||<q|||<qq |Sr+)copyitemsr,dict deep_update)rDrEZupdated_mappingZupdating_mappingkr*r&r&r'rI~s  rIzdict[Any, Any]None)rDupdater"cKs|dd|DdS)NcSsi|]\}}|dk r||qSr+r&).0rJr*r&r&r' sz#update_not_none..)rLrG)rDrLr&r&r'update_not_nonesrOT) name_factoryzlist[T] | tuple[T, ...]ztyping.Callable[[T], str]zlist[T]) input_listrQr"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)rRrQresultZ result_namesr*Zv_namer&r&r' unique_lists   rVc@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 | MappingIntStrAnyrK)valuerGr"cCs2||}t|ttfr(||t|}||_dSr+) _coerce_itemsr,r-r._normalize_indexeslenrX)selfrZrGr&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_truerXgetr^r`r&r&r' is_excludedszValueItems.is_excludedcCs ||jkS)z`Check if value is contained in self._items. :param item: key or index of value rXrcr&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)rXrbra)r^rgr`r&r&r' for_elements zValueItems.for_elementrintzdict[int | str, Any])rGv_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.)rGr,typingr AbstractSetrar6 __class__ _coerce_valuerimergerbrange setdefault) r^rGrjZnormalized_itemsZ all_itemsir*Z normalized_inormalized_itemr&r&r'r\s2 "       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&rMrJ)rvr&r' sz$ValueItems.merge..csg|]}|kr|qSr&r&rxrur&r'ryscsg|]}|kr|qSr&r&rxrzr&r'ry s)rw)rorar-rprb)r8rurvrwZ merge_keysZmergedrJZ merged_itemr&)rurvr'rps"    & zValueItems.merge)rGr"cCsFt|tjrn4t|tjr(t|d}nt|dd}td||S)N.rnz???z!Unexpected type of exclude value )r,rlrrmrHfromkeysgetattrr6)rG class_namer&r&r'r[s   zValueItems._coerce_items)rZr"cCs |dks||r|S||Sr+)rar[)r8rZr&r&r'roszValueItems._coerce_valuer)cCs|dkp|dkS)NT.r&r1r&r&r'ra$szValueItems.is_truez_repr.ReprArgsr"cCs d|jfgSr+rer^r&r&r' __repr_args__(szValueItems.__repr_args__N)F)__name__ __module__ __qualname____doc__ __slots__r_rdrfrhr\ classmethodrp staticmethodr[rorarr&r&r&r'rWs %% rWzCallable[[], T]name get_valuer"cCsdSr+r&rrr&r&r'LazyClassAttribute.rc@sFeZdZdZddddddZedd d d Zdd dd ddZdS)rzA descriptor exposing an attribute only accessible on a class (hidden from instances). The attribute is lazily computed and cached during the first access. r=zCallable[[], Any]rKrcCs||_||_dSr+r)r^rrr&r&r'r_8szLazyClassAttribute.__init__rr~cCs|Sr+)rrr&r&r'rZ<szLazyClassAttribute.valuez type[Any])instanceownerr"cCs*|dkr|jSt|jd|jddS)Nz attribute of z is class-only)rZAttributeErrorrr)r^rrr&r&r'__get__@szLazyClassAttribute.__get__N)rrrrr_rrZrr&r&r&r'r2s Obj)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. ) rnrrr.rFr6 ValueError RuntimeErrorr)robj_typer&r&r'smart_deepcopyIs 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_identical_s 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]rr=r)keyr"cCs|j|tSr+)rrbrr^rr&r&r' __getitem__{szSafeGetItemProxy.__getitem__r cCs |j|Sr+)r __contains__rr&r&r'rszSafeGetItemProxy.__contains__N) rrrrr__annotations__rrl TYPE_CHECKINGrr&r&r&r'rns r)Ur __future__rZ _annotations dataclassesr@rlweakref collectionsrrrrFr functoolsrinspectr itertoolsr typesr r r r rrrrrrtyping_extensionsrrrrZ _import_utilsrrrrrmainrrifloatcomplexr=r bytesr9ZNoneTyperefNotImplementedrnEllipsisrr-r/r.r0rHrr(r2r7r;r<rBrCrIrOrPrVZRepresentationrWrrrobjectrr dataclassrr&r&r&r's