def infer(self): """ Created to be used by inheritance. """ inference_state = self.inference_state is_coroutine = self.tree_node.parent.type in ('async_stmt', 'async_funcdef') from jedi.inference.gradual.base import GenericClass if is_coroutine: if self.is_generator(): async_generator_classes = inference_state.typing_module \ .py__getattribute__('AsyncGenerator') yield_values = self.merge_yield_values(is_async=True) # The contravariant doesn't seem to be defined. generics = (yield_values.py__class__(), NO_VALUES) return ValueSet( GenericClass(c, TupleGenericManager(generics)) for c in async_generator_classes ).execute_annotation() else: async_classes = inference_state.typing_module.py__getattribute__('Coroutine') return_values = self.get_return_values() # Only the first generic is relevant. generics = (return_values.py__class__(), NO_VALUES, NO_VALUES) return ValueSet( GenericClass(c, TupleGenericManager(generics)) for c in async_classes ).execute_annotation() else: if self.is_generator(): return ValueSet([iterable.Generator(inference_state, self)]) else: return self.get_return_values()
def infer_param(function_value, param, ignore_stars=False): values = _infer_param(function_value, param) if ignore_stars: return values inference_state = function_value.inference_state if param.star_count == 1: tuple_ = builtin_from_name(inference_state, 'tuple') return ValueSet([ GenericClass( tuple_, TupleGenericManager((values, )), ) for c in values ]) elif param.star_count == 2: dct = builtin_from_name(inference_state, 'dict') generics = (ValueSet([builtin_from_name(inference_state, 'str')]), values) return ValueSet([ GenericClass( dct, TupleGenericManager(generics), ) for c in values ]) pass return values
def _get_wrapped_value(self): from jedi.inference.gradual.base import GenericClass from jedi.inference.gradual.generics import TupleGenericManager klass = compiled.builtin_from_name(self.inference_state, self.array_type) c, = GenericClass(klass, TupleGenericManager( self._cached_generics())).execute_annotation() return c
def _create_manager_for(cls, manager_cls='BaseManager'): managers = cls.inference_state.import_module( ('django', 'db', 'models', 'manager')).py__getattribute__(manager_cls) for m in managers: if m.is_class_mixin(): generics_manager = TupleGenericManager((ValueSet([cls]), )) for c in GenericClass(m, generics_manager).execute_annotation(): return c return None
def py__getitem__(self, index_value_set, contextualized_node): from jedi.inference.gradual.base import GenericClass if not index_value_set: return ValueSet([self]) return ValueSet( GenericClass( self, LazyGenericManager( context_of_index=contextualized_node.context, index_value=index_value, )) for index_value in index_value_set)
def py__getitem__(self, index_value_set, contextualized_node): from jedi.inference.gradual.base import GenericClass if not index_value_set: debug.warning( 'Class indexes inferred to nothing. Returning class instead') return ValueSet([self]) return ValueSet( GenericClass( self, LazyGenericManager( context_of_index=contextualized_node.context, index_value=index_value, )) for index_value in index_value_set)
def define_generics(self, type_var_dict): from jedi.inference.gradual.base import GenericClass def remap_type_vars(): """ The TypeVars in the resulting classes have sometimes different names and we need to check for that, e.g. a signature can be: def iter(iterable: Iterable[_T]) -> Iterator[_T]: ... However, the iterator is defined as Iterator[_T_co], which means it has a different type var name. """ for type_var in self.list_type_vars(): yield type_var_dict.get(type_var.py__name__(), NO_VALUES) if type_var_dict: return ValueSet([ GenericClass(self, TupleGenericManager(tuple(remap_type_vars()))) ]) return ValueSet({self})
def with_generics(self, generics_tuple): from jedi.inference.gradual.base import GenericClass return GenericClass( self, TupleGenericManager(generics_tuple) )