a _gE@sJUddlZddlZddlZddlmZmZmZmZmZmZm Z m Z m Z m Z m Z mZmZmZmZddlmZmZddlmZmZddlmZddlmZddlmZmZddl m!Z!dd l"m#Z#m$Z$m%Z%m&Z&m'Z'dd l(m)Z)m*Z*ej+d krdd lm,Z,ej+d kr ddlmZedddZ-eZ.e eeee edffZ/e e.eefZ0ej+dkrtee/eefZ1eeee0fZ2neZ1eZ2e1Z3e2Z4GdddeZ5ee eefedddZ6ee5e edfddddZ7i8j9Z:eee;d<ee e.dddZfdd d!Z?ee5e e=efe e=e@fe ee@fdd"d#d$ZAdS)%N) TYPE_CHECKINGAnyClassVarDict ForwardRefGenericIteratorListMappingOptionalTupleTypeTypeVarUnioncast)WeakKeyDictionaryWeakValueDictionary) AnnotatedLiteral)gather_all_validators) DeferredType) BaseModel create_model) JsonWrapper)display_as_typeget_all_type_hintsget_args get_origin typing_base) all_identicallenient_issubclass )_UnionGenericAliasr")r GenericModelT GenericModel)bound.)r" c@seZdZUdZdZeeed<er6ee e dfed<e e e e ee e edffe edddZee ee e edfedd d Zeeee ed d d ZdS)r(F __concrete__.__parameters__)clsparamsreturnc sttdfdd }t||}|dur.|SjrFtjvrFtdt|t sV|f}t urxt dd|Drxtdt d std j d t|ttj|}t||r|rȈS|}t}t}d d |D}fdd |D} t\} } ttt t|f| p(jft |d|dd| } |t| <| rd} |}t j!| jj"}| | ur|#|| } |d7}qrj$| _$t dd t%|D}| | _|r|| _| t||<t&|dkr| t||d<t'| | ||| S)aInstantiates a new class from a generic class `cls` and type variables `params`. :param params: Tuple of types the class . Given a generic class `Model` with 2 type variables and a concrete model `Model[str, int]`, the value `(str, int)` would be passed to `params`. :return: New model class inheriting from `cls` with instantiated types described by `params`. If no parameters are given, `cls` is returned as is. )_paramsr0cs@t|}t|dkr6t|dtr6t|d|df}||fS)Nr)rlen isinstancelisttuple)r1argsr.r+b/var/www/html/cobodadashboardai.evdpl.com/venv/lib/python3.9/site-packages/pydantic/v1/generics.py _cache_keyWsz2GenericModel.__class_getitem__.._cache_keyNz?Cannot parameterize a concrete instantiation of a generic modelcss|]}t|tVqdSN)r5r.0paramr+r+r: ez1GenericModel.__class_getitem__..zDType parameters should be placed on typing.Generic, not GenericModelr-zType z< must inherit from typing.Generic before being parameterizedcSs"i|]\}}t|tur||qSr+)rr)r>kvr+r+r: urAz2GenericModel.__class_getitem__..cs*i|]"}|jvr|tj|jfqSr+) __fields__rZ field_info)r>rBr9r+r:rDwrA) __module____base__Z __config__Z__validators__Z__cls_kwargs___cSsi|] }|dqSr<r+r=r+r+r:rDrAr3r)(rCacheKey_generic_types_cachegetr,r __bases__ TypeErrorr5r7r(anyhasattr__name__check_parameters_countdictzipr-rkeysvalues__concrete_name__rritemsget_caller_frame_inforr rrF__parameterized_bases___assigned_parameterssysmodules__dict__ setdefaultZConfigiter_contained_typevarsr4_prepare_model_fields)r.r/r;cached typevars_mapZ model_nameZ validatorsZ type_hintsinstance_type_hintsfieldsZ model_moduleZcalled_globally created_modelZobject_by_referenceZreference_nameZreference_module_globals new_paramsr+r9r:__class_getitem__Ksp             zGenericModel.__class_getitem__cCs*dd|D}d|}|jd|dS)aCompute class name for child classes. :param params: Tuple of types the class . Given a generic class `Model` with 2 type variables and a concrete model `Model[str, int]`, the value `(str, int)` would be passed to `params`. :return: String representing a the new class where `params` are passed to `cls` as type variables. This method can be overridden to achieve a custom naming scheme for GenericModels. cSsg|] }t|qSr+)rr=r+r+r: rAz2GenericModel.__concrete_name__..z, [])joinrP)r.r/Z param_namesZparams_componentr+r+r:rVs  zGenericModel.__concrete_name__)rbr0c#sttttttdfdd }jD]r}t|ts:q(q(t|ddsJq(q(tvr|tvr^q(qfddtD}|||EdHq(||EdHq(dS)a Returns unbound bases of cls parameterised to given type variables :param typevars_map: Dictionary of type applications for binding subclasses. Given a generic class `Model` with 2 type variables [S, T] and a concrete model `Model[str, int]`, the value `{S: str, T: int}` would be passed to `typevars_map`. :return: an iterator of generic sub classes, parameterised by `typevars_map` and other assigned parameters of `cls` e.g.: ``` class A(GenericModel, Generic[T]): ... class B(A[V], Generic[V]): ... assert A[int] in B.__parameterized_bases__({V: int}) ``` ) base_model mapped_typesr0c3s@tfdd|jD}||}||us2|ur6dS|VdS)Nc3s|]}|VqdSr<r+r=rmr+r:r@rAzQGenericModel.__parameterized_bases__..build_base_model..)r7r-rg)rlrmZbase_parametersZparameterized_baser9rnr:build_base_models  z>GenericModel.__parameterized_bases__..build_base_modelr-Ncsi|]\}}|||qSr+)rK)r>keyvalue)rbr+r:rDsz8GenericModel.__parameterized_bases__..) r r(ParametrizationrrL issubclassgetattrrZrW)r.rbrorlrmr+)r.rbr:rYs       z$GenericModel.__parameterized_bases__N)rPrF __qualname__ __slots__r,rbool__annotations__rr TypeVarTyper r'rrrg classmethodstrrVrrrrYr+r+r+r:r(@s 2_$)type_type_mapr0c ss|St|}t|}|tur>|^}}tt|t|fS|tusXtjdkrd|turd ||S|rtfdd|D}t ||r|S|durt |t rt |t st |dddurt t|j}|dusJtjdkr|tjurt||S||S|sDt|trD|jsD|j}tfdd|D}t ||r<|S||St |ttfr~tfdd|D}t ||rz|S|S|st|trt|j|_|S ||}t |trt|S|SdS) aReturn type with all occurrences of `type_map` keys recursively replaced with their values. :param type_: Any type, class or generic alias :param type_map: Mapping from `TypeVar` instance to concrete types. :return: New type representing the basic structure of `type_` with all `typevar_map` keys recursively replaced. >>> replace_types(Tuple[str, Union[List[str], float]], {str: int}) Tuple[int, Union[List[int], float]] r%c3s|]}t|VqdSr< replace_types)r>argr}r+r:r@rAz replace_types..N_namer!c3s|]}t|VqdSr<r~)r>trr+r:r@0rAc3s|]}t|VqdSr<r~)r>elementrr+r:r@8rA)rrrrr7 ExtLiteralr[ version_inforrKrr5rrttypingrtypesZ UnionTyper$r r(r,r-r r6rZ inner_typer{r) r|r}Z type_argsZ origin_typeannotated_type annotationsZresolved_type_argsZ resolved_listnew_typer+rr:rsX          r)r. parametersr0c CsPt|}t|j}||krL||kr&dnd}td|d|jd|d|dS)NmanyfewzToo z parameters for z ; actual z , expected )r4r-rMrP)r.ractualexpected descriptionr+r+r:rQMs  rQ DictValues)rCr0ccst|tr|Vnrt|drsN D         <R