o niE @sRUddlZddlZddlZddlZddlZddlmZmZmZmZm Z m Z m Z m Z m Z mZmZmZmZmZmZddlmZmZddlmZmZddlmZddlmZddlm Z m!Z!ddl"m#Z#dd l$m%Z%m&Z&m'Z'm(Z(m)Z)dd l*m+Z+m,Z,ej-d krdd lmZed ddZ.eZ/eeeeeedffZ0e e/eefZ1ej-dkree0ee fZ2eee e1fZ3neZ2eZ3e2Z4e3Z5Gddde Z6dede eefdefddZ7dee6deedfddfddZ8i9j:Z;eeee?ffd d!Z@d"ee6d#e e>efd$e e>eAfd%e eeAfddf d&d'ZBdS)(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)r GenericModelT GenericModel)bound.)r" c@seZdZUdZdZeeed<eree e dfed<de e de e ee e edffde efd d Zede ede e edfdefd d Zed edee efddZdS)r%F __concrete__.__parameters__clsparamsreturnc sdtdtffdd }t||}|dur|Sjr$tjvr$tdt|t s,|f}t ur=t dd|Dr=td t d sKtd j d t|ttj|}t||re|reS|}t}t}d d|D}fdd|D} t\} } ttt t|f| pjft |d|dd| } |t| <| rd} |}t j!| jj"}| | ur|#|| } |d7}| | usj$| _$t ddt%|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. _paramsr-cs@t|}t|dkrt|dtrt|d|df}||fS)Nr)rlen isinstancelisttuple)r.argsr+r(T/var/www/html/arapca_proje/venv/lib/python3.10/site-packages/pydantic/v1/generics.py _cache_keyWs z2GenericModel.__class_getitem__.._cache_keyNz?Cannot parameterize a concrete instantiation of a generic modelcss|]}t|tVqdSN)r2r.0paramr(r(r7 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(r7 us"z2GenericModel.__class_getitem__..cs*i|]}|jvr|tj|jfqSr() __fields__r field_info)r;r?r6r(r7rAws*) __module____base__ __config____validators____cls_kwargs___cSsi|]}|dqSr9r(r:r(r(r7rAsr0r)(rCacheKey_generic_types_cachegetr)r __bases__ TypeErrorr2r4r%anyhasattr__name__check_parameters_countdictzipr*rkeysvalues__concrete_name__rritemsget_caller_frame_inforr rrD__parameterized_bases___assigned_parameterssysmodules__dict__ setdefaultConfigiter_contained_typevarsr1_prepare_model_fields)r+r,r8cached typevars_map model_name validators type_hintsinstance_type_hintsfields model_modulecalled_globally created_modelobject_by_referencereference_namereference_module_globals new_paramsr(r6r7__class_getitem__Ksr           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(r7 sz2GenericModel.__concrete_name__..z, [])joinrQ)r+r, param_namesparams_componentr(r(r7rWs zGenericModel.__concrete_name__rdc#sdttdtdtttffdd }jD]6}t|tsqt|dds&qtvrE|tvr/qfdd tD}|||EdHq||EdHqdS) 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_typesr-c3sBtfdd|jD}||}||us|urdS|VdS)Nc3s|]}|VqdSr9r(r:ryr(r7r=szQGenericModel.__parameterized_bases__..build_base_model..)r4r*rq)rxrybase_parametersparameterized_baser6rzr7build_base_models   z>GenericModel.__parameterized_bases__..build_base_modelr*Ncsi|] \}}|||qSr()rL)r;keyvalue)rdr(r7rAsz8GenericModel.__parameterized_bases__..) r r%ParametrizationrrM issubclassgetattrr[rX)r+rdr}rxryr()r+rdr7rZs,     z$GenericModel.__parameterized_bases__N)rQrD __qualname__ __slots__r)rbool__annotations__rr TypeVarTyper r$rrrq classmethodstrrWrrrZr(r(r(r7r%@s 6_( type_type_mapr-c ss|St|}t|}|tur|^}}tt|t|fS|tus,tjdkr2|tur2 ||S|r}tfdd|D}t ||rF|S|durbt |t rbt |t sbt |dddurbt t|j}|dushJtjdkry|tjuryttj|S||S|st|tr|js|j}tfdd|D}t ||r|S||St |ttfrtfdd|D}t ||r|S|S|st|trt|j|_|S ||}t |trt|S|S) 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!c3|]}t|VqdSr9 replace_types)r;argrr(r7r=r>z replace_types..N_name)r" c3rr9r)r;trr(r7r=0r>c3rr9r)r;elementrr(r7r=8r>) rrrrr4 ExtLiteralr\ version_inforrLrr2rrtypingrtypes UnionType functoolsreduceoperatoror_r r%r)r*r r3r inner_typerr) rr type_args origin_typeannotated_type annotationsresolved_type_args resolved_listnew_typer(rr7rsT         rr+ parametersc CsPt|}t|j}||kr&||krdnd}td|d|jd|d|dS)NmanyfewzToo z parameters for z ; actual z , expected )r1r*rNrQ)r+ractualexpected descriptionr(r(r7rRMs  "rR DictValuesr@ccst|tr |VdSt|dr!t|s!t|tr!|jEdHdSt|ttfr6|D] }t |EdHq*dSt |}|D] }t |EdHqsZ D       <"R