[config.git] / djavu-asus / elpy / rpc-venv / lib / python3.11 / site-packages / jedi / inference / gradual / base.py

from jedi.inference.cache import inference_state_method_cache
from jedi.inference.base_value import ValueSet, NO_VALUES, Value, \
    iterator_to_value_set, LazyValueWrapper, ValueWrapper
from jedi.inference.compiled import builtin_from_name
from jedi.inference.value.klass import ClassFilter
from jedi.inference.value.klass import ClassMixin
from jedi.inference.utils import to_list
from jedi.inference.names import AbstractNameDefinition, ValueName
from jedi.inference.context import ClassContext
from jedi.inference.gradual.generics import TupleGenericManager


class _BoundTypeVarName(AbstractNameDefinition):
    """
    This type var was bound to a certain type, e.g. int.
    """
    def __init__(self, type_var, value_set):
        self._type_var = type_var
        self.parent_context = type_var.parent_context
        self._value_set = value_set

    def infer(self):
        def iter_():
            for value in self._value_set:
                # Replace any with the constraints if they are there.
                from jedi.inference.gradual.typing import AnyClass
                if isinstance(value, AnyClass):
                    yield from self._type_var.constraints
                else:
                    yield value
        return ValueSet(iter_())

    def py__name__(self):
        return self._type_var.py__name__()

    def __repr__(self):
        return '<%s %s -> %s>' % (self.__class__.__name__, self.py__name__(), self._value_set)


class _TypeVarFilter:
    """
    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
    """
    def __init__(self, generics, type_vars):
        self._generics = generics
        self._type_vars = type_vars

    def get(self, name):
        for i, type_var in enumerate(self._type_vars):
            if type_var.py__name__() == name:
                try:
                    return [_BoundTypeVarName(type_var, self._generics[i])]
                except IndexError:
                    return [type_var.name]
        return []

    def values(self):
        # The values are not relevant. If it's not searched exactly, the type
        # vars are just global and should be looked up as that.
        return []


class _AnnotatedClassContext(ClassContext):
    def get_filters(self, *args, **kwargs):
        filters = super().get_filters(
            *args, **kwargs
        )
        yield from filters

        # The type vars can only be looked up if it's a global search and
        # not a direct lookup on the class.
        yield self._value.get_type_var_filter()


class DefineGenericBaseClass(LazyValueWrapper):
    def __init__(self, generics_manager):
        self._generics_manager = generics_manager

    def _create_instance_with_generics(self, generics_manager):
        raise NotImplementedError

    @inference_state_method_cache()
    def get_generics(self):
        return self._generics_manager.to_tuple()

    def define_generics(self, type_var_dict):
        from jedi.inference.gradual.type_var import TypeVar
        changed = False
        new_generics = []
        for generic_set in self.get_generics():
            values = NO_VALUES
            for generic in generic_set:
                if isinstance(generic, (DefineGenericBaseClass, TypeVar)):
                    result = generic.define_generics(type_var_dict)
                    values |= result
                    if result != ValueSet({generic}):
                        changed = True
                else:
                    values |= ValueSet([generic])
            new_generics.append(values)

        if not changed:
            # There might not be any type vars that change. In that case just
            # return itself, because it does not make sense to potentially lose
            # cached results.
            return ValueSet([self])

        return ValueSet([self._create_instance_with_generics(
            TupleGenericManager(tuple(new_generics))
        )])

    def is_same_class(self, other):
        if not isinstance(other, DefineGenericBaseClass):
            return False

        if self.tree_node != other.tree_node:
            # TODO not sure if this is nice.
            return False
        given_params1 = self.get_generics()
        given_params2 = other.get_generics()

        if len(given_params1) != len(given_params2):
            # If the amount of type vars doesn't match, the class doesn't
            # match.
            return False

        # Now compare generics
        return all(
            any(
                # TODO why is this ordering the correct one?
                cls2.is_same_class(cls1)
                # TODO I'm still not sure gather_annotation_classes is a good
                # idea. They are essentially here to avoid comparing Tuple <=>
                # tuple and instead compare tuple <=> tuple, but at the moment
                # the whole `is_same_class` and `is_sub_class` matching is just
                # not in the best shape.
                for cls1 in class_set1.gather_annotation_classes()
                for cls2 in class_set2.gather_annotation_classes()
            ) for class_set1, class_set2 in zip(given_params1, given_params2)
        )

    def get_signatures(self):
        return []

    def __repr__(self):
        return '<%s: %s%s>' % (
            self.__class__.__name__,
            self._wrapped_value,
            list(self.get_generics()),
        )


class GenericClass(DefineGenericBaseClass, ClassMixin):
    """
    A class that is defined with generics, might be something simple like:

        class Foo(Generic[T]): ...
        my_foo_int_cls = Foo[int]
    """
    def __init__(self, class_value, generics_manager):
        super().__init__(generics_manager)
        self._class_value = class_value

    def _get_wrapped_value(self):
        return self._class_value

    def get_type_hint(self, add_class_info=True):
        n = self.py__name__()
        # Not sure if this is the best way to do this, but all of these types
        # are a bit special in that they have type aliases and other ways to
        # become lower case. It's probably better to make them upper case,
        # because that's what you can use in annotations.
        n = dict(list="List", dict="Dict", set="Set", tuple="Tuple").get(n, n)
        s = n + self._generics_manager.get_type_hint()
        if add_class_info:
            return 'Type[%s]' % s
        return s

    def get_type_var_filter(self):
        return _TypeVarFilter(self.get_generics(), self.list_type_vars())

    def py__call__(self, arguments):
        instance, = super().py__call__(arguments)
        return ValueSet([_GenericInstanceWrapper(instance)])

    def _as_context(self):
        return _AnnotatedClassContext(self)

    @to_list
    def py__bases__(self):
        for base in self._wrapped_value.py__bases__():
            yield _LazyGenericBaseClass(self, base, self._generics_manager)

    def _create_instance_with_generics(self, generics_manager):
        return GenericClass(self._class_value, generics_manager)

    def is_sub_class_of(self, class_value):
        if super().is_sub_class_of(class_value):
            return True
        return self._class_value.is_sub_class_of(class_value)

    def with_generics(self, generics_tuple):
        return self._class_value.with_generics(generics_tuple)

    def infer_type_vars(self, value_set):
        # Circular
        from jedi.inference.gradual.annotation import merge_pairwise_generics, merge_type_var_dicts

        annotation_name = self.py__name__()
        type_var_dict = {}
        if annotation_name == 'Iterable':
            annotation_generics = self.get_generics()
            if annotation_generics:
                return annotation_generics[0].infer_type_vars(
                    value_set.merge_types_of_iterate(),
                )
        else:
            # Note: we need to handle the MRO _in order_, so we need to extract
            # the elements from the set first, then handle them, even if we put
            # them back in a set afterwards.
            for py_class in value_set:
                if py_class.is_instance() and not py_class.is_compiled():
                    py_class = py_class.get_annotated_class_object()
                else:
                    continue

                if py_class.api_type != 'class':
                    # Functions & modules don't have an MRO and we're not
                    # expecting a Callable (those are handled separately within
                    # TypingClassValueWithIndex).
                    continue

                for parent_class in py_class.py__mro__():
                    class_name = parent_class.py__name__()
                    if annotation_name == class_name:
                        merge_type_var_dicts(
                            type_var_dict,
                            merge_pairwise_generics(self, parent_class),
                        )
                        break

        return type_var_dict


class _LazyGenericBaseClass:
    def __init__(self, class_value, lazy_base_class, generics_manager):
        self._class_value = class_value
        self._lazy_base_class = lazy_base_class
        self._generics_manager = generics_manager

    @iterator_to_value_set
    def infer(self):
        for base in self._lazy_base_class.infer():
            if isinstance(base, GenericClass):
                # Here we have to recalculate the given types.
                yield GenericClass.create_cached(
                    base.inference_state,
                    base._wrapped_value,
                    TupleGenericManager(tuple(self._remap_type_vars(base))),
                )
            else:
                if base.is_class_mixin():
                    # This case basically allows classes like `class Foo(List)`
                    # to be used like `Foo[int]`. The generics are not
                    # necessary and can be used later.
                    yield GenericClass.create_cached(
                        base.inference_state,
                        base,
                        self._generics_manager,
                    )
                else:
                    yield base

    def _remap_type_vars(self, base):
        from jedi.inference.gradual.type_var import TypeVar
        filter = self._class_value.get_type_var_filter()
        for type_var_set in base.get_generics():
            new = NO_VALUES
            for type_var in type_var_set:
                if isinstance(type_var, TypeVar):
                    names = filter.get(type_var.py__name__())
                    new |= ValueSet.from_sets(
                        name.infer() for name in names
                    )
                else:
                    # Mostly will be type vars, except if in some cases
                    # a concrete type will already be there. In that
                    # case just add it to the value set.
                    new |= ValueSet([type_var])
            yield new

    def __repr__(self):
        return '<%s: %s>' % (self.__class__.__name__, self._lazy_base_class)


class _GenericInstanceWrapper(ValueWrapper):
    def py__stop_iteration_returns(self):
        for cls in self._wrapped_value.class_value.py__mro__():
            if cls.py__name__() == 'Generator':
                generics = cls.get_generics()
                try:
                    return generics[2].execute_annotation()
                except IndexError:
                    pass
            elif cls.py__name__() == 'Iterator':
                return ValueSet([builtin_from_name(self.inference_state, 'None')])
        return self._wrapped_value.py__stop_iteration_returns()

    def get_type_hint(self, add_class_info=True):
        return self._wrapped_value.class_value.get_type_hint(add_class_info=False)


class _PseudoTreeNameClass(Value):
    """
    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.
    """
    api_type = 'class'

    def __init__(self, parent_context, tree_name):
        super().__init__(
            parent_context.inference_state,
            parent_context
        )
        self._tree_name = tree_name

    @property
    def tree_node(self):
        return self._tree_name

    def get_filters(self, *args, **kwargs):
        # TODO this is obviously wrong. Is it though?
        class EmptyFilter(ClassFilter):
            def __init__(self):
                pass

            def get(self, name, **kwargs):
                return []

            def values(self, **kwargs):
                return []

        yield EmptyFilter()

    def py__class__(self):
        # This might not be 100% correct, but it is good enough. The details of
        # the typing library are not really an issue for Jedi.
        return builtin_from_name(self.inference_state, 'type')

    @property
    def name(self):
        return ValueName(self, self._tree_name)

    def get_qualified_names(self):
        return (self._tree_name.value,)

    def __repr__(self):
        return '%s(%s)' % (self.__class__.__name__, self._tree_name.value)


class BaseTypingValue(LazyValueWrapper):
    def __init__(self, parent_context, tree_name):
        self.inference_state = parent_context.inference_state
        self.parent_context = parent_context
        self._tree_name = tree_name

    @property
    def name(self):
        return ValueName(self, self._tree_name)

    def _get_wrapped_value(self):
        return _PseudoTreeNameClass(self.parent_context, self._tree_name)

    def get_signatures(self):
        return self._wrapped_value.get_signatures()

    def __repr__(self):
        return '%s(%s)' % (self.__class__.__name__, self._tree_name.value)


class BaseTypingClassWithGenerics(DefineGenericBaseClass):
    def __init__(self, parent_context, tree_name, generics_manager):
        super().__init__(generics_manager)
        self.inference_state = parent_context.inference_state
        self.parent_context = parent_context
        self._tree_name = tree_name

    def _get_wrapped_value(self):
        return _PseudoTreeNameClass(self.parent_context, self._tree_name)

    def __repr__(self):
        return '%s(%s%s)' % (self.__class__.__name__, self._tree_name.value,
                             self._generics_manager)


class BaseTypingInstance(LazyValueWrapper):
    def __init__(self, parent_context, class_value, tree_name, generics_manager):
        self.inference_state = class_value.inference_state
        self.parent_context = parent_context
        self._class_value = class_value
        self._tree_name = tree_name
        self._generics_manager = generics_manager

    def py__class__(self):
        return self._class_value

    def get_annotated_class_object(self):
        return self._class_value

    def get_qualified_names(self):
        return (self.py__name__(),)

    @property
    def name(self):
        return ValueName(self, self._tree_name)

    def _get_wrapped_value(self):
        object_, = builtin_from_name(self.inference_state, 'object').execute_annotation()
        return object_

    def __repr__(self):
        return '<%s: %s>' % (self.__class__.__name__, self._generics_manager)
Commit	Line	Data
53e6db90 DC	1	from jedi.inference.cache import inference_state_method_cache
	2	from jedi.inference.base_value import ValueSet, NO_VALUES, Value, \
	3	iterator_to_value_set, LazyValueWrapper, ValueWrapper
	4	from jedi.inference.compiled import builtin_from_name
	5	from jedi.inference.value.klass import ClassFilter
	6	from jedi.inference.value.klass import ClassMixin
	7	from jedi.inference.utils import to_list
	8	from jedi.inference.names import AbstractNameDefinition, ValueName
	9	from jedi.inference.context import ClassContext
	10	from jedi.inference.gradual.generics import TupleGenericManager
	11
	12
	13	class _BoundTypeVarName(AbstractNameDefinition):
	14	"""
	15	This type var was bound to a certain type, e.g. int.
	16	"""
	17	def __init__(self, type_var, value_set):
	18	self._type_var = type_var
	19	self.parent_context = type_var.parent_context
	20	self._value_set = value_set
	21
	22	def infer(self):
	23	def iter_():
	24	for value in self._value_set:
	25	# Replace any with the constraints if they are there.
	26	from jedi.inference.gradual.typing import AnyClass
	27	if isinstance(value, AnyClass):
	28	yield from self._type_var.constraints
	29	else:
	30	yield value
	31	return ValueSet(iter_())
	32
	33	def py__name__(self):
	34	return self._type_var.py__name__()
	35
	36	def __repr__(self):
	37	return '<%s %s -> %s>' % (self.__class__.__name__, self.py__name__(), self._value_set)
	38
	39
	40	class _TypeVarFilter:
	41	"""
	42	A filter for all given variables in a class.
	43
	44	A = TypeVar('A')
	45	B = TypeVar('B')
	46	class Foo(Mapping[A, B]):
	47	...
	48
	49	In this example we would have two type vars given: A and B
	50	"""
	51	def __init__(self, generics, type_vars):
	52	self._generics = generics
	53	self._type_vars = type_vars
	54
	55	def get(self, name):
	56	for i, type_var in enumerate(self._type_vars):
	57	if type_var.py__name__() == name:
	58	try:
	59	return [_BoundTypeVarName(type_var, self._generics[i])]
	60	except IndexError:
	61	return [type_var.name]
	62	return []
	63
	64	def values(self):
65	# The values are not relevant. If it's not searched exactly, the type
66	# vars are just global and should be looked up as that.
67	return []
68
69
70	class _AnnotatedClassContext(ClassContext):
71	def get_filters(self, args, *kwargs):
72	filters = super().get_filters(
73	args, *kwargs
74	)
75	yield from filters
76
77	# The type vars can only be looked up if it's a global search and
78	# not a direct lookup on the class.
79	yield self._value.get_type_var_filter()
80
81
82	class DefineGenericBaseClass(LazyValueWrapper):
83	def __init__(self, generics_manager):
84	self._generics_manager = generics_manager
85
86	def _create_instance_with_generics(self, generics_manager):
87	raise NotImplementedError
88
89	@inference_state_method_cache()
90	def get_generics(self):
91	return self._generics_manager.to_tuple()
92
93	def define_generics(self, type_var_dict):
94	from jedi.inference.gradual.type_var import TypeVar
95	changed = False
96	new_generics = []
97	for generic_set in self.get_generics():
98	values = NO_VALUES
99	for generic in generic_set:
100	if isinstance(generic, (DefineGenericBaseClass, TypeVar)):
101	result = generic.define_generics(type_var_dict)
102	values \|= result
103	if result != ValueSet({generic}):
104	changed = True
105	else:
106	values \|= ValueSet([generic])
107	new_generics.append(values)
108
109	if not changed:
110	# There might not be any type vars that change. In that case just
111	# return itself, because it does not make sense to potentially lose
112	# cached results.
113	return ValueSet([self])
114
115	return ValueSet([self._create_instance_with_generics(
116	TupleGenericManager(tuple(new_generics))
117	)])
118
119	def is_same_class(self, other):
120	if not isinstance(other, DefineGenericBaseClass):
121	return False
122
123	if self.tree_node != other.tree_node:
124	# TODO not sure if this is nice.
125	return False
126	given_params1 = self.get_generics()
127	given_params2 = other.get_generics()
128
129	if len(given_params1) != len(given_params2):
130	# If the amount of type vars doesn't match, the class doesn't
131	# match.
132	return False
133
134	# Now compare generics
135	return all(
136	any(
137	# TODO why is this ordering the correct one?
138	cls2.is_same_class(cls1)
139	# TODO I'm still not sure gather_annotation_classes is a good
140	# idea. They are essentially here to avoid comparing Tuple <=>
141	# tuple and instead compare tuple <=> tuple, but at the moment
142	# the whole `is_same_class` and `is_sub_class` matching is just
143	# not in the best shape.
144	for cls1 in class_set1.gather_annotation_classes()
145	for cls2 in class_set2.gather_annotation_classes()
146	) for class_set1, class_set2 in zip(given_params1, given_params2)
147	)
148
149	def get_signatures(self):
150	return []
151
152	def __repr__(self):
153	return '<%s: %s%s>' % (
154	self.__class__.__name__,
155	self._wrapped_value,
156	list(self.get_generics()),
157	)
158
159
160	class GenericClass(DefineGenericBaseClass, ClassMixin):
161	"""
162	A class that is defined with generics, might be something simple like:
163
164	class Foo(Generic[T]): ...
165	my_foo_int_cls = Foo[int]
166	"""
167	def __init__(self, class_value, generics_manager):
168	super().__init__(generics_manager)
169	self._class_value = class_value
170
171	def _get_wrapped_value(self):
172	return self._class_value
173
174	def get_type_hint(self, add_class_info=True):
175	n = self.py__name__()
176	# Not sure if this is the best way to do this, but all of these types
177	# are a bit special in that they have type aliases and other ways to
178	# become lower case. It's probably better to make them upper case,
179	# because that's what you can use in annotations.
180	n = dict(list="List", dict="Dict", set="Set", tuple="Tuple").get(n, n)
181	s = n + self._generics_manager.get_type_hint()
182	if add_class_info:
183	return 'Type[%s]' % s
184	return s
185
186	def get_type_var_filter(self):
187	return _TypeVarFilter(self.get_generics(), self.list_type_vars())
188
189	def py__call__(self, arguments):
190	instance, = super().py__call__(arguments)
191	return ValueSet([_GenericInstanceWrapper(instance)])
192
193	def _as_context(self):
194	return _AnnotatedClassContext(self)
195
196	@to_list
197	def py__bases__(self):
198	for base in self._wrapped_value.py__bases__():
199	yield _LazyGenericBaseClass(self, base, self._generics_manager)
200
201	def _create_instance_with_generics(self, generics_manager):
202	return GenericClass(self._class_value, generics_manager)
203
204	def is_sub_class_of(self, class_value):
205	if super().is_sub_class_of(class_value):
206	return True
207	return self._class_value.is_sub_class_of(class_value)
208
209	def with_generics(self, generics_tuple):
210	return self._class_value.with_generics(generics_tuple)
211
212	def infer_type_vars(self, value_set):
213	# Circular
214	from jedi.inference.gradual.annotation import merge_pairwise_generics, merge_type_var_dicts
215
216	annotation_name = self.py__name__()
217	type_var_dict = {}
218	if annotation_name == 'Iterable':
219	annotation_generics = self.get_generics()
220	if annotation_generics:
221	return annotation_generics[0].infer_type_vars(
222	value_set.merge_types_of_iterate(),
223	)
224	else:
225	# Note: we need to handle the MRO _in order_, so we need to extract
226	# the elements from the set first, then handle them, even if we put
227	# them back in a set afterwards.
228	for py_class in value_set:
229	if py_class.is_instance() and not py_class.is_compiled():
230	py_class = py_class.get_annotated_class_object()
231	else:
232	continue
233
234	if py_class.api_type != 'class':
235	# Functions & modules don't have an MRO and we're not
236	# expecting a Callable (those are handled separately within
237	# TypingClassValueWithIndex).
238	continue
239
240	for parent_class in py_class.py__mro__():
241	class_name = parent_class.py__name__()
242	if annotation_name == class_name:
243	merge_type_var_dicts(
244	type_var_dict,
245	merge_pairwise_generics(self, parent_class),
246	)
247	break
248
249	return type_var_dict
250
251
252	class _LazyGenericBaseClass:
253	def __init__(self, class_value, lazy_base_class, generics_manager):
254	self._class_value = class_value
255	self._lazy_base_class = lazy_base_class
256	self._generics_manager = generics_manager
257
258	@iterator_to_value_set
259	def infer(self):
260	for base in self._lazy_base_class.infer():
261	if isinstance(base, GenericClass):
262	# Here we have to recalculate the given types.
263	yield GenericClass.create_cached(
264	base.inference_state,
265	base._wrapped_value,
266	TupleGenericManager(tuple(self._remap_type_vars(base))),
267	)
268	else:
269	if base.is_class_mixin():
270	# This case basically allows classes like `class Foo(List)`
271	# to be used like `Foo[int]`. The generics are not
272	# necessary and can be used later.
273	yield GenericClass.create_cached(
274	base.inference_state,
275	base,
276	self._generics_manager,
277	)
278	else:
279	yield base
280
281	def _remap_type_vars(self, base):
282	from jedi.inference.gradual.type_var import TypeVar
283	filter = self._class_value.get_type_var_filter()
284	for type_var_set in base.get_generics():
285	new = NO_VALUES
286	for type_var in type_var_set:
287	if isinstance(type_var, TypeVar):
288	names = filter.get(type_var.py__name__())
289	new \|= ValueSet.from_sets(
290	name.infer() for name in names
291	)
292	else:
293	# Mostly will be type vars, except if in some cases
294	# a concrete type will already be there. In that
295	# case just add it to the value set.
296	new \|= ValueSet([type_var])
297	yield new
298
299	def __repr__(self):
300	return '<%s: %s>' % (self.__class__.__name__, self._lazy_base_class)
301
302
303	class _GenericInstanceWrapper(ValueWrapper):
304	def py__stop_iteration_returns(self):
305	for cls in self._wrapped_value.class_value.py__mro__():
306	if cls.py__name__() == 'Generator':
307	generics = cls.get_generics()
308	try:
309	return generics[2].execute_annotation()
310	except IndexError:
311	pass
312	elif cls.py__name__() == 'Iterator':
313	return ValueSet([builtin_from_name(self.inference_state, 'None')])
314	return self._wrapped_value.py__stop_iteration_returns()
315
316	def get_type_hint(self, add_class_info=True):
317	return self._wrapped_value.class_value.get_type_hint(add_class_info=False)
318
319
320	class _PseudoTreeNameClass(Value):
321	"""
322	In typeshed, some classes are defined like this:
323
324	Tuple: _SpecialForm = ...
325
326	Now this is not a real class, therefore we have to do some workarounds like
327	this class. Essentially this class makes it possible to goto that `Tuple`
328	name, without affecting anything else negatively.
329	"""
330	api_type = 'class'
331
332	def __init__(self, parent_context, tree_name):
333	super().__init__(
334	parent_context.inference_state,
335	parent_context
336	)
337	self._tree_name = tree_name
338
339	@property
340	def tree_node(self):
341	return self._tree_name
342
343	def get_filters(self, args, *kwargs):
344	# TODO this is obviously wrong. Is it though?
345	class EmptyFilter(ClassFilter):
346	def __init__(self):
347	pass
348
349	def get(self, name, **kwargs):
350	return []
351
352	def values(self, **kwargs):
353	return []
354
355	yield EmptyFilter()
356
357	def py__class__(self):
358	# This might not be 100% correct, but it is good enough. The details of
359	# the typing library are not really an issue for Jedi.
360	return builtin_from_name(self.inference_state, 'type')
361
362	@property
363	def name(self):
364	return ValueName(self, self._tree_name)
365
366	def get_qualified_names(self):
367	return (self._tree_name.value,)
368
369	def __repr__(self):
370	return '%s(%s)' % (self.__class__.__name__, self._tree_name.value)
371
372
373	class BaseTypingValue(LazyValueWrapper):
374	def __init__(self, parent_context, tree_name):
375	self.inference_state = parent_context.inference_state
376	self.parent_context = parent_context
377	self._tree_name = tree_name
378
379	@property
380	def name(self):
381	return ValueName(self, self._tree_name)
382
383	def _get_wrapped_value(self):
384	return _PseudoTreeNameClass(self.parent_context, self._tree_name)
385
386	def get_signatures(self):
387	return self._wrapped_value.get_signatures()
388
389	def __repr__(self):
390	return '%s(%s)' % (self.__class__.__name__, self._tree_name.value)
391
392
393	class BaseTypingClassWithGenerics(DefineGenericBaseClass):
394	def __init__(self, parent_context, tree_name, generics_manager):
395	super().__init__(generics_manager)
396	self.inference_state = parent_context.inference_state
397	self.parent_context = parent_context
398	self._tree_name = tree_name
399
400	def _get_wrapped_value(self):
401	return _PseudoTreeNameClass(self.parent_context, self._tree_name)
402
403	def __repr__(self):
404	return '%s(%s%s)' % (self.__class__.__name__, self._tree_name.value,
405	self._generics_manager)
406
407
408	class BaseTypingInstance(LazyValueWrapper):
409	def __init__(self, parent_context, class_value, tree_name, generics_manager):
410	self.inference_state = class_value.inference_state
411	self.parent_context = parent_context
412	self._class_value = class_value
413	self._tree_name = tree_name
414	self._generics_manager = generics_manager
415
416	def py__class__(self):
417	return self._class_value
418
419	def get_annotated_class_object(self):
420	return self._class_value
421
422	def get_qualified_names(self):
423	return (self.py__name__(),)
424
425	@property
426	def name(self):
427	return ValueName(self, self._tree_name)
428
429	def _get_wrapped_value(self):
430	object_, = builtin_from_name(self.inference_state, 'object').execute_annotation()
431	return object_
432
433	def __repr__(self):
434	return '<%s: %s>' % (self.__class__.__name__, self._generics_manager)