o h-@sUdZddlmZddlZddlZddlZddlmZm Z m Z ddl m Z ddl mZddlmZmZmZmZmZmZddlmZmZdd lmZmZd d lmZmZejrhd 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<dOddZ7dPdd Z8dQd"d#Z9dRd%d&Z:dSd)d*Z;ed+Zed6Z?e'd7dVd=d>Z@Gd?d@d@ejAZBejrdWdCdDZCnGdEdDdDZCedFZDdXdHdIZEeFZGdYdMdNZHdS)ZzBucket 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_COLLECTIONSvrreturnboolcCst|ttttttfSN) isinstancelisttupleset frozensetr rrr&O/var/www/html/ai/venv/lib/python3.10/site-packages/pydantic/_internal/_utils.py sequence_like>sr(oclass_or_tuple(type[Any] | tuple[type[Any], ...] | NonecCs"zt||WStyYdSwNF)r TypeError)r)r*r&r&r'lenient_isinstanceBs   r.clscCs:z t|to t||WStyt|tjrYdSwr,)r type issubclassr-r WithArgsTypes)r/r*r&r&r'lenient_issubclassIs  r3TypeGuard[type[BaseModel]]cCsddlm}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)mainrr3)r/rr&r&r'is_model_classRs r6 identifierstrcCs|o t| 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)r7r&r&r'is_valid_identifier[sr<KeyTypemappingdict[KeyType, Any]updating_mappingscGsd|}|D])}|D]"\}}||vr*t||tr*t|tr*t|||||<q |||<q q|Sr)copyitemsr dict deep_update)r>r@updated_mappingupdating_mappingkrr&r&r'rDfs  rDdict[Any, Any]updateNonecKs|dd|DdS)NcSsi|] \}}|dur||qSrr&).0rGrr&r&r' rsz#update_not_none..)rIrB)r>rIr&r&r'update_not_noneqsrMT) name_factory input_listlist[T] | tuple[T, ...]rOtyping.Callable[[T], str]list[T]cCsJg}g}|D]}||}||vr||||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)rPrOresult result_namesrv_namer&r&r' unique_listxs   rYc@seZdZdZdZd-d d Zd.d dZd.ddZd/ddZd0ddZ e d1d2d d!Z e d3d"d#Z e d4d$d%Ze d5d'd(Zd6d*d+Zd,S)7 ValueItemszOClass for more convenient calculation of excluded or included fields on values.)_items_typevaluerrB$AbstractSetIntStr | MappingIntStrAnyrrJcCs2||}t|ttfr||t|}||_dSr) _coerce_itemsr r!r"_normalize_indexeslenr[)selfr]rBr&r&r'__init__s  zValueItems.__init__itemrcCs||j|S)zWCheck if item is fully excluded. :param item: key or index of a value )is_truer[getrbrdr&r&r' is_excludedszValueItems.is_excludedcCs ||jvS)z`Check if value is contained in self._items. :param item: key or index of value r[rgr&r&r' is_includeds zValueItems.is_includede int | str+AbstractSetIntStr | MappingIntStrAny | NonecCs|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)r[rfre)rbrkrdr&r&r' for_elements zValueItems.for_elementrv_lengthintdict[int | str, Any]c Cs i}d}|D]H\}}t|tjs(t|tjs(||s(td|d|j|dkr2||}qt|t s;td|dkrC||n|}| || |||<q|sU|S||rit |D]}| |dq^|St |D]}| |i}||s| ||||<qm|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.)rBr typingMapping AbstractSetrer- __class__ _coerce_valuerpmergerfrange setdefault) rbrBronormalized_items all_itemsir normalized_inormalized_itemr&r&r'r`s4 "       zValueItems._normalize_indexesFbaseoverride intersectcs||durS|sdurS|r&|r$SS|r;fddDfddD}n tfddD}i}|D]}|j|||d}|durd|||<qL|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`. Ncg|]}|vr|qSr&r&rKrG)rr&r' z$ValueItems.merge..crr&r&rrr&r'rrcsg|]}|vr|qSr&r&rrr&r'rr)r)rwrer!rxrf)r/rrr merge_keysmergedrG merged_itemr&)rrr'rxs$    &zValueItems.mergecCsHt|tjr |St|tjrt|d}|St|dd}td|)N.rvz???z!Unexpected type of exclude value )r rsrtrurCfromkeysgetattrr-)rB class_namer&r&r'r_s   zValueItems._coerce_itemscCs |dus ||r |S||Sr)rer_)r/r]r&r&r'rws zValueItems._coerce_valuercCs|dup|duS)NT.r&r%r&r&r're szValueItems.is_true_repr.ReprArgscCs d|jfgSrri)rbr&r&r' __repr_args__s zValueItems.__repr_args__N)r]rrBr^rrJ)rdrrr)rkrlrrm)rBrrorprrq)F)rrrrrrrr)rBr^rr)r]rrrrrrr)rr)__name__ __module__ __qualname____doc__ __slots__rcrhrjrnr` classmethodrx staticmethodr_rwrerr&r&r&r'rZs"     %%   rZnamer]cCsdSrr&rr]r&r&r'ClassAttributesrc@s(eZdZdZdZdd d ZdddZdS)rz(Hide class attribute from its instances.rrr8r]rrrJcCs||_||_dSrr)rbrr]r&r&r'rc s zClassAttribute.__init__instanceowner type[Any]cCs&|dur|jSt|jd|jd)Nz attribute of z is class-only)r]AttributeErrorrr)rbrrr&r&r'__get__$szClassAttribute.__get__N)rr8r]rrrJ)rrrrrrJ)rrrrrrcrr&r&r&r'rs  Objobjc Csj|j}|tvr |Sz|s|tvr!|tur|WS|WSWt|SWt|Stttfy4Yt|Sw)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. ) rvrrr"rAr- ValueError RuntimeErrorr)robj_typer&r&r'smart_deepcopy-s rlefttyping.Iterable[Any]rightcCs*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)rr left_item right_itemr&r&r' all_identicalCs  rr)r)rr*r+rr)r/rr*rrr)r/rrr4)r7r8rr)r>r?r@r?rr?)r>rHrIrrrJ)rPrQrOrRrrS)rr8r]rNrrN)rrrr)rrrrrr)Ir __future__r _annotationsr:rsweakref collectionsrrrrAr itertoolsrtypesrr r r r r rrtyping_extensionsrrrr TYPE_CHECKINGr__annotations__rr5rrpfloatcomplexr8rbytesr0NoneTyperefNotImplementedrvEllipsisrr!r#r"r$rCrr(r.r3r6r<r=rDrMrNrYRepresentationrZrrrobjectrrr&r&r&r's|