a Š©lcÂ<ã@s6ddlmZddlmZmZmZmZmZmZddl m Z ddlmZddlm Z ddlmZddlmZmZddlmZdd lmZGd d„deƒZGdd „d ƒZGdd„deƒZGdd„deƒZGdd„dee ƒZGdd„dƒZGdd„deƒZGdd„deƒZGdd„deƒZGdd„deƒZ Gdd„deƒZ!d S)!é)Úinference_state_method_cache)ÚValueSetÚ NO_VALUESÚValueÚiterator_to_value_setÚLazyValueWrapperÚValueWrapper)Úbuiltin_from_name©ÚClassFilter)Ú ClassMixin)Úto_list)ÚAbstractNameDefinitionÚ ValueName)ÚClassContext)ÚTupleGenericManagerc@s0eZdZdZdd„Zdd„Zdd„Zdd „Zd S)Ú_BoundTypeVarNamez> This type var was bound to a certain type, e.g. int. cCs||_|j|_||_dS©N)Ú _type_varÚparent_contextÚ _value_set)ÚselfÚtype_varÚ value_set©rúW/var/www/html/django/DPS/env/lib/python3.9/site-packages/jedi/inference/gradual/base.pyÚ__init__sz_BoundTypeVarName.__init__cs‡fdd„}t|ƒƒS)Nc3s<ˆjD]0}ddlm}t||ƒr0ˆjjEdHq|VqdS)Nr)ÚAnyClass)rZjedi.inference.gradual.typingrÚ isinstancerÚconstraints)Úvaluer©rrrÚiter_s z&_BoundTypeVarName.infer..iter_)r)rr"rr!rÚinfersz_BoundTypeVarName.infercCs |j ¡Sr)rÚ py__name__r!rrrr$!sz_BoundTypeVarName.py__name__cCsd|jj| ¡|jfS)Nz <%s %s -> %s>)Ú __class__Ú__name__r$rr!rrrÚ__repr__$sz_BoundTypeVarName.__repr__N)r&Ú __module__Ú__qualname__Ú__doc__rr#r$r'rrrrr s rc@s(eZdZdZdd„Zdd„Zdd„ZdS) Ú_TypeVarFilterzÛ A filter for all given variables in a class. A = TypeVar('A') B = TypeVar('B') class Foo(Mapping[A, B]): ... In this example we would have two type vars given: A and B cCs||_||_dSr)Ú _genericsÚ _type_vars)rÚgenericsZ type_varsrrrr3sz_TypeVarFilter.__init__c Cs\t|jƒD]L\}}| ¡|kr zt||j|ƒgWStyT|jgYS0q gSr)Ú enumerater-r$rr,Ú IndexErrorÚname)rr1ÚirrrrÚget7sz_TypeVarFilter.getcCsgSrrr!rrrÚvalues@sz_TypeVarFilter.valuesN)r&r(r)r*rr3r4rrrrr+(s r+cseZdZ‡fdd„Z‡ZS)Ú_AnnotatedClassContextc/s,tƒj|i|¤Ž}|EdH|j ¡VdSr)ÚsuperÚget_filtersÚ_valueÚget_type_var_filter)rÚargsÚkwargsÚfilters©r%rrr7Gsÿÿ z"_AnnotatedClassContext.get_filters)r&r(r)r7Ú __classcell__rrr=rr5Fsr5c@sJeZdZdd„Zdd„Zeƒdd„ƒZdd„Zd d „Zdd„Z d d„Z dS)ÚDefineGenericBaseClasscCs ||_dSr)Ú_generics_manager©rÚgenerics_managerrrrrSszDefineGenericBaseClass.__init__cCst‚dSr)ÚNotImplementedErrorrArrrÚ_create_instance_with_genericsVsz5DefineGenericBaseClass._create_instance_with_genericscCs |j ¡Sr)r@Zto_tupler!rrrÚget_genericsYsz#DefineGenericBaseClass.get_genericsc Cs¢ddlm}d}g}| ¡D]^}t}|D]F}t|t|fƒr`| |¡}||O}|t|hƒkrnd}q(|t|gƒO}q(| |¡q|sŠt|gƒSt| t t|ƒƒ¡gƒS)Nr©ÚTypeVarFT)Újedi.inference.gradual.type_varrGrErrr?Údefine_genericsrÚappendrDrÚtuple) rÚ type_var_dictrGÚchangedZnew_genericsZgeneric_setr4ZgenericÚresultrrrrI]s$ ÿz&DefineGenericBaseClass.define_genericscCsZt|tƒsdS|j|jkrdS| ¡}| ¡}t|ƒt|ƒkrBdStdd„t||ƒDƒƒS)NFc3s,|]$\}‰t‡fdd„| ¡DƒƒVqdS)c3s&|]}ˆ ¡D]}| |¡VqqdSr)Úgather_annotation_classesÚ is_same_class)Ú.0Zcls1Zcls2©Z class_set2rrÚ ˆsùzADefineGenericBaseClass.is_same_class...N)ÚanyrO)rQZ class_set1rrRrrS‡söøz7DefineGenericBaseClass.is_same_class..)rr?Ú tree_noderEÚlenÚallÚzip)rÚotherZ given_params1Z given_params2rrrrPws õz$DefineGenericBaseClass.is_same_classcCsgSrrr!rrrÚget_signatures•sz%DefineGenericBaseClass.get_signaturescCsd|jj|jt| ¡ƒfS)Nz <%s: %s%s>)r%r&Ú_wrapped_valueÚlistrEr!rrrr'˜s ýzDefineGenericBaseClass.__repr__N)r&r(r)rrDrrErIrPrZr'rrrrr?Rs r?cs~eZdZdZ‡fdd„Zdd„Zddd„Zd d „Z‡fdd„Zd d„Z e dd„ƒZdd„Z‡fdd„Z dd„Zdd„Z‡ZS)ÚGenericClassz– A class that is defined with generics, might be something simple like: class Foo(Generic[T]): ... my_foo_int_cls = Foo[int] cstƒ |¡||_dSr)r6rÚ_class_value)rÚclass_valuerBr=rrr§szGenericClass.__init__cCs|jSr©r^r!rrrÚ_get_wrapped_value«szGenericClass._get_wrapped_valueTcCs>| ¡}tddddd ||¡}||j ¡}|r:d|S|S)NÚListÚDictÚSetÚTuple)r\ÚdictÚsetrKzType[%s])r$rfr3r@Ú get_type_hint)rÚadd_class_infoÚnÚsrrrrh®szGenericClass.get_type_hintcCst| ¡| ¡ƒSr)r+rEZlist_type_varsr!rrrr9ºsz GenericClass.get_type_var_filtercstƒ |¡\}tt|ƒgƒSr)r6Ú py__call__rÚ_GenericInstanceWrapper)rÚ argumentsÚinstancer=rrrl½szGenericClass.py__call__cCst|ƒSr)r5r!rrrÚ_as_contextÁszGenericClass._as_contextccs$|j ¡D]}t|||jƒVq dSr)r[Úpy__bases__Ú_LazyGenericBaseClassr@©rÚbaserrrrqÄszGenericClass.py__bases__cCst|j|ƒSr)r]r^rArrrrDÉsz+GenericClass._create_instance_with_genericscstƒ |¡rdS|j |¡S)NT)r6Úis_sub_class_ofr^)rr_r=rrruÌszGenericClass.is_sub_class_ofcCs|j |¡Sr)r^Ú with_generics)rZgenerics_tuplerrrrvÑszGenericClass.with_genericsc Cs¬ddlm}m}| ¡}i}|dkrD| ¡}|r¨|d | ¡¡Snd|D]^}| ¡rH| ¡sH| ¡}nqH|j dkrtqH| ¡D](}| ¡} || kr||||||ƒƒqHq|qH|S)Nr)Úmerge_pairwise_genericsÚmerge_type_var_dictsÚIterableÚclass)Z!jedi.inference.gradual.annotationrwrxr$rEÚinfer_type_varsZmerge_types_of_iterateZis_instanceZis_compiledÚget_annotated_class_objectÚapi_typeÚ py__mro__) rrrwrxZannotation_namerLZannotation_genericsZpy_classZparent_classÚ class_namerrrr{Ôs0ÿ þzGenericClass.infer_type_vars)T)r&r(r)r*rrarhr9rlrpr rqrDrurvr{r>rrr=rr] s r]c@s0eZdZdd„Zedd„ƒZdd„Zdd„Zd S) rrcCs||_||_||_dSr)r^Ú_lazy_base_classr@)rr_Zlazy_base_classrBrrrrýsz_LazyGenericBaseClass.__init__c csf|j ¡D]V}t|tƒr.)rHrGr^r9rErrr3r$rZ from_sets)rrtrGÚfilterZtype_var_setÚnewrÚnamesrrrr‚s ÿz&_LazyGenericBaseClass._remap_type_varscCsd|jj|jfS©Nz<%s: %s>)r%r&r€r!rrrr'+sz_LazyGenericBaseClass.__repr__N)r&r(r)rrr#r‚r'rrrrrrüs rrc@seZdZdd„Zddd„ZdS)rmc Csz|jj ¡D]b}| ¡dkrL| ¡}z|d ¡WStyHYqn0q| ¡dkrtt|j dƒgƒSq|j ¡S)NÚ GeneratoréÚIteratorÚNone)r[r_r~r$rEÚexecute_annotationr0rr rÚpy__stop_iteration_returns)rÚclsr.rrrrŒ0sz2_GenericInstanceWrapper.py__stop_iteration_returnsTcCs|jjjddS)NF)ri)r[r_rh)rrirrrrh<sz%_GenericInstanceWrapper.get_type_hintN)T)r&r(r)rŒrhrrrrrm/srmcs\eZdZdZdZ‡fdd„Zedd„ƒZdd„Zd d „Z edd„ƒZ d d„Zdd„Z‡Z S)Ú_PseudoTreeNameClassa2 In typeshed, some classes are defined like this: Tuple: _SpecialForm = ... Now this is not a real class, therefore we have to do some workarounds like this class. Essentially this class makes it possible to goto that `Tuple` name, without affecting anything else negatively. rzcstƒ |j|¡||_dSr)r6rrÚ _tree_name©rrÚ tree_namer=rrrLs þz_PseudoTreeNameClass.__init__cCs|jSr)rr!rrrrUSsz_PseudoTreeNameClass.tree_nodecosGdd„dtƒ}|ƒVdS)Nc@s$eZdZdd„Zdd„Zdd„ZdS)z5_PseudoTreeNameClass.get_filters..EmptyFiltercSsdSrrr!rrrrZsz>_PseudoTreeNameClass.get_filters..EmptyFilter.__init__c[sgSrr)rr1r;rrrr3]sz9_PseudoTreeNameClass.get_filters..EmptyFilter.getc[sgSrr)rr;rrrr4`sz<_PseudoTreeNameClass.get_filters..EmptyFilter.valuesN)r&r(r)rr3r4rrrrÚEmptyFilterYsr’r )rr:r;r’rrrr7Ws z _PseudoTreeNameClass.get_filterscCst|jdƒS)NÚtype)r rr!rrrÚpy__class__esz _PseudoTreeNameClass.py__class__cCst||jƒSr©rrr!rrrr1jsz_PseudoTreeNameClass.namecCs |jjfSr)rr r!rrrÚget_qualified_namesnsz(_PseudoTreeNameClass.get_qualified_namescCsd|jj|jjfS©Nz%s(%s)©r%r&rr r!rrrr'qsz_PseudoTreeNameClass.__repr__)r&r(r)r*r}rÚpropertyrUr7r”r1r–r'r>rrr=rrŽ@s rŽc@s8eZdZdd„Zedd„ƒZdd„Zdd„Zd d „ZdS)ÚBaseTypingValuecCs|j|_||_||_dSr)rrrrrrrrvszBaseTypingValue.__init__cCst||jƒSrr•r!rrrr1{szBaseTypingValue.namecCst|j|jƒSr©rŽrrr!rrrrasz"BaseTypingValue._get_wrapped_valuecCs |j ¡Sr)r[rZr!rrrrZ‚szBaseTypingValue.get_signaturescCsd|jj|jjfSr—r˜r!rrrr'…szBaseTypingValue.__repr__N) r&r(r)rr™r1rarZr'rrrrršus ršcs,eZdZ‡fdd„Zdd„Zdd„Z‡ZS)ÚBaseTypingClassWithGenericscs$tƒ |¡|j|_||_||_dSr)r6rrrr)rrr‘rBr=rrrŠsz$BaseTypingClassWithGenerics.__init__cCst|j|jƒSrr›r!rrrrasz.BaseTypingClassWithGenerics._get_wrapped_valuecCsd|jj|jj|jfS)Nz%s(%s%s))r%r&rr r@r!rrrr'“sÿz$BaseTypingClassWithGenerics.__repr__)r&r(r)rrar'r>rrr=rrœ‰srœc@sHeZdZdd„Zdd„Zdd„Zdd„Zed d „ƒZdd„Z d d„Z dS)ÚBaseTypingInstancecCs$|j|_||_||_||_||_dSr)rrr^rr@)rrr_r‘rBrrrr™s zBaseTypingInstance.__init__cCs|jSrr`r!rrrr” szBaseTypingInstance.py__class__cCs|jSrr`r!rrrr|£sz-BaseTypingInstance.get_annotated_class_objectcCs | ¡fSr)r$r!rrrr–¦sz&BaseTypingInstance.get_qualified_namescCst||jƒSrr•r!rrrr1©szBaseTypingInstance.namecCst|jdƒ ¡\}|S)NÚobject)r rr‹)rZobject_rrrrasz%BaseTypingInstance._get_wrapped_valuecCsd|jj|jfSr†)r%r&r@r!rrrr'±szBaseTypingInstance.__repr__N)r&r(r)rr”r|r–r™r1rar'rrrrr˜s rN)"Zjedi.inference.cacherZjedi.inference.base_valuerrrrrrZjedi.inference.compiledr Zjedi.inference.value.klassrrZjedi.inference.utilsr Zjedi.inference.namesrrZjedi.inference.contextrZjedi.inference.gradual.genericsrrr+r5r?r]rrrmrŽršrœrrrrrÚs& N\35