o 7ήc? @sUddlZddlZddlmZmZmZmZmZmZmZm Z m Z m Z m Z m Z mZmZddlmZddlmZddlmZddlmZmZddlmZdd lmZmZmZmZmZdd l m!Z!m"Z"m#Z#e d d d Z$eZ%e e%e efZ&e!Z'e!e e eeee edfffe efe(d<e!Z)e!e ee&fe(d<Gdd d eZ*dede eefdefddZ+de e*de edfddfddZ,i-j.Z/e ee(d<dedee%fddZ0de e e1e2ffdd Z3d!e e*d"e e1efd#e e1e4fd$e ee4fddf d%d&Z5dS)'N) TYPE_CHECKINGAnyClassVarDictGenericIteratorListMappingOptionalTupleTypeTypeVarUnioncast) Annotated)gather_all_validators) DeferredType) BaseModel create_model) JsonWrapper)display_as_typeget_all_type_hintsget_args get_origin typing_base) LimitedDict all_identicallenient_issubclass GenericModelT GenericModel)bound._generic_types_cache_assigned_parametersc@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 sdtdttttttdffffdd }t||}|dur#|Sjr/tjvr/t dt |t s7|f}t urHt dd |DrHt d td sVt d jd t|ttj|}t||rp|rpS|}t}t}dd|D}fdd|D} t\} } ttt t|f| pjft |d|dd| } |t | <| rd} |}t!j"| jj#}| | ur|$|| } |d7}| | usLjj%| _%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)Nrr)rlen isinstancelisttuple)r*argsr'r$8/tmp/pip-target-vg8gfxp4/lib/python/pydantic/generics.py _cache_keyBs z2GenericModel.__class_getitem__.._cache_keyNz?Cannot parameterize a concrete instantiation of a generic modelcss|]}t|tVqdSN)r-r .0paramr$r$r2 Pz1GenericModel.__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)r6kvr$r$r2 `s"z2GenericModel.__class_getitem__..cs*i|]}|jvr|tj|jfqSr$) __fields__r field_info)r6r:r1r$r2r<bs*) __module____base__ __config____validators____cls_kwargs___cSsi|]}|dqSr4r$r5r$r$r2r<srr))rr r rr"getr%r __bases__ TypeErrorr-r/r anyhasattr__name__check_parameters_countdictzipr&rkeysvalues__concrete_name__rritemsget_caller_frame_inforrr?__parameterized_bases__r#sysmodules__dict__ setdefaultConfigiter_contained_typevarsr,_prepare_model_fields)r'r(r3cached typevars_map model_name validators type_hintsinstance_type_hintsfields model_modulecalled_globally created_modelobject_by_referencereference_namereference_module_globals new_paramsr$r1r2__class_getitem__6sr,          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$)rr5r$r$r2 sz2GenericModel.__concrete_name__..z, [])joinrJ)r'r( param_namesparams_componentr$r$r2rPs zGenericModel.__concrete_name__r\c#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|]}|VqdSr4r$r5rqr$r2r8szQGenericModel.__parameterized_bases__..build_base_model..)r/r&ri)rprqbase_parametersparameterized_baser1rrr2build_base_models   z>GenericModel.__parameterized_bases__..build_base_modelr&Ncsi|] \}}|||qSr$)rE)r6keyvalue)r\r$r2r<sz8GenericModel.__parameterized_bases__..) r r ParametrizationrrF issubclassgetattrr#rQ)r'r\rurprqr$)r'r\r2rSs,     z$GenericModel.__parameterized_bases__N)rJr? __qualname__ __slots__r%rbool__annotations__rr TypeVarTyper rrrri classmethodstrrPrxrrSr$r$r$r2r +s 6_( type_type_mapr)csZs|St|}t|}|tur|^}}tt|t|fS|rYtfdd|D}t||r3|S|durOt|trOt|tsOt|dddurOtt |j }|dusUJ||S|s|t |t r||j s||j}tfdd|D}t||rx|S||St|ttfrtfdd|D}t||r|S|S|st |trt|j|_|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]] c3|]}t|VqdSr4 replace_types)r6argrr$r2r8r9z replace_types..N_namec3rr4r)r6trr$r2r8r9c3rr4r)r6elementrr$r2r8r9)rrrrr/rr-rrztypingrrr r%r&rr.r inner_typerE)rr type_args origin_typeannotated_type annotationsresolved_type_args resolved_listr$rr2rsJ      rr' parametersc CsPt|}t|j}||kr&||krdnd}td|d|jd|d|dS)NmanyfewzToo z parameters for z ; actual z , expected )r,r&rGrJ)r'ractualexpected descriptionr$r$r2rK-s  "rK DictValuesr;ccst|tr |VdSt|dr!t|s!t|tr!|jEdHdSt|ttfr6|D] }t |EdHq*dSt |}|D] }t |EdHqsB @     6<"G