Uploaded Test files

venv/Lib/site-packages/jedi/inference/__init__.py

@@ -0,0 +1,197 @@
+"""
+Type inference of Python code in |jedi| is based on three assumptions:
+
+* The code uses as least side effects as possible. Jedi understands certain
+  list/tuple/set modifications, but there's no guarantee that Jedi detects
+  everything (list.append in different modules for example).
+* No magic is being used:
+
+  - metaclasses
+  - ``setattr()`` / ``__import__()``
+  - writing to ``globals()``, ``locals()``, ``object.__dict__``
+* The programmer is not a total dick, e.g. like `this
+  <https://github.com/davidhalter/jedi/issues/24>`_ :-)
+
+The actual algorithm is based on a principle I call lazy type inference.  That
+said, the typical entry point for static analysis is calling
+``infer_expr_stmt``. There's separate logic for autocompletion in the API, the
+inference_state is all about inferring an expression.
+
+TODO this paragraph is not what jedi does anymore, it's similar, but not the
+same.
+
+Now you need to understand what follows after ``infer_expr_stmt``. Let's
+make an example::
+
+    import datetime
+    datetime.date.toda# <-- cursor here
+
+First of all, this module doesn't care about completion. It really just cares
+about ``datetime.date``. At the end of the procedure ``infer_expr_stmt`` will
+return the ``date`` class.
+
+To *visualize* this (simplified):
+
+- ``InferenceState.infer_expr_stmt`` doesn't do much, because there's no assignment.
+- ``Context.infer_node`` cares for resolving the dotted path
+- ``InferenceState.find_types`` searches for global definitions of datetime, which
+  it finds in the definition of an import, by scanning the syntax tree.
+- Using the import logic, the datetime module is found.
+- Now ``find_types`` is called again by ``infer_node`` to find ``date``
+  inside the datetime module.
+
+Now what would happen if we wanted ``datetime.date.foo.bar``? Two more
+calls to ``find_types``. However the second call would be ignored, because the
+first one would return nothing (there's no foo attribute in ``date``).
+
+What if the import would contain another ``ExprStmt`` like this::
+
+    from foo import bar
+    Date = bar.baz
+
+Well... You get it. Just another ``infer_expr_stmt`` recursion. It's really
+easy. Python can obviously get way more complicated then this. To understand
+tuple assignments, list comprehensions and everything else, a lot more code had
+to be written.
+
+Jedi has been tested very well, so you can just start modifying code. It's best
+to write your own test first for your "new" feature. Don't be scared of
+breaking stuff. As long as the tests pass, you're most likely to be fine.
+
+I need to mention now that lazy type inference is really good because it
+only *inferes* what needs to be *inferred*. All the statements and modules
+that are not used are just being ignored.
+"""
+import parso
+from jedi.file_io import FileIO
+
+from jedi import debug
+from jedi import settings
+from jedi.inference import imports
+from jedi.inference import recursion
+from jedi.inference.cache import inference_state_function_cache
+from jedi.inference import helpers
+from jedi.inference.names import TreeNameDefinition
+from jedi.inference.base_value import ContextualizedNode, \
+    ValueSet, iterate_values
+from jedi.inference.value import ClassValue, FunctionValue
+from jedi.inference.syntax_tree import infer_expr_stmt, \
+    check_tuple_assignments, tree_name_to_values
+from jedi.inference.imports import follow_error_node_imports_if_possible
+from jedi.plugins import plugin_manager
+
+
+class InferenceState(object):
+    def __init__(self, project, environment=None, script_path=None):
+        if environment is None:
+            environment = project.get_environment()
+        self.environment = environment
+        self.script_path = script_path
+        self.compiled_subprocess = environment.get_inference_state_subprocess(self)
+        self.grammar = environment.get_grammar()
+
+        self.latest_grammar = parso.load_grammar(version='3.7')
+        self.memoize_cache = {}  # for memoize decorators
+        self.module_cache = imports.ModuleCache()  # does the job of `sys.modules`.
+        self.stub_module_cache = {}  # Dict[Tuple[str, ...], Optional[ModuleValue]]
+        self.compiled_cache = {}  # see `inference.compiled.create()`
+        self.inferred_element_counts = {}
+        self.mixed_cache = {}  # see `inference.compiled.mixed._create()`
+        self.analysis = []
+        self.dynamic_params_depth = 0
+        self.is_analysis = False
+        self.project = project
+        self.access_cache = {}
+        self.allow_descriptor_getattr = False
+        self.flow_analysis_enabled = True
+
+        self.reset_recursion_limitations()
+
+    def import_module(self, import_names, sys_path=None, prefer_stubs=True):
+        return imports.import_module_by_names(
+            self, import_names, sys_path, prefer_stubs=prefer_stubs)
+
+    @staticmethod
+    @plugin_manager.decorate()
+    def execute(value, arguments):
+        debug.dbg('execute: %s %s', value, arguments)
+        with debug.increase_indent_cm():
+            value_set = value.py__call__(arguments=arguments)
+        debug.dbg('execute result: %s in %s', value_set, value)
+        return value_set
+
+    @property
+    @inference_state_function_cache()
+    def builtins_module(self):
+        module_name = u'builtins'
+        if self.environment.version_info.major == 2:
+            module_name = u'__builtin__'
+        builtins_module, = self.import_module((module_name,), sys_path=())
+        return builtins_module
+
+    @property
+    @inference_state_function_cache()
+    def typing_module(self):
+        typing_module, = self.import_module((u'typing',))
+        return typing_module
+
+    def reset_recursion_limitations(self):
+        self.recursion_detector = recursion.RecursionDetector()
+        self.execution_recursion_detector = recursion.ExecutionRecursionDetector(self)
+
+    def get_sys_path(self, **kwargs):
+        """Convenience function"""
+        return self.project._get_sys_path(self, **kwargs)
+
+    def infer(self, context, name):
+        def_ = name.get_definition(import_name_always=True)
+        if def_ is not None:
+            type_ = def_.type
+            is_classdef = type_ == 'classdef'
+            if is_classdef or type_ == 'funcdef':
+                if is_classdef:
+                    c = ClassValue(self, context, name.parent)
+                else:
+                    c = FunctionValue.from_context(context, name.parent)
+                return ValueSet([c])
+
+            if type_ == 'expr_stmt':
+                is_simple_name = name.parent.type not in ('power', 'trailer')
+                if is_simple_name:
+                    return infer_expr_stmt(context, def_, name)
+            if type_ == 'for_stmt':
+                container_types = context.infer_node(def_.children[3])
+                cn = ContextualizedNode(context, def_.children[3])
+                for_types = iterate_values(container_types, cn)
+                n = TreeNameDefinition(context, name)
+                return check_tuple_assignments(n, for_types)
+            if type_ in ('import_from', 'import_name'):
+                return imports.infer_import(context, name)
+            if type_ == 'with_stmt':
+                return tree_name_to_values(self, context, name)
+            elif type_ == 'param':
+                return context.py__getattribute__(name.value, position=name.end_pos)
+        else:
+            result = follow_error_node_imports_if_possible(context, name)
+            if result is not None:
+                return result
+
+        return helpers.infer_call_of_leaf(context, name)
+
+    def parse_and_get_code(self, code=None, path=None, encoding='utf-8',
+                           use_latest_grammar=False, file_io=None, **kwargs):
+        if code is None:
+            if file_io is None:
+                file_io = FileIO(path)
+            code = file_io.read()
+        # We cannot just use parso, because it doesn't use errors='replace'.
+        code = parso.python_bytes_to_unicode(code, encoding=encoding, errors='replace')
+
+        if len(code) > settings._cropped_file_size:
+            code = code[:settings._cropped_file_size]
+
+        grammar = self.latest_grammar if use_latest_grammar else self.grammar
+        return grammar.parse(code=code, path=path, file_io=file_io, **kwargs), code
+
+    def parse(self, *args, **kwargs):
+        return self.parse_and_get_code(*args, **kwargs)[0]

venv/Lib/site-packages/jedi/inference/analysis.py

@@ -0,0 +1,217 @@
+"""
+Module for statical analysis.
+"""
+from parso.python import tree
+
+from jedi._compatibility import force_unicode
+from jedi import debug
+from jedi.inference.helpers import is_string
+
+
+CODES = {
+    'attribute-error': (1, AttributeError, 'Potential AttributeError.'),
+    'name-error': (2, NameError, 'Potential NameError.'),
+    'import-error': (3, ImportError, 'Potential ImportError.'),
+    'type-error-too-many-arguments': (4, TypeError, None),
+    'type-error-too-few-arguments': (5, TypeError, None),
+    'type-error-keyword-argument': (6, TypeError, None),
+    'type-error-multiple-values': (7, TypeError, None),
+    'type-error-star-star': (8, TypeError, None),
+    'type-error-star': (9, TypeError, None),
+    'type-error-operation': (10, TypeError, None),
+    'type-error-not-iterable': (11, TypeError, None),
+    'type-error-isinstance': (12, TypeError, None),
+    'type-error-not-subscriptable': (13, TypeError, None),
+    'value-error-too-many-values': (14, ValueError, None),
+    'value-error-too-few-values': (15, ValueError, None),
+}
+
+
+class Error(object):
+    def __init__(self, name, module_path, start_pos, message=None):
+        self.path = module_path
+        self._start_pos = start_pos
+        self.name = name
+        if message is None:
+            message = CODES[self.name][2]
+        self.message = message
+
+    @property
+    def line(self):
+        return self._start_pos[0]
+
+    @property
+    def column(self):
+        return self._start_pos[1]
+
+    @property
+    def code(self):
+        # The class name start
+        first = self.__class__.__name__[0]
+        return first + str(CODES[self.name][0])
+
+    def __unicode__(self):
+        return '%s:%s:%s: %s %s' % (self.path, self.line, self.column,
+                                    self.code, self.message)
+
+    def __str__(self):
+        return self.__unicode__()
+
+    def __eq__(self, other):
+        return (self.path == other.path and self.name == other.name
+                and self._start_pos == other._start_pos)
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __hash__(self):
+        return hash((self.path, self._start_pos, self.name))
+
+    def __repr__(self):
+        return '<%s %s: %s@%s,%s>' % (self.__class__.__name__,
+                                      self.name, self.path,
+                                      self._start_pos[0], self._start_pos[1])
+
+
+class Warning(Error):
+    pass
+
+
+def add(node_context, error_name, node, message=None, typ=Error, payload=None):
+    exception = CODES[error_name][1]
+    if _check_for_exception_catch(node_context, node, exception, payload):
+        return
+
+    # TODO this path is probably not right
+    module_context = node_context.get_root_context()
+    module_path = module_context.py__file__()
+    issue_instance = typ(error_name, module_path, node.start_pos, message)
+    debug.warning(str(issue_instance), format=False)
+    node_context.inference_state.analysis.append(issue_instance)
+    return issue_instance
+
+
+def _check_for_setattr(instance):
+    """
+    Check if there's any setattr method inside an instance. If so, return True.
+    """
+    module = instance.get_root_context()
+    node = module.tree_node
+    if node is None:
+        # If it's a compiled module or doesn't have a tree_node
+        return False
+
+    try:
+        stmt_names = node.get_used_names()['setattr']
+    except KeyError:
+        return False
+
+    return any(node.start_pos < n.start_pos < node.end_pos
+               # Check if it's a function called setattr.
+               and not (n.parent.type == 'funcdef' and n.parent.name == n)
+               for n in stmt_names)
+
+
+def add_attribute_error(name_context, lookup_value, name):
+    message = ('AttributeError: %s has no attribute %s.' % (lookup_value, name))
+    # Check for __getattr__/__getattribute__ existance and issue a warning
+    # instead of an error, if that happens.
+    typ = Error
+    if lookup_value.is_instance() and not lookup_value.is_compiled():
+        # TODO maybe make a warning for __getattr__/__getattribute__
+
+        if _check_for_setattr(lookup_value):
+            typ = Warning
+
+    payload = lookup_value, name
+    add(name_context, 'attribute-error', name, message, typ, payload)
+
+
+def _check_for_exception_catch(node_context, jedi_name, exception, payload=None):
+    """
+    Checks if a jedi object (e.g. `Statement`) sits inside a try/catch and
+    doesn't count as an error (if equal to `exception`).
+    Also checks `hasattr` for AttributeErrors and uses the `payload` to compare
+    it.
+    Returns True if the exception was catched.
+    """
+    def check_match(cls, exception):
+        if not cls.is_class():
+            return False
+
+        for python_cls in exception.mro():
+            if cls.py__name__() == python_cls.__name__ \
+                    and cls.parent_context.is_builtins_module():
+                return True
+        return False
+
+    def check_try_for_except(obj, exception):
+        # Only nodes in try
+        iterator = iter(obj.children)
+        for branch_type in iterator:
+            next(iterator)  # The colon
+            suite = next(iterator)
+            if branch_type == 'try' \
+                    and not (branch_type.start_pos < jedi_name.start_pos <= suite.end_pos):
+                return False
+
+        for node in obj.get_except_clause_tests():
+            if node is None:
+                return True  # An exception block that catches everything.
+            else:
+                except_classes = node_context.infer_node(node)
+                for cls in except_classes:
+                    from jedi.inference.value import iterable
+                    if isinstance(cls, iterable.Sequence) and \
+                            cls.array_type == 'tuple':
+                        # multiple exceptions
+                        for lazy_value in cls.py__iter__():
+                            for typ in lazy_value.infer():
+                                if check_match(typ, exception):
+                                    return True
+                    else:
+                        if check_match(cls, exception):
+                            return True
+
+    def check_hasattr(node, suite):
+        try:
+            assert suite.start_pos <= jedi_name.start_pos < suite.end_pos
+            assert node.type in ('power', 'atom_expr')
+            base = node.children[0]
+            assert base.type == 'name' and base.value == 'hasattr'
+            trailer = node.children[1]
+            assert trailer.type == 'trailer'
+            arglist = trailer.children[1]
+            assert arglist.type == 'arglist'
+            from jedi.inference.arguments import TreeArguments
+            args = TreeArguments(node_context.inference_state, node_context, arglist)
+            unpacked_args = list(args.unpack())
+            # Arguments should be very simple
+            assert len(unpacked_args) == 2
+
+            # Check name
+            key, lazy_value = unpacked_args[1]
+            names = list(lazy_value.infer())
+            assert len(names) == 1 and is_string(names[0])
+            assert force_unicode(names[0].get_safe_value()) == payload[1].value
+
+            # Check objects
+            key, lazy_value = unpacked_args[0]
+            objects = lazy_value.infer()
+            return payload[0] in objects
+        except AssertionError:
+            return False
+
+    obj = jedi_name
+    while obj is not None and not isinstance(obj, (tree.Function, tree.Class)):
+        if isinstance(obj, tree.Flow):
+            # try/except catch check
+            if obj.type == 'try_stmt' and check_try_for_except(obj, exception):
+                return True
+            # hasattr check
+            if exception == AttributeError and obj.type in ('if_stmt', 'while_stmt'):
+                if check_hasattr(obj.children[1], obj.children[3]):
+                    return True
+        obj = obj.parent
+
+    return False

venv/Lib/site-packages/jedi/inference/arguments.py

@@ -0,0 +1,343 @@
+import re
+
+from parso.python import tree
+
+from jedi._compatibility import zip_longest
+from jedi import debug
+from jedi.inference.utils import PushBackIterator
+from jedi.inference import analysis
+from jedi.inference.lazy_value import LazyKnownValue, LazyKnownValues, \
+    LazyTreeValue, get_merged_lazy_value
+from jedi.inference.names import ParamName, TreeNameDefinition, AnonymousParamName
+from jedi.inference.base_value import NO_VALUES, ValueSet, ContextualizedNode
+from jedi.inference.value import iterable
+from jedi.inference.cache import inference_state_as_method_param_cache
+
+
+def try_iter_content(types, depth=0):
+    """Helper method for static analysis."""
+    if depth > 10:
+        # It's possible that a loop has references on itself (especially with
+        # CompiledValue). Therefore don't loop infinitely.
+        return
+
+    for typ in types:
+        try:
+            f = typ.py__iter__
+        except AttributeError:
+            pass
+        else:
+            for lazy_value in f():
+                try_iter_content(lazy_value.infer(), depth + 1)
+
+
+class ParamIssue(Exception):
+    pass
+
+
+def repack_with_argument_clinic(clinic_string):
+    """
+    Transforms a function or method with arguments to the signature that is
+    given as an argument clinic notation.
+
+    Argument clinic is part of CPython and used for all the functions that are
+    implemented in C (Python 3.7):
+
+        str.split.__text_signature__
+        # Results in: '($self, /, sep=None, maxsplit=-1)'
+    """
+    def decorator(func):
+        def wrapper(value, arguments):
+            try:
+                args = tuple(iterate_argument_clinic(
+                    value.inference_state,
+                    arguments,
+                    clinic_string,
+                ))
+            except ParamIssue:
+                return NO_VALUES
+            else:
+                return func(value, *args)
+
+        return wrapper
+    return decorator
+
+
+def iterate_argument_clinic(inference_state, arguments, clinic_string):
+    """Uses a list with argument clinic information (see PEP 436)."""
+    clinic_args = list(_parse_argument_clinic(clinic_string))
+
+    iterator = PushBackIterator(arguments.unpack())
+    for i, (name, optional, allow_kwargs, stars) in enumerate(clinic_args):
+        if stars == 1:
+            lazy_values = []
+            for key, argument in iterator:
+                if key is not None:
+                    iterator.push_back((key, argument))
+                    break
+
+                lazy_values.append(argument)
+            yield ValueSet([iterable.FakeTuple(inference_state, lazy_values)])
+            lazy_values
+            continue
+        elif stars == 2:
+            raise NotImplementedError()
+        key, argument = next(iterator, (None, None))
+        if key is not None:
+            debug.warning('Keyword arguments in argument clinic are currently not supported.')
+            raise ParamIssue
+        if argument is None and not optional:
+            debug.warning('TypeError: %s expected at least %s arguments, got %s',
+                          name, len(clinic_args), i)
+            raise ParamIssue
+
+        value_set = NO_VALUES if argument is None else argument.infer()
+
+        if not value_set and not optional:
+            # For the stdlib we always want values. If we don't get them,
+            # that's ok, maybe something is too hard to resolve, however,
+            # we will not proceed with the type inference of that function.
+            debug.warning('argument_clinic "%s" not resolvable.', name)
+            raise ParamIssue
+        yield value_set
+
+
+def _parse_argument_clinic(string):
+    allow_kwargs = False
+    optional = False
+    while string:
+        # Optional arguments have to begin with a bracket. And should always be
+        # at the end of the arguments. This is therefore not a proper argument
+        # clinic implementation. `range()` for exmple allows an optional start
+        # value at the beginning.
+        match = re.match(r'(?:(?:(\[),? ?|, ?|)(\**\w+)|, ?/)\]*', string)
+        string = string[len(match.group(0)):]
+        if not match.group(2):  # A slash -> allow named arguments
+            allow_kwargs = True
+            continue
+        optional = optional or bool(match.group(1))
+        word = match.group(2)
+        stars = word.count('*')
+        word = word[stars:]
+        yield (word, optional, allow_kwargs, stars)
+        if stars:
+            allow_kwargs = True
+
+
+class _AbstractArgumentsMixin(object):
+    def unpack(self, funcdef=None):
+        raise NotImplementedError
+
+    def get_calling_nodes(self):
+        return []
+
+
+class AbstractArguments(_AbstractArgumentsMixin):
+    context = None
+    argument_node = None
+    trailer = None
+
+
+def unpack_arglist(arglist):
+    if arglist is None:
+        return
+
+    # Allow testlist here as well for Python2's class inheritance
+    # definitions.
+    if not (arglist.type in ('arglist', 'testlist') or (
+            # in python 3.5 **arg is an argument, not arglist
+            arglist.type == 'argument' and arglist.children[0] in ('*', '**'))):
+        yield 0, arglist
+        return
+
+    iterator = iter(arglist.children)
+    for child in iterator:
+        if child == ',':
+            continue
+        elif child in ('*', '**'):
+            c = next(iterator, None)
+            assert c is not None
+            yield len(child.value), c
+        elif child.type == 'argument' and \
+                child.children[0] in ('*', '**'):
+            assert len(child.children) == 2
+            yield len(child.children[0].value), child.children[1]
+        else:
+            yield 0, child
+
+
+class TreeArguments(AbstractArguments):
+    def __init__(self, inference_state, context, argument_node, trailer=None):
+        """
+        :param argument_node: May be an argument_node or a list of nodes.
+        """
+        self.argument_node = argument_node
+        self.context = context
+        self._inference_state = inference_state
+        self.trailer = trailer  # Can be None, e.g. in a class definition.
+
+    @classmethod
+    @inference_state_as_method_param_cache()
+    def create_cached(cls, *args, **kwargs):
+        return cls(*args, **kwargs)
+
+    def unpack(self, funcdef=None):
+        named_args = []
+        for star_count, el in unpack_arglist(self.argument_node):
+            if star_count == 1:
+                arrays = self.context.infer_node(el)
+                iterators = [_iterate_star_args(self.context, a, el, funcdef)
+                             for a in arrays]
+                for values in list(zip_longest(*iterators)):
+                    # TODO zip_longest yields None, that means this would raise
+                    # an exception?
+                    yield None, get_merged_lazy_value(
+                        [v for v in values if v is not None]
+                    )
+            elif star_count == 2:
+                arrays = self.context.infer_node(el)
+                for dct in arrays:
+                    for key, values in _star_star_dict(self.context, dct, el, funcdef):
+                        yield key, values
+            else:
+                if el.type == 'argument':
+                    c = el.children
+                    if len(c) == 3:  # Keyword argument.
+                        named_args.append((c[0].value, LazyTreeValue(self.context, c[2]),))
+                    else:  # Generator comprehension.
+                        # Include the brackets with the parent.
+                        sync_comp_for = el.children[1]
+                        if sync_comp_for.type == 'comp_for':
+                            sync_comp_for = sync_comp_for.children[1]
+                        comp = iterable.GeneratorComprehension(
+                            self._inference_state,
+                            defining_context=self.context,
+                            sync_comp_for_node=sync_comp_for,
+                            entry_node=el.children[0],
+                        )
+                        yield None, LazyKnownValue(comp)
+                else:
+                    yield None, LazyTreeValue(self.context, el)
+
+        # Reordering arguments is necessary, because star args sometimes appear
+        # after named argument, but in the actual order it's prepended.
+        for named_arg in named_args:
+            yield named_arg
+
+    def _as_tree_tuple_objects(self):
+        for star_count, argument in unpack_arglist(self.argument_node):
+            default = None
+            if argument.type == 'argument':
+                if len(argument.children) == 3:  # Keyword argument.
+                    argument, default = argument.children[::2]
+            yield argument, default, star_count
+
+    def iter_calling_names_with_star(self):
+        for name, default, star_count in self._as_tree_tuple_objects():
+            # TODO this function is a bit strange. probably refactor?
+            if not star_count or not isinstance(name, tree.Name):
+                continue
+
+            yield TreeNameDefinition(self.context, name)
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self.argument_node)
+
+    def get_calling_nodes(self):
+        old_arguments_list = []
+        arguments = self
+
+        while arguments not in old_arguments_list:
+            if not isinstance(arguments, TreeArguments):
+                break
+
+            old_arguments_list.append(arguments)
+            for calling_name in reversed(list(arguments.iter_calling_names_with_star())):
+                names = calling_name.goto()
+                if len(names) != 1:
+                    break
+                if isinstance(names[0], AnonymousParamName):
+                    # Dynamic parameters should not have calling nodes, because
+                    # they are dynamic and extremely random.
+                    return []
+                if not isinstance(names[0], ParamName):
+                    break
+                executed_param_name = names[0].get_executed_param_name()
+                arguments = executed_param_name.arguments
+                break
+
+        if arguments.argument_node is not None:
+            return [ContextualizedNode(arguments.context, arguments.argument_node)]
+        if arguments.trailer is not None:
+            return [ContextualizedNode(arguments.context, arguments.trailer)]
+        return []
+
+
+class ValuesArguments(AbstractArguments):
+    def __init__(self, values_list):
+        self._values_list = values_list
+
+    def unpack(self, funcdef=None):
+        for values in self._values_list:
+            yield None, LazyKnownValues(values)
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self._values_list)
+
+
+class TreeArgumentsWrapper(_AbstractArgumentsMixin):
+    def __init__(self, arguments):
+        self._wrapped_arguments = arguments
+
+    @property
+    def context(self):
+        return self._wrapped_arguments.context
+
+    @property
+    def argument_node(self):
+        return self._wrapped_arguments.argument_node
+
+    @property
+    def trailer(self):
+        return self._wrapped_arguments.trailer
+
+    def unpack(self, func=None):
+        raise NotImplementedError
+
+    def get_calling_nodes(self):
+        return self._wrapped_arguments.get_calling_nodes()
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self._wrapped_arguments)
+
+
+def _iterate_star_args(context, array, input_node, funcdef=None):
+    if not array.py__getattribute__('__iter__'):
+        if funcdef is not None:
+            # TODO this funcdef should not be needed.
+            m = "TypeError: %s() argument after * must be a sequence, not %s" \
+                % (funcdef.name.value, array)
+            analysis.add(context, 'type-error-star', input_node, message=m)
+    try:
+        iter_ = array.py__iter__
+    except AttributeError:
+        pass
+    else:
+        for lazy_value in iter_():
+            yield lazy_value
+
+
+def _star_star_dict(context, array, input_node, funcdef):
+    from jedi.inference.value.instance import CompiledInstance
+    if isinstance(array, CompiledInstance) and array.name.string_name == 'dict':
+        # For now ignore this case. In the future add proper iterators and just
+        # make one call without crazy isinstance checks.
+        return {}
+    elif isinstance(array, iterable.Sequence) and array.array_type == 'dict':
+        return array.exact_key_items()
+    else:
+        if funcdef is not None:
+            m = "TypeError: %s argument after ** must be a mapping, not %s" \
+                % (funcdef.name.value, array)
+            analysis.add(context, 'type-error-star-star', input_node, message=m)
+        return {}

venv/Lib/site-packages/jedi/inference/base_value.py

@@ -0,0 +1,556 @@
+"""
+Values are the "values" that Python would return. However Values are at the
+same time also the "values" that a user is currently sitting in.
+
+A ValueSet is typically used to specify the return of a function or any other
+static analysis operation. In jedi there are always multiple returns and not
+just one.
+"""
+from functools import reduce
+from operator import add
+from parso.python.tree import Name
+
+from jedi import debug
+from jedi._compatibility import zip_longest, unicode
+from jedi.parser_utils import clean_scope_docstring
+from jedi.inference.helpers import SimpleGetItemNotFound
+from jedi.inference.utils import safe_property
+from jedi.inference.cache import inference_state_as_method_param_cache
+from jedi.cache import memoize_method
+
+sentinel = object()
+
+
+class HelperValueMixin(object):
+    def get_root_context(self):
+        value = self
+        if value.parent_context is None:
+            return value.as_context()
+
+        while True:
+            if value.parent_context is None:
+                return value
+            value = value.parent_context
+
+    def execute(self, arguments):
+        return self.inference_state.execute(self, arguments=arguments)
+
+    def execute_with_values(self, *value_list):
+        from jedi.inference.arguments import ValuesArguments
+        arguments = ValuesArguments([ValueSet([value]) for value in value_list])
+        return self.inference_state.execute(self, arguments)
+
+    def execute_annotation(self):
+        return self.execute_with_values()
+
+    def gather_annotation_classes(self):
+        return ValueSet([self])
+
+    def merge_types_of_iterate(self, contextualized_node=None, is_async=False):
+        return ValueSet.from_sets(
+            lazy_value.infer()
+            for lazy_value in self.iterate(contextualized_node, is_async)
+        )
+
+    def _get_value_filters(self, name_or_str):
+        origin_scope = name_or_str if isinstance(name_or_str, Name) else None
+        for f in self.get_filters(origin_scope=origin_scope):
+            yield f
+        # This covers the case where a stub files are incomplete.
+        if self.is_stub():
+            from jedi.inference.gradual.conversion import convert_values
+            for c in convert_values(ValueSet({self})):
+                for f in c.get_filters():
+                    yield f
+
+    def goto(self, name_or_str, name_context=None, analysis_errors=True):
+        from jedi.inference import finder
+        filters = self._get_value_filters(name_or_str)
+        names = finder.filter_name(filters, name_or_str)
+        debug.dbg('context.goto %s in (%s): %s', name_or_str, self, names)
+        return names
+
+    def py__getattribute__(self, name_or_str, name_context=None, position=None,
+                           analysis_errors=True):
+        """
+        :param position: Position of the last statement -> tuple of line, column
+        """
+        if name_context is None:
+            name_context = self
+        names = self.goto(name_or_str, name_context, analysis_errors)
+        values = ValueSet.from_sets(name.infer() for name in names)
+        if not values:
+            n = name_or_str.value if isinstance(name_or_str, Name) else name_or_str
+            values = self.py__getattribute__alternatives(n)
+
+        if not names and not values and analysis_errors:
+            if isinstance(name_or_str, Name):
+                from jedi.inference import analysis
+                analysis.add_attribute_error(
+                    name_context, self, name_or_str)
+        debug.dbg('context.names_to_types: %s -> %s', names, values)
+        return values
+
+    def py__await__(self):
+        await_value_set = self.py__getattribute__(u"__await__")
+        if not await_value_set:
+            debug.warning('Tried to run __await__ on value %s', self)
+        return await_value_set.execute_with_values()
+
+    def py__name__(self):
+        return self.name.string_name
+
+    def iterate(self, contextualized_node=None, is_async=False):
+        debug.dbg('iterate %s', self)
+        if is_async:
+            from jedi.inference.lazy_value import LazyKnownValues
+            # TODO if no __aiter__ values are there, error should be:
+            # TypeError: 'async for' requires an object with __aiter__ method, got int
+            return iter([
+                LazyKnownValues(
+                    self.py__getattribute__('__aiter__').execute_with_values()
+                        .py__getattribute__('__anext__').execute_with_values()
+                        .py__getattribute__('__await__').execute_with_values()
+                        .py__stop_iteration_returns()
+                )  # noqa
+            ])
+        return self.py__iter__(contextualized_node)
+
+    def is_sub_class_of(self, class_value):
+        with debug.increase_indent_cm('subclass matching of %s <=> %s' % (self, class_value),
+                                      color='BLUE'):
+            for cls in self.py__mro__():
+                if cls.is_same_class(class_value):
+                    debug.dbg('matched subclass True', color='BLUE')
+                    return True
+            debug.dbg('matched subclass False', color='BLUE')
+            return False
+
+    def is_same_class(self, class2):
+        # Class matching should prefer comparisons that are not this function.
+        if type(class2).is_same_class != HelperValueMixin.is_same_class:
+            return class2.is_same_class(self)
+        return self == class2
+
+    @memoize_method
+    def as_context(self, *args, **kwargs):
+        return self._as_context(*args, **kwargs)
+
+
+class Value(HelperValueMixin):
+    """
+    To be implemented by subclasses.
+    """
+    tree_node = None
+    # Possible values: None, tuple, list, dict and set. Here to deal with these
+    # very important containers.
+    array_type = None
+    api_type = 'not_defined_please_report_bug'
+
+    def __init__(self, inference_state, parent_context=None):
+        self.inference_state = inference_state
+        self.parent_context = parent_context
+
+    def py__getitem__(self, index_value_set, contextualized_node):
+        from jedi.inference import analysis
+        # TODO this value is probably not right.
+        analysis.add(
+            contextualized_node.context,
+            'type-error-not-subscriptable',
+            contextualized_node.node,
+            message="TypeError: '%s' object is not subscriptable" % self
+        )
+        return NO_VALUES
+
+    def py__simple_getitem__(self, index):
+        raise SimpleGetItemNotFound
+
+    def py__iter__(self, contextualized_node=None):
+        if contextualized_node is not None:
+            from jedi.inference import analysis
+            analysis.add(
+                contextualized_node.context,
+                'type-error-not-iterable',
+                contextualized_node.node,
+                message="TypeError: '%s' object is not iterable" % self)
+        return iter([])
+
+    def py__next__(self, contextualized_node=None):
+        return self.py__iter__(contextualized_node)
+
+    def get_signatures(self):
+        return []
+
+    def is_class(self):
+        return False
+
+    def is_class_mixin(self):
+        return False
+
+    def is_instance(self):
+        return False
+
+    def is_function(self):
+        return False
+
+    def is_module(self):
+        return False
+
+    def is_namespace(self):
+        return False
+
+    def is_compiled(self):
+        return False
+
+    def is_bound_method(self):
+        return False
+
+    def is_builtins_module(self):
+        return False
+
+    def py__bool__(self):
+        """
+        Since Wrapper is a super class for classes, functions and modules,
+        the return value will always be true.
+        """
+        return True
+
+    def py__doc__(self):
+        try:
+            self.tree_node.get_doc_node
+        except AttributeError:
+            return ''
+        else:
+            return clean_scope_docstring(self.tree_node)
+
+    def get_safe_value(self, default=sentinel):
+        if default is sentinel:
+            raise ValueError("There exists no safe value for value %s" % self)
+        return default
+
+    def execute_operation(self, other, operator):
+        debug.warning("%s not possible between %s and %s", operator, self, other)
+        return NO_VALUES
+
+    def py__call__(self, arguments):
+        debug.warning("no execution possible %s", self)
+        return NO_VALUES
+
+    def py__stop_iteration_returns(self):
+        debug.warning("Not possible to return the stop iterations of %s", self)
+        return NO_VALUES
+
+    def py__getattribute__alternatives(self, name_or_str):
+        """
+        For now a way to add values in cases like __getattr__.
+        """
+        return NO_VALUES
+
+    def py__get__(self, instance, class_value):
+        debug.warning("No __get__ defined on %s", self)
+        return ValueSet([self])
+
+    def py__get__on_class(self, calling_instance, instance, class_value):
+        return NotImplemented
+
+    def get_qualified_names(self):
+        # Returns Optional[Tuple[str, ...]]
+        return None
+
+    def is_stub(self):
+        # The root value knows if it's a stub or not.
+        return self.parent_context.is_stub()
+
+    def _as_context(self):
+        raise NotImplementedError('Not all values need to be converted to contexts: %s', self)
+
+    @property
+    def name(self):
+        raise NotImplementedError
+
+    def get_type_hint(self, add_class_info=True):
+        return None
+
+    def infer_type_vars(self, value_set):
+        """
+        When the current instance represents a type annotation, this method
+        tries to find information about undefined type vars and returns a dict
+        from type var name to value set.
+
+        This is for example important to understand what `iter([1])` returns.
+        According to typeshed, `iter` returns an `Iterator[_T]`:
+
+            def iter(iterable: Iterable[_T]) -> Iterator[_T]: ...
+
+        This functions would generate `int` for `_T` in this case, because it
+        unpacks the `Iterable`.
+
+        Parameters
+        ----------
+
+        `self`: represents the annotation of the current parameter to infer the
+            value for. In the above example, this would initially be the
+            `Iterable[_T]` of the `iterable` parameter and then, when recursing,
+            just the `_T` generic parameter.
+
+        `value_set`: represents the actual argument passed to the parameter
+            we're inferrined for, or (for recursive calls) their types. In the
+            above example this would first be the representation of the list
+            `[1]` and then, when recursing, just of `1`.
+        """
+        return {}
+
+
+def iterate_values(values, contextualized_node=None, is_async=False):
+    """
+    Calls `iterate`, on all values but ignores the ordering and just returns
+    all values that the iterate functions yield.
+    """
+    return ValueSet.from_sets(
+        lazy_value.infer()
+        for lazy_value in values.iterate(contextualized_node, is_async=is_async)
+    )
+
+
+class _ValueWrapperBase(HelperValueMixin):
+    @safe_property
+    def name(self):
+        from jedi.inference.names import ValueName
+        wrapped_name = self._wrapped_value.name
+        if wrapped_name.tree_name is not None:
+            return ValueName(self, wrapped_name.tree_name)
+        else:
+            from jedi.inference.compiled import CompiledValueName
+            return CompiledValueName(self, wrapped_name.string_name)
+
+    @classmethod
+    @inference_state_as_method_param_cache()
+    def create_cached(cls, inference_state, *args, **kwargs):
+        return cls(*args, **kwargs)
+
+    def __getattr__(self, name):
+        assert name != '_wrapped_value', 'Problem with _get_wrapped_value'
+        return getattr(self._wrapped_value, name)
+
+
+class LazyValueWrapper(_ValueWrapperBase):
+    @safe_property
+    @memoize_method
+    def _wrapped_value(self):
+        with debug.increase_indent_cm('Resolve lazy value wrapper'):
+            return self._get_wrapped_value()
+
+    def __repr__(self):
+        return '<%s>' % (self.__class__.__name__)
+
+    def _get_wrapped_value(self):
+        raise NotImplementedError
+
+
+class ValueWrapper(_ValueWrapperBase):
+    def __init__(self, wrapped_value):
+        self._wrapped_value = wrapped_value
+
+    def __repr__(self):
+        return '%s(%s)' % (self.__class__.__name__, self._wrapped_value)
+
+
+class TreeValue(Value):
+    def __init__(self, inference_state, parent_context, tree_node):
+        super(TreeValue, self).__init__(inference_state, parent_context)
+        self.tree_node = tree_node
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self.tree_node)
+
+
+class ContextualizedNode(object):
+    def __init__(self, context, node):
+        self.context = context
+        self.node = node
+
+    def get_root_context(self):
+        return self.context.get_root_context()
+
+    def infer(self):
+        return self.context.infer_node(self.node)
+
+    def __repr__(self):
+        return '<%s: %s in %s>' % (self.__class__.__name__, self.node, self.context)
+
+
+def _getitem(value, index_values, contextualized_node):
+    # The actual getitem call.
+    result = NO_VALUES
+    unused_values = set()
+    for index_value in index_values:
+        index = index_value.get_safe_value(default=None)
+        if type(index) in (float, int, str, unicode, slice, bytes):
+            try:
+                result |= value.py__simple_getitem__(index)
+                continue
+            except SimpleGetItemNotFound:
+                pass
+
+        unused_values.add(index_value)
+
+    # The index was somehow not good enough or simply a wrong type.
+    # Therefore we now iterate through all the values and just take
+    # all results.
+    if unused_values or not index_values:
+        result |= value.py__getitem__(
+            ValueSet(unused_values),
+            contextualized_node
+        )
+    debug.dbg('py__getitem__ result: %s', result)
+    return result
+
+
+class ValueSet(object):
+    def __init__(self, iterable):
+        self._set = frozenset(iterable)
+        for value in iterable:
+            assert not isinstance(value, ValueSet)
+
+    @classmethod
+    def _from_frozen_set(cls, frozenset_):
+        self = cls.__new__(cls)
+        self._set = frozenset_
+        return self
+
+    @classmethod
+    def from_sets(cls, sets):
+        """
+        Used to work with an iterable of set.
+        """
+        aggregated = set()
+        for set_ in sets:
+            if isinstance(set_, ValueSet):
+                aggregated |= set_._set
+            else:
+                aggregated |= frozenset(set_)
+        return cls._from_frozen_set(frozenset(aggregated))
+
+    def __or__(self, other):
+        return self._from_frozen_set(self._set | other._set)
+
+    def __and__(self, other):
+        return self._from_frozen_set(self._set & other._set)
+
+    def __iter__(self):
+        for element in self._set:
+            yield element
+
+    def __bool__(self):
+        return bool(self._set)
+
+    def __len__(self):
+        return len(self._set)
+
+    def __repr__(self):
+        return 'S{%s}' % (', '.join(str(s) for s in self._set))
+
+    def filter(self, filter_func):
+        return self.__class__(filter(filter_func, self._set))
+
+    def __getattr__(self, name):
+        def mapper(*args, **kwargs):
+            return self.from_sets(
+                getattr(value, name)(*args, **kwargs)
+                for value in self._set
+            )
+        return mapper
+
+    def __eq__(self, other):
+        return self._set == other._set
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __hash__(self):
+        return hash(self._set)
+
+    def py__class__(self):
+        return ValueSet(c.py__class__() for c in self._set)
+
+    def iterate(self, contextualized_node=None, is_async=False):
+        from jedi.inference.lazy_value import get_merged_lazy_value
+        type_iters = [c.iterate(contextualized_node, is_async=is_async) for c in self._set]
+        for lazy_values in zip_longest(*type_iters):
+            yield get_merged_lazy_value(
+                [l for l in lazy_values if l is not None]
+            )
+
+    def execute(self, arguments):
+        return ValueSet.from_sets(c.inference_state.execute(c, arguments) for c in self._set)
+
+    def execute_with_values(self, *args, **kwargs):
+        return ValueSet.from_sets(c.execute_with_values(*args, **kwargs) for c in self._set)
+
+    def goto(self, *args, **kwargs):
+        return reduce(add, [c.goto(*args, **kwargs) for c in self._set], [])
+
+    def py__getattribute__(self, *args, **kwargs):
+        return ValueSet.from_sets(c.py__getattribute__(*args, **kwargs) for c in self._set)
+
+    def get_item(self, *args, **kwargs):
+        return ValueSet.from_sets(_getitem(c, *args, **kwargs) for c in self._set)
+
+    def try_merge(self, function_name):
+        value_set = self.__class__([])
+        for c in self._set:
+            try:
+                method = getattr(c, function_name)
+            except AttributeError:
+                pass
+            else:
+                value_set |= method()
+        return value_set
+
+    def gather_annotation_classes(self):
+        return ValueSet.from_sets([c.gather_annotation_classes() for c in self._set])
+
+    def get_signatures(self):
+        return [sig for c in self._set for sig in c.get_signatures()]
+
+    def get_type_hint(self, add_class_info=True):
+        t = [v.get_type_hint(add_class_info=add_class_info) for v in self._set]
+        type_hints = sorted(filter(None, t))
+        if len(type_hints) == 1:
+            return type_hints[0]
+
+        optional = 'None' in type_hints
+        if optional:
+            type_hints.remove('None')
+
+        if len(type_hints) == 0:
+            return None
+        elif len(type_hints) == 1:
+            s = type_hints[0]
+        else:
+            s = 'Union[%s]' % ', '.join(type_hints)
+        if optional:
+            s = 'Optional[%s]' % s
+        return s
+
+    def infer_type_vars(self, value_set):
+        # Circular
+        from jedi.inference.gradual.annotation import merge_type_var_dicts
+
+        type_var_dict = {}
+        for value in self._set:
+            merge_type_var_dicts(
+                type_var_dict,
+                value.infer_type_vars(value_set),
+            )
+        return type_var_dict
+
+
+NO_VALUES = ValueSet([])
+
+
+def iterator_to_value_set(func):
+    def wrapper(*args, **kwargs):
+        return ValueSet(func(*args, **kwargs))
+
+    return wrapper

venv/Lib/site-packages/jedi/inference/cache.py

@@ -0,0 +1,126 @@
+"""
+- the popular ``_memoize_default`` works like a typical memoize and returns the
+  default otherwise.
+- ``CachedMetaClass`` uses ``_memoize_default`` to do the same with classes.
+"""
+from functools import wraps
+
+from jedi import debug
+
+_NO_DEFAULT = object()
+_RECURSION_SENTINEL = object()
+
+
+def _memoize_default(default=_NO_DEFAULT, inference_state_is_first_arg=False,
+                     second_arg_is_inference_state=False):
+    """ This is a typical memoization decorator, BUT there is one difference:
+    To prevent recursion it sets defaults.
+
+    Preventing recursion is in this case the much bigger use than speed. I
+    don't think, that there is a big speed difference, but there are many cases
+    where recursion could happen (think about a = b; b = a).
+    """
+    def func(function):
+        def wrapper(obj, *args, **kwargs):
+            # TODO These checks are kind of ugly and slow.
+            if inference_state_is_first_arg:
+                cache = obj.memoize_cache
+            elif second_arg_is_inference_state:
+                cache = args[0].memoize_cache  # needed for meta classes
+            else:
+                cache = obj.inference_state.memoize_cache
+
+            try:
+                memo = cache[function]
+            except KeyError:
+                cache[function] = memo = {}
+
+            key = (obj, args, frozenset(kwargs.items()))
+            if key in memo:
+                return memo[key]
+            else:
+                if default is not _NO_DEFAULT:
+                    memo[key] = default
+                rv = function(obj, *args, **kwargs)
+                memo[key] = rv
+                return rv
+        return wrapper
+
+    return func
+
+
+def inference_state_function_cache(default=_NO_DEFAULT):
+    def decorator(func):
+        return _memoize_default(default=default, inference_state_is_first_arg=True)(func)
+
+    return decorator
+
+
+def inference_state_method_cache(default=_NO_DEFAULT):
+    def decorator(func):
+        return _memoize_default(default=default)(func)
+
+    return decorator
+
+
+def inference_state_as_method_param_cache():
+    def decorator(call):
+        return _memoize_default(second_arg_is_inference_state=True)(call)
+
+    return decorator
+
+
+class CachedMetaClass(type):
+    """
+    This is basically almost the same than the decorator above, it just caches
+    class initializations. Either you do it this way or with decorators, but
+    with decorators you lose class access (isinstance, etc).
+    """
+    @inference_state_as_method_param_cache()
+    def __call__(self, *args, **kwargs):
+        return super(CachedMetaClass, self).__call__(*args, **kwargs)
+
+
+def inference_state_method_generator_cache():
+    """
+    This is a special memoizer. It memoizes generators and also checks for
+    recursion errors and returns no further iterator elemends in that case.
+    """
+    def func(function):
+        @wraps(function)
+        def wrapper(obj, *args, **kwargs):
+            cache = obj.inference_state.memoize_cache
+            try:
+                memo = cache[function]
+            except KeyError:
+                cache[function] = memo = {}
+
+            key = (obj, args, frozenset(kwargs.items()))
+
+            if key in memo:
+                actual_generator, cached_lst = memo[key]
+            else:
+                actual_generator = function(obj, *args, **kwargs)
+                cached_lst = []
+                memo[key] = actual_generator, cached_lst
+
+            i = 0
+            while True:
+                try:
+                    next_element = cached_lst[i]
+                    if next_element is _RECURSION_SENTINEL:
+                        debug.warning('Found a generator recursion for %s' % obj)
+                        # This means we have hit a recursion.
+                        return
+                except IndexError:
+                    cached_lst.append(_RECURSION_SENTINEL)
+                    next_element = next(actual_generator, None)
+                    if next_element is None:
+                        cached_lst.pop()
+                        return
+                    cached_lst[-1] = next_element
+                yield next_element
+                i += 1
+        return wrapper
+
+    return func

venv/Lib/site-packages/jedi/inference/compiled/__init__.py

@@ -0,0 +1,68 @@
+from jedi._compatibility import unicode
+from jedi.inference.compiled.value import CompiledValue, CompiledName, \
+    CompiledValueFilter, CompiledValueName, create_from_access_path
+from jedi.inference.base_value import LazyValueWrapper
+
+
+def builtin_from_name(inference_state, string):
+    typing_builtins_module = inference_state.builtins_module
+    if string in ('None', 'True', 'False'):
+        builtins, = typing_builtins_module.non_stub_value_set
+        filter_ = next(builtins.get_filters())
+    else:
+        filter_ = next(typing_builtins_module.get_filters())
+    name, = filter_.get(string)
+    value, = name.infer()
+    return value
+
+
+class ExactValue(LazyValueWrapper):
+    """
+    This class represents exact values, that makes operations like additions
+    and exact boolean values possible, while still being a "normal" stub.
+    """
+    def __init__(self, compiled_value):
+        self.inference_state = compiled_value.inference_state
+        self._compiled_value = compiled_value
+
+    def __getattribute__(self, name):
+        if name in ('get_safe_value', 'execute_operation', 'access_handle',
+                    'negate', 'py__bool__', 'is_compiled'):
+            return getattr(self._compiled_value, name)
+        return super(ExactValue, self).__getattribute__(name)
+
+    def _get_wrapped_value(self):
+        instance, = builtin_from_name(
+            self.inference_state, self._compiled_value.name.string_name).execute_with_values()
+        return instance
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self._compiled_value)
+
+
+def create_simple_object(inference_state, obj):
+    """
+    Only allows creations of objects that are easily picklable across Python
+    versions.
+    """
+    assert type(obj) in (int, float, str, bytes, unicode, slice, complex, bool), obj
+    compiled_value = create_from_access_path(
+        inference_state,
+        inference_state.compiled_subprocess.create_simple_object(obj)
+    )
+    return ExactValue(compiled_value)
+
+
+def get_string_value_set(inference_state):
+    return builtin_from_name(inference_state, u'str').execute_with_values()
+
+
+def load_module(inference_state, dotted_name, **kwargs):
+    # Temporary, some tensorflow builtins cannot be loaded, so it's tried again
+    # and again and it's really slow.
+    if dotted_name.startswith('tensorflow.'):
+        return None
+    access_path = inference_state.compiled_subprocess.load_module(dotted_name=dotted_name, **kwargs)
+    if access_path is None:
+        return None
+    return create_from_access_path(inference_state, access_path)

venv/Lib/site-packages/jedi/inference/compiled/access.py

@@ -0,0 +1,564 @@
+from __future__ import print_function
+import inspect
+import types
+import sys
+import operator as op
+from collections import namedtuple
+import warnings
+import re
+
+from jedi._compatibility import unicode, is_py3, builtins, \
+    py_version, force_unicode
+from jedi.inference.compiled.getattr_static import getattr_static
+
+ALLOWED_GETITEM_TYPES = (str, list, tuple, unicode, bytes, bytearray, dict)
+
+MethodDescriptorType = type(str.replace)
+# These are not considered classes and access is granted even though they have
+# a __class__ attribute.
+NOT_CLASS_TYPES = (
+    types.BuiltinFunctionType,
+    types.CodeType,
+    types.FrameType,
+    types.FunctionType,
+    types.GeneratorType,
+    types.GetSetDescriptorType,
+    types.LambdaType,
+    types.MemberDescriptorType,
+    types.MethodType,
+    types.ModuleType,
+    types.TracebackType,
+    MethodDescriptorType
+)
+
+if is_py3:
+    NOT_CLASS_TYPES += (
+        types.MappingProxyType,
+        types.SimpleNamespace,
+        types.DynamicClassAttribute,
+    )
+
+
+# Those types don't exist in typing.
+MethodDescriptorType = type(str.replace)
+WrapperDescriptorType = type(set.__iter__)
+# `object.__subclasshook__` is an already executed descriptor.
+object_class_dict = type.__dict__["__dict__"].__get__(object)
+ClassMethodDescriptorType = type(object_class_dict['__subclasshook__'])
+
+_sentinel = object()
+
+# Maps Python syntax to the operator module.
+COMPARISON_OPERATORS = {
+    '==': op.eq,
+    '!=': op.ne,
+    'is': op.is_,
+    'is not': op.is_not,
+    '<': op.lt,
+    '<=': op.le,
+    '>': op.gt,
+    '>=': op.ge,
+}
+
+_OPERATORS = {
+    '+': op.add,
+    '-': op.sub,
+}
+_OPERATORS.update(COMPARISON_OPERATORS)
+
+ALLOWED_DESCRIPTOR_ACCESS = (
+    types.FunctionType,
+    types.GetSetDescriptorType,
+    types.MemberDescriptorType,
+    MethodDescriptorType,
+    WrapperDescriptorType,
+    ClassMethodDescriptorType,
+    staticmethod,
+    classmethod,
+)
+
+
+def safe_getattr(obj, name, default=_sentinel):
+    try:
+        attr, is_get_descriptor = getattr_static(obj, name)
+    except AttributeError:
+        if default is _sentinel:
+            raise
+        return default
+    else:
+        if isinstance(attr, ALLOWED_DESCRIPTOR_ACCESS):
+            # In case of descriptors that have get methods we cannot return
+            # it's value, because that would mean code execution.
+            # Since it's an isinstance call, code execution is still possible,
+            # but this is not really a security feature, but much more of a
+            # safety feature. Code execution is basically always possible when
+            # a module is imported. This is here so people don't shoot
+            # themselves in the foot.
+            return getattr(obj, name)
+    return attr
+
+
+SignatureParam = namedtuple(
+    'SignatureParam',
+    'name has_default default default_string has_annotation annotation annotation_string kind_name'
+)
+
+
+def shorten_repr(func):
+    def wrapper(self):
+        r = func(self)
+        if len(r) > 50:
+            r = r[:50] + '..'
+        return r
+    return wrapper
+
+
+def create_access(inference_state, obj):
+    return inference_state.compiled_subprocess.get_or_create_access_handle(obj)
+
+
+def load_module(inference_state, dotted_name, sys_path):
+    temp, sys.path = sys.path, sys_path
+    try:
+        __import__(dotted_name)
+    except ImportError:
+        # If a module is "corrupt" or not really a Python module or whatever.
+        print('Module %s not importable in path %s.' % (dotted_name, sys_path), file=sys.stderr)
+        return None
+    except Exception:
+        # Since __import__ pretty much makes code execution possible, just
+        # catch any error here and print it.
+        import traceback
+        print("Cannot import:\n%s" % traceback.format_exc(), file=sys.stderr)
+        return None
+    finally:
+        sys.path = temp
+
+    # Just access the cache after import, because of #59 as well as the very
+    # complicated import structure of Python.
+    module = sys.modules[dotted_name]
+    return create_access_path(inference_state, module)
+
+
+class AccessPath(object):
+    def __init__(self, accesses):
+        self.accesses = accesses
+
+    # Writing both of these methods here looks a bit ridiculous. However with
+    # the differences of Python 2/3 it's actually necessary, because we will
+    # otherwise have a accesses attribute that is bytes instead of unicode.
+    def __getstate__(self):
+        return self.accesses
+
+    def __setstate__(self, value):
+        self.accesses = value
+
+
+def create_access_path(inference_state, obj):
+    access = create_access(inference_state, obj)
+    return AccessPath(access.get_access_path_tuples())
+
+
+def _force_unicode_decorator(func):
+    return lambda *args, **kwargs: force_unicode(func(*args, **kwargs))
+
+
+def get_api_type(obj):
+    if inspect.isclass(obj):
+        return u'class'
+    elif inspect.ismodule(obj):
+        return u'module'
+    elif inspect.isbuiltin(obj) or inspect.ismethod(obj) \
+            or inspect.ismethoddescriptor(obj) or inspect.isfunction(obj):
+        return u'function'
+    # Everything else...
+    return u'instance'
+
+
+class DirectObjectAccess(object):
+    def __init__(self, inference_state, obj):
+        self._inference_state = inference_state
+        self._obj = obj
+
+    def __repr__(self):
+        return '%s(%s)' % (self.__class__.__name__, self.get_repr())
+
+    def _create_access(self, obj):
+        return create_access(self._inference_state, obj)
+
+    def _create_access_path(self, obj):
+        return create_access_path(self._inference_state, obj)
+
+    def py__bool__(self):
+        return bool(self._obj)
+
+    def py__file__(self):
+        try:
+            return self._obj.__file__
+        except AttributeError:
+            return None
+
+    def py__doc__(self):
+        return force_unicode(inspect.getdoc(self._obj)) or u''
+
+    def py__name__(self):
+        if not _is_class_instance(self._obj) or \
+                inspect.ismethoddescriptor(self._obj):  # slots
+            cls = self._obj
+        else:
+            try:
+                cls = self._obj.__class__
+            except AttributeError:
+                # happens with numpy.core.umath._UFUNC_API (you get it
+                # automatically by doing `import numpy`.
+                return None
+
+        try:
+            return force_unicode(cls.__name__)
+        except AttributeError:
+            return None
+
+    def py__mro__accesses(self):
+        return tuple(self._create_access_path(cls) for cls in self._obj.__mro__[1:])
+
+    def py__getitem__all_values(self):
+        if isinstance(self._obj, dict):
+            return [self._create_access_path(v) for v in self._obj.values()]
+        return self.py__iter__list()
+
+    def py__simple_getitem__(self, index):
+        if type(self._obj) not in ALLOWED_GETITEM_TYPES:
+            # Get rid of side effects, we won't call custom `__getitem__`s.
+            return None
+
+        return self._create_access_path(self._obj[index])
+
+    def py__iter__list(self):
+        if not hasattr(self._obj, '__getitem__'):
+            return None
+
+        if type(self._obj) not in ALLOWED_GETITEM_TYPES:
+            # Get rid of side effects, we won't call custom `__getitem__`s.
+            return []
+
+        lst = []
+        for i, part in enumerate(self._obj):
+            if i > 20:
+                # Should not go crazy with large iterators
+                break
+            lst.append(self._create_access_path(part))
+        return lst
+
+    def py__class__(self):
+        return self._create_access_path(self._obj.__class__)
+
+    def py__bases__(self):
+        return [self._create_access_path(base) for base in self._obj.__bases__]
+
+    def py__path__(self):
+        paths = getattr(self._obj, '__path__', None)
+        # Avoid some weird hacks that would just fail, because they cannot be
+        # used by pickle.
+        if not isinstance(paths, list) \
+                or not all(isinstance(p, (bytes, unicode)) for p in paths):
+            return None
+        return paths
+
+    @_force_unicode_decorator
+    @shorten_repr
+    def get_repr(self):
+        builtins = 'builtins', '__builtin__'
+
+        if inspect.ismodule(self._obj):
+            return repr(self._obj)
+        # Try to avoid execution of the property.
+        if safe_getattr(self._obj, '__module__', default='') in builtins:
+            return repr(self._obj)
+
+        type_ = type(self._obj)
+        if type_ == type:
+            return type.__repr__(self._obj)
+
+        if safe_getattr(type_, '__module__', default='') in builtins:
+            # Allow direct execution of repr for builtins.
+            return repr(self._obj)
+        return object.__repr__(self._obj)
+
+    def is_class(self):
+        return inspect.isclass(self._obj)
+
+    def is_function(self):
+        return inspect.isfunction(self._obj) or inspect.ismethod(self._obj)
+
+    def is_module(self):
+        return inspect.ismodule(self._obj)
+
+    def is_instance(self):
+        return _is_class_instance(self._obj)
+
+    def ismethoddescriptor(self):
+        return inspect.ismethoddescriptor(self._obj)
+
+    def get_qualified_names(self):
+        def try_to_get_name(obj):
+            return getattr(obj, '__qualname__', getattr(obj, '__name__', None))
+
+        if self.is_module():
+            return ()
+        name = try_to_get_name(self._obj)
+        if name is None:
+            name = try_to_get_name(type(self._obj))
+            if name is None:
+                return ()
+        return tuple(force_unicode(n) for n in name.split('.'))
+
+    def dir(self):
+        return list(map(force_unicode, dir(self._obj)))
+
+    def has_iter(self):
+        try:
+            iter(self._obj)
+            return True
+        except TypeError:
+            return False
+
+    def is_allowed_getattr(self, name, unsafe=False):
+        # TODO this API is ugly.
+        if unsafe:
+            # Unsafe is mostly used to check for __getattr__/__getattribute__.
+            # getattr_static works for properties, but the underscore methods
+            # are just ignored (because it's safer and avoids more code
+            # execution). See also GH #1378.
+
+            # Avoid warnings, see comment in the next function.
+            with warnings.catch_warnings(record=True):
+                warnings.simplefilter("always")
+                try:
+                    return hasattr(self._obj, name), False
+                except Exception:
+                    # Obviously has an attribute (propably a property) that
+                    # gets executed, so just avoid all exceptions here.
+                    return False, False
+        try:
+            attr, is_get_descriptor = getattr_static(self._obj, name)
+        except AttributeError:
+            return False, False
+        else:
+            if is_get_descriptor and type(attr) not in ALLOWED_DESCRIPTOR_ACCESS:
+                # In case of descriptors that have get methods we cannot return
+                # it's value, because that would mean code execution.
+                return True, True
+        return True, False
+
+    def getattr_paths(self, name, default=_sentinel):
+        try:
+            # Make sure no warnings are printed here, this is autocompletion,
+            # warnings should not be shown. See also GH #1383.
+            with warnings.catch_warnings(record=True):
+                warnings.simplefilter("always")
+                return_obj = getattr(self._obj, name)
+        except Exception as e:
+            if default is _sentinel:
+                if isinstance(e, AttributeError):
+                    # Happens e.g. in properties of
+                    # PyQt4.QtGui.QStyleOptionComboBox.currentText
+                    # -> just set it to None
+                    raise
+                # Just in case anything happens, return an AttributeError. It
+                # should not crash.
+                raise AttributeError
+            return_obj = default
+        access = self._create_access(return_obj)
+        if inspect.ismodule(return_obj):
+            return [access]
+
+        try:
+            module = return_obj.__module__
+        except AttributeError:
+            pass
+        else:
+            if module is not None:
+                try:
+                    __import__(module)
+                    # For some modules like _sqlite3, the __module__ for classes is
+                    # different, in this case it's sqlite3. So we have to try to
+                    # load that "original" module, because it's not loaded yet. If
+                    # we don't do that, we don't really have a "parent" module and
+                    # we would fall back to builtins.
+                except ImportError:
+                    pass
+
+        module = inspect.getmodule(return_obj)
+        if module is None:
+            module = inspect.getmodule(type(return_obj))
+            if module is None:
+                module = builtins
+        return [self._create_access(module), access]
+
+    def get_safe_value(self):
+        if type(self._obj) in (bool, bytes, float, int, str, unicode, slice) or self._obj is None:
+            return self._obj
+        raise ValueError("Object is type %s and not simple" % type(self._obj))
+
+    def get_api_type(self):
+        return get_api_type(self._obj)
+
+    def get_array_type(self):
+        if isinstance(self._obj, dict):
+            return 'dict'
+        return None
+
+    def get_key_paths(self):
+        def iter_partial_keys():
+            # We could use list(keys()), but that might take a lot more memory.
+            for (i, k) in enumerate(self._obj.keys()):
+                # Limit key listing at some point. This is artificial, but this
+                # way we don't get stalled because of slow completions
+                if i > 50:
+                    break
+                yield k
+
+        return [self._create_access_path(k) for k in iter_partial_keys()]
+
+    def get_access_path_tuples(self):
+        accesses = [create_access(self._inference_state, o) for o in self._get_objects_path()]
+        return [(access.py__name__(), access) for access in accesses]
+
+    def _get_objects_path(self):
+        def get():
+            obj = self._obj
+            yield obj
+            try:
+                obj = obj.__objclass__
+            except AttributeError:
+                pass
+            else:
+                yield obj
+
+            try:
+                # Returns a dotted string path.
+                imp_plz = obj.__module__
+            except AttributeError:
+                # Unfortunately in some cases like `int` there's no __module__
+                if not inspect.ismodule(obj):
+                    yield builtins
+            else:
+                if imp_plz is None:
+                    # Happens for example in `(_ for _ in []).send.__module__`.
+                    yield builtins
+                else:
+                    try:
+                        yield sys.modules[imp_plz]
+                    except KeyError:
+                        # __module__ can be something arbitrary that doesn't exist.
+                        yield builtins
+
+        return list(reversed(list(get())))
+
+    def execute_operation(self, other_access_handle, operator):
+        other_access = other_access_handle.access
+        op = _OPERATORS[operator]
+        return self._create_access_path(op(self._obj, other_access._obj))
+
+    def get_annotation_name_and_args(self):
+        """
+        Returns Tuple[Optional[str], Tuple[AccessPath, ...]]
+        """
+        if sys.version_info < (3, 5):
+            return None, ()
+
+        name = None
+        args = ()
+        if safe_getattr(self._obj, '__module__', default='') == 'typing':
+            m = re.match(r'typing.(\w+)\[', repr(self._obj))
+            if m is not None:
+                name = m.group(1)
+
+                import typing
+                if sys.version_info >= (3, 8):
+                    args = typing.get_args(self._obj)
+                else:
+                    args = safe_getattr(self._obj, '__args__', default=None)
+        return name, tuple(self._create_access_path(arg) for arg in args)
+
+    def needs_type_completions(self):
+        return inspect.isclass(self._obj) and self._obj != type
+
+    def _annotation_to_str(self, annotation):
+        if py_version < 30:
+            return ''
+        return inspect.formatannotation(annotation)
+
+    def get_signature_params(self):
+        return [
+            SignatureParam(
+                name=p.name,
+                has_default=p.default is not p.empty,
+                default=self._create_access_path(p.default),
+                default_string=repr(p.default),
+                has_annotation=p.annotation is not p.empty,
+                annotation=self._create_access_path(p.annotation),
+                annotation_string=self._annotation_to_str(p.annotation),
+                kind_name=str(p.kind)
+            ) for p in self._get_signature().parameters.values()
+        ]
+
+    def _get_signature(self):
+        obj = self._obj
+        if py_version < 33:
+            raise ValueError("inspect.signature was introduced in 3.3")
+        try:
+            return inspect.signature(obj)
+        except (RuntimeError, TypeError):
+            # Reading the code of the function in Python 3.6 implies there are
+            # at least these errors that might occur if something is wrong with
+            # the signature. In that case we just want a simple escape for now.
+            raise ValueError
+
+    def get_return_annotation(self):
+        try:
+            o = self._obj.__annotations__.get('return')
+        except AttributeError:
+            return None
+
+        if o is None:
+            return None
+
+        try:
+            # Python 2 doesn't have typing.
+            import typing
+        except ImportError:
+            pass
+        else:
+            try:
+                o = typing.get_type_hints(self._obj).get('return')
+            except Exception:
+                pass
+
+        return self._create_access_path(o)
+
+    def negate(self):
+        return self._create_access_path(-self._obj)
+
+    def get_dir_infos(self):
+        """
+        Used to return a couple of infos that are needed when accessing the sub
+        objects of an objects
+        """
+        tuples = dict(
+            (force_unicode(name), self.is_allowed_getattr(name))
+            for name in self.dir()
+        )
+        return self.needs_type_completions(), tuples
+
+
+def _is_class_instance(obj):
+    """Like inspect.* methods."""
+    try:
+        cls = obj.__class__
+    except AttributeError:
+        return False
+    else:
+        # The isinstance check for cls is just there so issubclass doesn't
+        # raise an exception.
+        return cls != type and isinstance(cls, type) and not issubclass(cls, NOT_CLASS_TYPES)

venv/Lib/site-packages/jedi/inference/compiled/getattr_static.py

@@ -0,0 +1,184 @@
+"""
+A static version of getattr.
+This is a backport of the Python 3 code with a little bit of additional
+information returned to enable Jedi to make decisions.
+"""
+
+import types
+
+from jedi import debug
+from jedi._compatibility import py_version
+
+_sentinel = object()
+
+
+def _check_instance(obj, attr):
+    instance_dict = {}
+    try:
+        instance_dict = object.__getattribute__(obj, "__dict__")
+    except AttributeError:
+        pass
+    return dict.get(instance_dict, attr, _sentinel)
+
+
+def _check_class(klass, attr):
+    for entry in _static_getmro(klass):
+        if _shadowed_dict(type(entry)) is _sentinel:
+            try:
+                return entry.__dict__[attr]
+            except KeyError:
+                pass
+    return _sentinel
+
+
+def _is_type(obj):
+    try:
+        _static_getmro(obj)
+    except TypeError:
+        return False
+    return True
+
+
+def _shadowed_dict_newstyle(klass):
+    dict_attr = type.__dict__["__dict__"]
+    for entry in _static_getmro(klass):
+        try:
+            class_dict = dict_attr.__get__(entry)["__dict__"]
+        except KeyError:
+            pass
+        else:
+            if not (type(class_dict) is types.GetSetDescriptorType
+                    and class_dict.__name__ == "__dict__"
+                    and class_dict.__objclass__ is entry):
+                return class_dict
+    return _sentinel
+
+
+def _static_getmro_newstyle(klass):
+    mro = type.__dict__['__mro__'].__get__(klass)
+    if not isinstance(mro, (tuple, list)):
+        # There are unfortunately no tests for this, I was not able to
+        # reproduce this in pure Python. However should still solve the issue
+        # raised in GH #1517.
+        debug.warning('mro of %s returned %s, should be a tuple' % (klass, mro))
+        return ()
+    return mro
+
+
+if py_version >= 30:
+    _shadowed_dict = _shadowed_dict_newstyle
+    _get_type = type
+    _static_getmro = _static_getmro_newstyle
+else:
+    def _shadowed_dict(klass):
+        """
+        In Python 2 __dict__ is not overwritable:
+
+            class Foo(object): pass
+            setattr(Foo, '__dict__', 4)
+
+            Traceback (most recent call last):
+              File "<stdin>", line 1, in <module>
+            TypeError: __dict__ must be a dictionary object
+
+        It applies to both newstyle and oldstyle classes:
+
+            class Foo(object): pass
+            setattr(Foo, '__dict__', 4)
+            Traceback (most recent call last):
+              File "<stdin>", line 1, in <module>
+            AttributeError: attribute '__dict__' of 'type' objects is not writable
+
+        It also applies to instances of those objects. However to keep things
+        straight forward, newstyle classes always use the complicated way of
+        accessing it while oldstyle classes just use getattr.
+        """
+        if type(klass) is _oldstyle_class_type:
+            return getattr(klass, '__dict__', _sentinel)
+        return _shadowed_dict_newstyle(klass)
+
+    class _OldStyleClass:
+        pass
+
+    _oldstyle_instance_type = type(_OldStyleClass())
+    _oldstyle_class_type = type(_OldStyleClass)
+
+    def _get_type(obj):
+        type_ = object.__getattribute__(obj, '__class__')
+        if type_ is _oldstyle_instance_type:
+            # Somehow for old style classes we need to access it directly.
+            return obj.__class__
+        return type_
+
+    def _static_getmro(klass):
+        if type(klass) is _oldstyle_class_type:
+            def oldstyle_mro(klass):
+                """
+                Oldstyle mro is a really simplistic way of look up mro:
+                https://stackoverflow.com/questions/54867/what-is-the-difference-between-old-style-and-new-style-classes-in-python
+                """
+                yield klass
+                for base in klass.__bases__:
+                    for yield_from in oldstyle_mro(base):
+                        yield yield_from
+
+            return oldstyle_mro(klass)
+
+        return _static_getmro_newstyle(klass)
+
+
+def _safe_hasattr(obj, name):
+    return _check_class(_get_type(obj), name) is not _sentinel
+
+
+def _safe_is_data_descriptor(obj):
+    return _safe_hasattr(obj, '__set__') or _safe_hasattr(obj, '__delete__')
+
+
+def getattr_static(obj, attr, default=_sentinel):
+    """Retrieve attributes without triggering dynamic lookup via the
+       descriptor protocol,  __getattr__ or __getattribute__.
+
+       Note: this function may not be able to retrieve all attributes
+       that getattr can fetch (like dynamically created attributes)
+       and may find attributes that getattr can't (like descriptors
+       that raise AttributeError). It can also return descriptor objects
+       instead of instance members in some cases. See the
+       documentation for details.
+
+       Returns a tuple `(attr, is_get_descriptor)`. is_get_descripter means that
+       the attribute is a descriptor that has a `__get__` attribute.
+    """
+    instance_result = _sentinel
+    if not _is_type(obj):
+        klass = _get_type(obj)
+        dict_attr = _shadowed_dict(klass)
+        if (dict_attr is _sentinel or type(dict_attr) is types.MemberDescriptorType):
+            instance_result = _check_instance(obj, attr)
+    else:
+        klass = obj
+
+    klass_result = _check_class(klass, attr)
+
+    if instance_result is not _sentinel and klass_result is not _sentinel:
+        if _safe_hasattr(klass_result, '__get__') \
+                and _safe_is_data_descriptor(klass_result):
+            # A get/set descriptor has priority over everything.
+            return klass_result, True
+
+    if instance_result is not _sentinel:
+        return instance_result, False
+    if klass_result is not _sentinel:
+        return klass_result, _safe_hasattr(klass_result, '__get__')
+
+    if obj is klass:
+        # for types we check the metaclass too
+        for entry in _static_getmro(type(klass)):
+            if _shadowed_dict(type(entry)) is _sentinel:
+                try:
+                    return entry.__dict__[attr], False
+                except KeyError:
+                    pass
+    if default is not _sentinel:
+        return default, False
+    raise AttributeError(attr)

venv/Lib/site-packages/jedi/inference/compiled/mixed.py

@@ -0,0 +1,304 @@
+"""
+Used only for REPL Completion.
+"""
+
+import inspect
+import os
+import sys
+
+from jedi.parser_utils import get_cached_code_lines
+
+from jedi._compatibility import unwrap
+from jedi import settings
+from jedi.cache import memoize_method
+from jedi.inference import compiled
+from jedi.file_io import FileIO
+from jedi.inference.names import NameWrapper
+from jedi.inference.base_value import ValueSet, ValueWrapper, NO_VALUES
+from jedi.inference.value import ModuleValue
+from jedi.inference.cache import inference_state_function_cache, \
+    inference_state_method_cache
+from jedi.inference.compiled.access import ALLOWED_GETITEM_TYPES, get_api_type
+from jedi.inference.gradual.conversion import to_stub
+from jedi.inference.context import CompiledContext, CompiledModuleContext, \
+    TreeContextMixin
+
+_sentinel = object()
+
+
+class MixedObject(ValueWrapper):
+    """
+    A ``MixedObject`` is used in two ways:
+
+    1. It uses the default logic of ``parser.python.tree`` objects,
+    2. except for getattr calls and signatures. The names dicts are generated
+       in a fashion like ``CompiledValue``.
+
+    This combined logic makes it possible to provide more powerful REPL
+    completion. It allows side effects that are not noticable with the default
+    parser structure to still be completeable.
+
+    The biggest difference from CompiledValue to MixedObject is that we are
+    generally dealing with Python code and not with C code. This will generate
+    fewer special cases, because we in Python you don't have the same freedoms
+    to modify the runtime.
+    """
+    def __init__(self, compiled_value, tree_value):
+        super(MixedObject, self).__init__(tree_value)
+        self.compiled_value = compiled_value
+        self.access_handle = compiled_value.access_handle
+
+    def get_filters(self, *args, **kwargs):
+        yield MixedObjectFilter(
+            self.inference_state, self.compiled_value, self._wrapped_value)
+
+    def get_signatures(self):
+        # Prefer `inspect.signature` over somehow analyzing Python code. It
+        # should be very precise, especially for stuff like `partial`.
+        return self.compiled_value.get_signatures()
+
+    @inference_state_method_cache(default=NO_VALUES)
+    def py__call__(self, arguments):
+        # Fallback to the wrapped value if to stub returns no values.
+        values = to_stub(self._wrapped_value)
+        if not values:
+            values = self._wrapped_value
+        return values.py__call__(arguments)
+
+    def get_safe_value(self, default=_sentinel):
+        if default is _sentinel:
+            return self.compiled_value.get_safe_value()
+        else:
+            return self.compiled_value.get_safe_value(default)
+
+    @property
+    def array_type(self):
+        return self.compiled_value.array_type
+
+    def get_key_values(self):
+        return self.compiled_value.get_key_values()
+
+    def py__simple_getitem__(self, index):
+        python_object = self.compiled_value.access_handle.access._obj
+        if type(python_object) in ALLOWED_GETITEM_TYPES:
+            return self.compiled_value.py__simple_getitem__(index)
+        return self._wrapped_value.py__simple_getitem__(index)
+
+    def negate(self):
+        return self.compiled_value.negate()
+
+    def _as_context(self):
+        if self.parent_context is None:
+            return MixedModuleContext(self)
+        return MixedContext(self)
+
+    def __repr__(self):
+        return '<%s: %s; %s>' % (
+            type(self).__name__,
+            self.access_handle.get_repr(),
+            self._wrapped_value,
+        )
+
+
+class MixedContext(CompiledContext, TreeContextMixin):
+    @property
+    def compiled_value(self):
+        return self._value.compiled_value
+
+
+class MixedModuleContext(CompiledModuleContext, MixedContext):
+    pass
+
+
+class MixedName(NameWrapper):
+    """
+    The ``CompiledName._compiled_value`` is our MixedObject.
+    """
+    def __init__(self, wrapped_name, parent_tree_value):
+        super(MixedName, self).__init__(wrapped_name)
+        self._parent_tree_value = parent_tree_value
+
+    @property
+    def start_pos(self):
+        values = list(self.infer())
+        if not values:
+            # This means a start_pos that doesn't exist (compiled objects).
+            return 0, 0
+        return values[0].name.start_pos
+
+    @memoize_method
+    def infer(self):
+        compiled_value = self._wrapped_name.infer_compiled_value()
+        tree_value = self._parent_tree_value
+        if tree_value.is_instance() or tree_value.is_class():
+            tree_values = tree_value.py__getattribute__(self.string_name)
+            if compiled_value.is_function():
+                return ValueSet({MixedObject(compiled_value, v) for v in tree_values})
+
+        module_context = tree_value.get_root_context()
+        return _create(self._inference_state, compiled_value, module_context)
+
+
+class MixedObjectFilter(compiled.CompiledValueFilter):
+    def __init__(self, inference_state, compiled_value, tree_value):
+        super(MixedObjectFilter, self).__init__(inference_state, compiled_value)
+        self._tree_value = tree_value
+
+    def _create_name(self, name):
+        return MixedName(
+            super(MixedObjectFilter, self)._create_name(name),
+            self._tree_value,
+        )
+
+
+@inference_state_function_cache()
+def _load_module(inference_state, path):
+    return inference_state.parse(
+        path=path,
+        cache=True,
+        diff_cache=settings.fast_parser,
+        cache_path=settings.cache_directory
+    ).get_root_node()
+
+
+def _get_object_to_check(python_object):
+    """Check if inspect.getfile has a chance to find the source."""
+    if sys.version_info[0] > 2:
+        try:
+            python_object = unwrap(python_object)
+        except ValueError:
+            # Can return a ValueError when it wraps around
+            pass
+
+    if (inspect.ismodule(python_object)
+            or inspect.isclass(python_object)
+            or inspect.ismethod(python_object)
+            or inspect.isfunction(python_object)
+            or inspect.istraceback(python_object)
+            or inspect.isframe(python_object)
+            or inspect.iscode(python_object)):
+        return python_object
+
+    try:
+        return python_object.__class__
+    except AttributeError:
+        raise TypeError  # Prevents computation of `repr` within inspect.
+
+
+def _find_syntax_node_name(inference_state, python_object):
+    original_object = python_object
+    try:
+        python_object = _get_object_to_check(python_object)
+        path = inspect.getsourcefile(python_object)
+    except TypeError:
+        # The type might not be known (e.g. class_with_dict.__weakref__)
+        return None
+    if path is None or not os.path.exists(path):
+        # The path might not exist or be e.g. <stdin>.
+        return None
+
+    file_io = FileIO(path)
+    module_node = _load_module(inference_state, path)
+
+    if inspect.ismodule(python_object):
+        # We don't need to check names for modules, because there's not really
+        # a way to write a module in a module in Python (and also __name__ can
+        # be something like ``email.utils``).
+        code_lines = get_cached_code_lines(inference_state.grammar, path)
+        return module_node, module_node, file_io, code_lines
+
+    try:
+        name_str = python_object.__name__
+    except AttributeError:
+        # Stuff like python_function.__code__.
+        return None
+
+    if name_str == '<lambda>':
+        return None  # It's too hard to find lambdas.
+
+    # Doesn't always work (e.g. os.stat_result)
+    names = module_node.get_used_names().get(name_str, [])
+    # Only functions and classes are relevant. If a name e.g. points to an
+    # import, it's probably a builtin (like collections.deque) and needs to be
+    # ignored.
+    names = [
+        n for n in names
+        if n.parent.type in ('funcdef', 'classdef') and n.parent.name == n
+    ]
+    if not names:
+        return None
+
+    try:
+        code = python_object.__code__
+        # By using the line number of a code object we make the lookup in a
+        # file pretty easy. There's still a possibility of people defining
+        # stuff like ``a = 3; foo(a); a = 4`` on the same line, but if people
+        # do so we just don't care.
+        line_nr = code.co_firstlineno
+    except AttributeError:
+        pass
+    else:
+        line_names = [name for name in names if name.start_pos[0] == line_nr]
+        # There's a chance that the object is not available anymore, because
+        # the code has changed in the background.
+        if line_names:
+            names = line_names
+
+    code_lines = get_cached_code_lines(inference_state.grammar, path)
+    # It's really hard to actually get the right definition, here as a last
+    # resort we just return the last one. This chance might lead to odd
+    # completions at some points but will lead to mostly correct type
+    # inference, because people tend to define a public name in a module only
+    # once.
+    tree_node = names[-1].parent
+    if tree_node.type == 'funcdef' and get_api_type(original_object) == 'instance':
+        # If an instance is given and we're landing on a function (e.g.
+        # partial in 3.5), something is completely wrong and we should not
+        # return that.
+        return None
+    return module_node, tree_node, file_io, code_lines
+
+
+@inference_state_function_cache()
+def _create(inference_state, compiled_value, module_context):
+    # TODO accessing this is bad, but it probably doesn't matter that much,
+    # because we're working with interpreteters only here.
+    python_object = compiled_value.access_handle.access._obj
+    result = _find_syntax_node_name(inference_state, python_object)
+    if result is None:
+        # TODO Care about generics from stuff like `[1]` and don't return like this.
+        if type(python_object) in (dict, list, tuple):
+            return ValueSet({compiled_value})
+
+        tree_values = to_stub(compiled_value)
+        if not tree_values:
+            return ValueSet({compiled_value})
+    else:
+        module_node, tree_node, file_io, code_lines = result
+
+        if module_context is None or module_context.tree_node != module_node:
+            root_compiled_value = compiled_value.get_root_context().get_value()
+            # TODO this __name__ might be wrong.
+            name = root_compiled_value.py__name__()
+            string_names = tuple(name.split('.'))
+            module_value = ModuleValue(
+                inference_state, module_node,
+                file_io=file_io,
+                string_names=string_names,
+                code_lines=code_lines,
+                is_package=root_compiled_value.is_package(),
+            )
+            if name is not None:
+                inference_state.module_cache.add(string_names, ValueSet([module_value]))
+            module_context = module_value.as_context()
+
+        tree_values = ValueSet({module_context.create_value(tree_node)})
+        if tree_node.type == 'classdef':
+            if not compiled_value.is_class():
+                # Is an instance, not a class.
+                tree_values = tree_values.execute_with_values()
+
+    return ValueSet(
+        MixedObject(compiled_value, tree_value=tree_value)
+        for tree_value in tree_values
+    )

venv/Lib/site-packages/jedi/inference/compiled/subprocess/__init__.py

@@ -0,0 +1,404 @@
+"""
+Makes it possible to do the compiled analysis in a subprocess. This has two
+goals:
+
+1. Making it safer - Segfaults and RuntimeErrors as well as stdout/stderr can
+   be ignored and dealt with.
+2. Make it possible to handle different Python versions as well as virtualenvs.
+"""
+
+import os
+import sys
+import subprocess
+import socket
+import errno
+import traceback
+from functools import partial
+from threading import Thread
+try:
+    from queue import Queue, Empty
+except ImportError:
+    from Queue import Queue, Empty  # python 2.7
+
+from jedi._compatibility import queue, is_py3, force_unicode, \
+    pickle_dump, pickle_load, GeneralizedPopen, weakref
+from jedi import debug
+from jedi.cache import memoize_method
+from jedi.inference.compiled.subprocess import functions
+from jedi.inference.compiled.access import DirectObjectAccess, AccessPath, \
+    SignatureParam
+from jedi.api.exceptions import InternalError
+
+
+_MAIN_PATH = os.path.join(os.path.dirname(__file__), '__main__.py')
+
+
+def _enqueue_output(out, queue):
+    for line in iter(out.readline, b''):
+        queue.put(line)
+
+
+def _add_stderr_to_debug(stderr_queue):
+    while True:
+        # Try to do some error reporting from the subprocess and print its
+        # stderr contents.
+        try:
+            line = stderr_queue.get_nowait()
+            line = line.decode('utf-8', 'replace')
+            debug.warning('stderr output: %s' % line.rstrip('\n'))
+        except Empty:
+            break
+
+
+def _get_function(name):
+    return getattr(functions, name)
+
+
+def _cleanup_process(process, thread):
+    try:
+        process.kill()
+        process.wait()
+    except OSError:
+        # Raised if the process is already killed.
+        pass
+    thread.join()
+    for stream in [process.stdin, process.stdout, process.stderr]:
+        try:
+            stream.close()
+        except OSError:
+            # Raised if the stream is broken.
+            pass
+
+
+class _InferenceStateProcess(object):
+    def __init__(self, inference_state):
+        self._inference_state_weakref = weakref.ref(inference_state)
+        self._inference_state_id = id(inference_state)
+        self._handles = {}
+
+    def get_or_create_access_handle(self, obj):
+        id_ = id(obj)
+        try:
+            return self.get_access_handle(id_)
+        except KeyError:
+            access = DirectObjectAccess(self._inference_state_weakref(), obj)
+            handle = AccessHandle(self, access, id_)
+            self.set_access_handle(handle)
+            return handle
+
+    def get_access_handle(self, id_):
+        return self._handles[id_]
+
+    def set_access_handle(self, handle):
+        self._handles[handle.id] = handle
+
+
+class InferenceStateSameProcess(_InferenceStateProcess):
+    """
+    Basically just an easy access to functions.py. It has the same API
+    as InferenceStateSubprocess and does the same thing without using a subprocess.
+    This is necessary for the Interpreter process.
+    """
+    def __getattr__(self, name):
+        return partial(_get_function(name), self._inference_state_weakref())
+
+
+class InferenceStateSubprocess(_InferenceStateProcess):
+    def __init__(self, inference_state, compiled_subprocess):
+        super(InferenceStateSubprocess, self).__init__(inference_state)
+        self._used = False
+        self._compiled_subprocess = compiled_subprocess
+
+    def __getattr__(self, name):
+        func = _get_function(name)
+
+        def wrapper(*args, **kwargs):
+            self._used = True
+
+            result = self._compiled_subprocess.run(
+                self._inference_state_weakref(),
+                func,
+                args=args,
+                kwargs=kwargs,
+            )
+            # IMO it should be possible to create a hook in pickle.load to
+            # mess with the loaded objects. However it's extremely complicated
+            # to work around this so just do it with this call. ~ dave
+            return self._convert_access_handles(result)
+
+        return wrapper
+
+    def _convert_access_handles(self, obj):
+        if isinstance(obj, SignatureParam):
+            return SignatureParam(*self._convert_access_handles(tuple(obj)))
+        elif isinstance(obj, tuple):
+            return tuple(self._convert_access_handles(o) for o in obj)
+        elif isinstance(obj, list):
+            return [self._convert_access_handles(o) for o in obj]
+        elif isinstance(obj, AccessHandle):
+            try:
+                # Rewrite the access handle to one we're already having.
+                obj = self.get_access_handle(obj.id)
+            except KeyError:
+                obj.add_subprocess(self)
+                self.set_access_handle(obj)
+        elif isinstance(obj, AccessPath):
+            return AccessPath(self._convert_access_handles(obj.accesses))
+        return obj
+
+    def __del__(self):
+        if self._used and not self._compiled_subprocess.is_crashed:
+            self._compiled_subprocess.delete_inference_state(self._inference_state_id)
+
+
+class CompiledSubprocess(object):
+    is_crashed = False
+    # Start with 2, gets set after _get_info.
+    _pickle_protocol = 2
+
+    def __init__(self, executable, env_vars=None):
+        self._executable = executable
+        self._env_vars = env_vars
+        self._inference_state_deletion_queue = queue.deque()
+        self._cleanup_callable = lambda: None
+
+    def __repr__(self):
+        pid = os.getpid()
+        return '<%s _executable=%r, _pickle_protocol=%r, is_crashed=%r, pid=%r>' % (
+            self.__class__.__name__,
+            self._executable,
+            self._pickle_protocol,
+            self.is_crashed,
+            pid,
+        )
+
+    @memoize_method
+    def _get_process(self):
+        debug.dbg('Start environment subprocess %s', self._executable)
+        parso_path = sys.modules['parso'].__file__
+        args = (
+            self._executable,
+            _MAIN_PATH,
+            os.path.dirname(os.path.dirname(parso_path)),
+            '.'.join(str(x) for x in sys.version_info[:3]),
+        )
+        process = GeneralizedPopen(
+            args,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            # Use system default buffering on Python 2 to improve performance
+            # (this is already the case on Python 3).
+            bufsize=-1,
+            env=self._env_vars
+        )
+        self._stderr_queue = Queue()
+        self._stderr_thread = t = Thread(
+            target=_enqueue_output,
+            args=(process.stderr, self._stderr_queue)
+        )
+        t.daemon = True
+        t.start()
+        # Ensure the subprocess is properly cleaned up when the object
+        # is garbage collected.
+        self._cleanup_callable = weakref.finalize(self,
+                                                  _cleanup_process,
+                                                  process,
+                                                  t)
+        return process
+
+    def run(self, inference_state, function, args=(), kwargs={}):
+        # Delete old inference_states.
+        while True:
+            try:
+                inference_state_id = self._inference_state_deletion_queue.pop()
+            except IndexError:
+                break
+            else:
+                self._send(inference_state_id, None)
+
+        assert callable(function)
+        return self._send(id(inference_state), function, args, kwargs)
+
+    def get_sys_path(self):
+        return self._send(None, functions.get_sys_path, (), {})
+
+    def _kill(self):
+        self.is_crashed = True
+        self._cleanup_callable()
+
+    def _send(self, inference_state_id, function, args=(), kwargs={}):
+        if self.is_crashed:
+            raise InternalError("The subprocess %s has crashed." % self._executable)
+
+        if not is_py3:
+            # Python 2 compatibility
+            kwargs = {force_unicode(key): value for key, value in kwargs.items()}
+
+        data = inference_state_id, function, args, kwargs
+        try:
+            pickle_dump(data, self._get_process().stdin, self._pickle_protocol)
+        except (socket.error, IOError) as e:
+            # Once Python2 will be removed we can just use `BrokenPipeError`.
+            # Also, somehow in windows it returns EINVAL instead of EPIPE if
+            # the subprocess dies.
+            if e.errno not in (errno.EPIPE, errno.EINVAL):
+                # Not a broken pipe
+                raise
+            self._kill()
+            raise InternalError("The subprocess %s was killed. Maybe out of memory?"
+                                % self._executable)
+
+        try:
+            is_exception, traceback, result = pickle_load(self._get_process().stdout)
+        except EOFError as eof_error:
+            try:
+                stderr = self._get_process().stderr.read().decode('utf-8', 'replace')
+            except Exception as exc:
+                stderr = '<empty/not available (%r)>' % exc
+            self._kill()
+            _add_stderr_to_debug(self._stderr_queue)
+            raise InternalError(
+                "The subprocess %s has crashed (%r, stderr=%s)." % (
+                    self._executable,
+                    eof_error,
+                    stderr,
+                ))
+
+        _add_stderr_to_debug(self._stderr_queue)
+
+        if is_exception:
+            # Replace the attribute error message with a the traceback. It's
+            # way more informative.
+            result.args = (traceback,)
+            raise result
+        return result
+
+    def delete_inference_state(self, inference_state_id):
+        """
+        Currently we are not deleting inference_state instantly. They only get
+        deleted once the subprocess is used again. It would probably a better
+        solution to move all of this into a thread. However, the memory usage
+        of a single inference_state shouldn't be that high.
+        """
+        # With an argument - the inference_state gets deleted.
+        self._inference_state_deletion_queue.append(inference_state_id)
+
+
+class Listener(object):
+    def __init__(self, pickle_protocol):
+        self._inference_states = {}
+        # TODO refactor so we don't need to process anymore just handle
+        # controlling.
+        self._process = _InferenceStateProcess(Listener)
+        self._pickle_protocol = pickle_protocol
+
+    def _get_inference_state(self, function, inference_state_id):
+        from jedi.inference import InferenceState
+
+        try:
+            inference_state = self._inference_states[inference_state_id]
+        except KeyError:
+            from jedi import InterpreterEnvironment
+            inference_state = InferenceState(
+                # The project is not actually needed. Nothing should need to
+                # access it.
+                project=None,
+                environment=InterpreterEnvironment()
+            )
+            self._inference_states[inference_state_id] = inference_state
+        return inference_state
+
+    def _run(self, inference_state_id, function, args, kwargs):
+        if inference_state_id is None:
+            return function(*args, **kwargs)
+        elif function is None:
+            del self._inference_states[inference_state_id]
+        else:
+            inference_state = self._get_inference_state(function, inference_state_id)
+
+            # Exchange all handles
+            args = list(args)
+            for i, arg in enumerate(args):
+                if isinstance(arg, AccessHandle):
+                    args[i] = inference_state.compiled_subprocess.get_access_handle(arg.id)
+            for key, value in kwargs.items():
+                if isinstance(value, AccessHandle):
+                    kwargs[key] = inference_state.compiled_subprocess.get_access_handle(value.id)
+
+            return function(inference_state, *args, **kwargs)
+
+    def listen(self):
+        stdout = sys.stdout
+        # Mute stdout. Nobody should actually be able to write to it,
+        # because stdout is used for IPC.
+        sys.stdout = open(os.devnull, 'w')
+        stdin = sys.stdin
+        if sys.version_info[0] > 2:
+            stdout = stdout.buffer
+            stdin = stdin.buffer
+        # Python 2 opens streams in text mode on Windows. Set stdout and stdin
+        # to binary mode.
+        elif sys.platform == 'win32':
+            import msvcrt
+            msvcrt.setmode(stdout.fileno(), os.O_BINARY)
+            msvcrt.setmode(stdin.fileno(), os.O_BINARY)
+
+        while True:
+            try:
+                payload = pickle_load(stdin)
+            except EOFError:
+                # It looks like the parent process closed.
+                # Don't make a big fuss here and just exit.
+                exit(0)
+            try:
+                result = False, None, self._run(*payload)
+            except Exception as e:
+                result = True, traceback.format_exc(), e
+
+            pickle_dump(result, stdout, self._pickle_protocol)
+
+
+class AccessHandle(object):
+    def __init__(self, subprocess, access, id_):
+        self.access = access
+        self._subprocess = subprocess
+        self.id = id_
+
+    def add_subprocess(self, subprocess):
+        self._subprocess = subprocess
+
+    def __repr__(self):
+        try:
+            detail = self.access
+        except AttributeError:
+            detail = '#' + str(self.id)
+        return '<%s of %s>' % (self.__class__.__name__, detail)
+
+    def __getstate__(self):
+        return self.id
+
+    def __setstate__(self, state):
+        self.id = state
+
+    def __getattr__(self, name):
+        if name in ('id', 'access') or name.startswith('_'):
+            raise AttributeError("Something went wrong with unpickling")
+
+        # if not is_py3: print >> sys.stderr, name
+        # print('getattr', name, file=sys.stderr)
+        return partial(self._workaround, force_unicode(name))
+
+    def _workaround(self, name, *args, **kwargs):
+        """
+        TODO Currently we're passing slice objects around. This should not
+        happen. They are also the only unhashable objects that we're passing
+        around.
+        """
+        if args and isinstance(args[0], slice):
+            return self._subprocess.get_compiled_method_return(self.id, name, *args, **kwargs)
+        return self._cached_results(name, *args, **kwargs)
+
+    @memoize_method
+    def _cached_results(self, name, *args, **kwargs):
+        return self._subprocess.get_compiled_method_return(self.id, name, *args, **kwargs)

venv/Lib/site-packages/jedi/inference/compiled/subprocess/__main__.py

@@ -0,0 +1,55 @@
+import os
+import sys
+
+
+def _get_paths():
+    # Get the path to jedi.
+    _d = os.path.dirname
+    _jedi_path = _d(_d(_d(_d(_d(__file__)))))
+    _parso_path = sys.argv[1]
+    # The paths are the directory that jedi and parso lie in.
+    return {'jedi': _jedi_path, 'parso': _parso_path}
+
+
+# Remove the first entry, because it's simply a directory entry that equals
+# this directory.
+del sys.path[0]
+
+if sys.version_info > (3, 4):
+    from importlib.machinery import PathFinder
+
+    class _ExactImporter(object):
+        def __init__(self, path_dct):
+            self._path_dct = path_dct
+
+        def find_module(self, fullname, path=None):
+            if path is None and fullname in self._path_dct:
+                p = self._path_dct[fullname]
+                loader = PathFinder.find_module(fullname, path=[p])
+                return loader
+            return None
+
+    # Try to import jedi/parso.
+    sys.meta_path.insert(0, _ExactImporter(_get_paths()))
+    from jedi.inference.compiled import subprocess  # NOQA
+    sys.meta_path.pop(0)
+else:
+    import imp
+
+    def load(name):
+        paths = list(_get_paths().values())
+        fp, pathname, description = imp.find_module(name, paths)
+        return imp.load_module(name, fp, pathname, description)
+
+    load('parso')
+    load('jedi')
+    from jedi.inference.compiled import subprocess  # NOQA
+
+from jedi._compatibility import highest_pickle_protocol  # noqa: E402
+
+
+# Retrieve the pickle protocol.
+host_sys_version = [int(x) for x in sys.argv[2].split('.')]
+pickle_protocol = highest_pickle_protocol([sys.version_info, host_sys_version])
+# And finally start the client.
+subprocess.Listener(pickle_protocol=pickle_protocol).listen()

venv/Lib/site-packages/jedi/inference/compiled/subprocess/functions.py

@@ -0,0 +1,115 @@
+from __future__ import print_function
+import sys
+import os
+import re
+import inspect
+
+from jedi._compatibility import find_module, cast_path, force_unicode, \
+    all_suffixes, scandir
+from jedi.inference.compiled import access
+from jedi import debug
+from jedi import parser_utils
+
+
+def get_sys_path():
+    return list(map(cast_path, sys.path))
+
+
+def load_module(inference_state, **kwargs):
+    return access.load_module(inference_state, **kwargs)
+
+
+def get_compiled_method_return(inference_state, id, attribute, *args, **kwargs):
+    handle = inference_state.compiled_subprocess.get_access_handle(id)
+    return getattr(handle.access, attribute)(*args, **kwargs)
+
+
+def create_simple_object(inference_state, obj):
+    return access.create_access_path(inference_state, obj)
+
+
+def get_module_info(inference_state, sys_path=None, full_name=None, **kwargs):
+    """
+    Returns Tuple[Union[NamespaceInfo, FileIO, None], Optional[bool]]
+    """
+    if sys_path is not None:
+        sys.path, temp = sys_path, sys.path
+    try:
+        return find_module(full_name=full_name, **kwargs)
+    except ImportError:
+        return None, None
+    finally:
+        if sys_path is not None:
+            sys.path = temp
+
+
+def get_builtin_module_names(inference_state):
+    return list(map(force_unicode, sys.builtin_module_names))
+
+
+def _test_raise_error(inference_state, exception_type):
+    """
+    Raise an error to simulate certain problems for unit tests.
+    """
+    raise exception_type
+
+
+def _test_print(inference_state, stderr=None, stdout=None):
+    """
+    Force some prints in the subprocesses. This exists for unit tests.
+    """
+    if stderr is not None:
+        print(stderr, file=sys.stderr)
+        sys.stderr.flush()
+    if stdout is not None:
+        print(stdout)
+        sys.stdout.flush()
+
+
+def _get_init_path(directory_path):
+    """
+    The __init__ file can be searched in a directory. If found return it, else
+    None.
+    """
+    for suffix in all_suffixes():
+        path = os.path.join(directory_path, '__init__' + suffix)
+        if os.path.exists(path):
+            return path
+    return None
+
+
+def safe_literal_eval(inference_state, value):
+    return parser_utils.safe_literal_eval(value)
+
+
+def iter_module_names(*args, **kwargs):
+    return list(_iter_module_names(*args, **kwargs))
+
+
+def _iter_module_names(inference_state, paths):
+    # Python modules/packages
+    for path in paths:
+        try:
+            dirs = scandir(path)
+        except OSError:
+            # The file might not exist or reading it might lead to an error.
+            debug.warning("Not possible to list directory: %s", path)
+            continue
+        for dir_entry in dirs:
+            name = dir_entry.name
+            # First Namespaces then modules/stubs
+            if dir_entry.is_dir():
+                # pycache is obviously not an interestin namespace. Also the
+                # name must be a valid identifier.
+                # TODO use str.isidentifier, once Python 2 is removed
+                if name != '__pycache__' and not re.search(r'\W|^\d', name):
+                    yield name
+            else:
+                if name.endswith('.pyi'):  # Stub files
+                    modname = name[:-4]
+                else:
+                    modname = inspect.getmodulename(name)
+
+                if modname and '.' not in modname:
+                    if modname != '__init__':
+                        yield modname

venv/Lib/site-packages/jedi/inference/compiled/value.py

@@ -0,0 +1,629 @@
+"""
+Imitate the parser representation.
+"""
+import re
+from functools import partial
+
+from jedi import debug
+from jedi.inference.utils import to_list
+from jedi._compatibility import force_unicode, Parameter, cast_path
+from jedi.cache import memoize_method
+from jedi.inference.filters import AbstractFilter
+from jedi.inference.names import AbstractNameDefinition, ValueNameMixin, \
+    ParamNameInterface
+from jedi.inference.base_value import Value, ValueSet, NO_VALUES
+from jedi.inference.lazy_value import LazyKnownValue
+from jedi.inference.compiled.access import _sentinel
+from jedi.inference.cache import inference_state_function_cache
+from jedi.inference.helpers import reraise_getitem_errors
+from jedi.inference.signature import BuiltinSignature
+from jedi.inference.context import CompiledContext, CompiledModuleContext
+
+
+class CheckAttribute(object):
+    """Raises :exc:`AttributeError` if the attribute X is not available."""
+    def __init__(self, check_name=None):
+        # Remove the py in front of e.g. py__call__.
+        self.check_name = check_name
+
+    def __call__(self, func):
+        self.func = func
+        if self.check_name is None:
+            self.check_name = force_unicode(func.__name__[2:])
+        return self
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            return self
+
+        # This might raise an AttributeError. That's wanted.
+        instance.access_handle.getattr_paths(self.check_name)
+        return partial(self.func, instance)
+
+
+class CompiledValue(Value):
+    def __init__(self, inference_state, access_handle, parent_context=None):
+        super(CompiledValue, self).__init__(inference_state, parent_context)
+        self.access_handle = access_handle
+
+    def py__call__(self, arguments):
+        return_annotation = self.access_handle.get_return_annotation()
+        if return_annotation is not None:
+            # TODO the return annotation may also be a string.
+            return create_from_access_path(
+                self.inference_state,
+                return_annotation
+            ).execute_annotation()
+
+        try:
+            self.access_handle.getattr_paths(u'__call__')
+        except AttributeError:
+            return super(CompiledValue, self).py__call__(arguments)
+        else:
+            if self.access_handle.is_class():
+                from jedi.inference.value import CompiledInstance
+                return ValueSet([
+                    CompiledInstance(self.inference_state, self.parent_context, self, arguments)
+                ])
+            else:
+                return ValueSet(self._execute_function(arguments))
+
+    @CheckAttribute()
+    def py__class__(self):
+        return create_from_access_path(self.inference_state, self.access_handle.py__class__())
+
+    @CheckAttribute()
+    def py__mro__(self):
+        return (self,) + tuple(
+            create_from_access_path(self.inference_state, access)
+            for access in self.access_handle.py__mro__accesses()
+        )
+
+    @CheckAttribute()
+    def py__bases__(self):
+        return tuple(
+            create_from_access_path(self.inference_state, access)
+            for access in self.access_handle.py__bases__()
+        )
+
+    def get_qualified_names(self):
+        return self.access_handle.get_qualified_names()
+
+    def py__bool__(self):
+        return self.access_handle.py__bool__()
+
+    def is_class(self):
+        return self.access_handle.is_class()
+
+    def is_function(self):
+        return self.access_handle.is_function()
+
+    def is_module(self):
+        return self.access_handle.is_module()
+
+    def is_compiled(self):
+        return True
+
+    def is_stub(self):
+        return False
+
+    def is_instance(self):
+        return self.access_handle.is_instance()
+
+    def py__doc__(self):
+        return self.access_handle.py__doc__()
+
+    @to_list
+    def get_param_names(self):
+        try:
+            signature_params = self.access_handle.get_signature_params()
+        except ValueError:  # Has no signature
+            params_str, ret = self._parse_function_doc()
+            if not params_str:
+                tokens = []
+            else:
+                tokens = params_str.split(',')
+            if self.access_handle.ismethoddescriptor():
+                tokens.insert(0, 'self')
+            for p in tokens:
+                name, _, default = p.strip().partition('=')
+                yield UnresolvableParamName(self, name, default)
+        else:
+            for signature_param in signature_params:
+                yield SignatureParamName(self, signature_param)
+
+    def get_signatures(self):
+        _, return_string = self._parse_function_doc()
+        return [BuiltinSignature(self, return_string)]
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self.access_handle.get_repr())
+
+    @memoize_method
+    def _parse_function_doc(self):
+        doc = self.py__doc__()
+        if doc is None:
+            return '', ''
+
+        return _parse_function_doc(doc)
+
+    @property
+    def api_type(self):
+        return self.access_handle.get_api_type()
+
+    def get_filters(self, is_instance=False, origin_scope=None):
+        yield self._ensure_one_filter(is_instance)
+
+    @memoize_method
+    def _ensure_one_filter(self, is_instance):
+        return CompiledValueFilter(self.inference_state, self, is_instance)
+
+    def py__simple_getitem__(self, index):
+        with reraise_getitem_errors(IndexError, KeyError, TypeError):
+            try:
+                access = self.access_handle.py__simple_getitem__(index)
+            except AttributeError:
+                return super(CompiledValue, self).py__simple_getitem__(index)
+        if access is None:
+            return NO_VALUES
+
+        return ValueSet([create_from_access_path(self.inference_state, access)])
+
+    def py__getitem__(self, index_value_set, contextualized_node):
+        all_access_paths = self.access_handle.py__getitem__all_values()
+        if all_access_paths is None:
+            # This means basically that no __getitem__ has been defined on this
+            # object.
+            return super(CompiledValue, self).py__getitem__(index_value_set, contextualized_node)
+        return ValueSet(
+            create_from_access_path(self.inference_state, access)
+            for access in all_access_paths
+        )
+
+    def py__iter__(self, contextualized_node=None):
+        # Python iterators are a bit strange, because there's no need for
+        # the __iter__ function as long as __getitem__ is defined (it will
+        # just start with __getitem__(0). This is especially true for
+        # Python 2 strings, where `str.__iter__` is not even defined.
+        if not self.access_handle.has_iter():
+            for x in super(CompiledValue, self).py__iter__(contextualized_node):
+                yield x
+
+        access_path_list = self.access_handle.py__iter__list()
+        if access_path_list is None:
+            # There is no __iter__ method on this object.
+            return
+
+        for access in access_path_list:
+            yield LazyKnownValue(create_from_access_path(self.inference_state, access))
+
+    def py__name__(self):
+        return self.access_handle.py__name__()
+
+    @property
+    def name(self):
+        name = self.py__name__()
+        if name is None:
+            name = self.access_handle.get_repr()
+        return CompiledValueName(self, name)
+
+    def _execute_function(self, params):
+        from jedi.inference import docstrings
+        from jedi.inference.compiled import builtin_from_name
+        if self.api_type != 'function':
+            return
+
+        for name in self._parse_function_doc()[1].split():
+            try:
+                # TODO wtf is this? this is exactly the same as the thing
+                # below. It uses getattr as well.
+                self.inference_state.builtins_module.access_handle.getattr_paths(name)
+            except AttributeError:
+                continue
+            else:
+                bltn_obj = builtin_from_name(self.inference_state, name)
+                for result in self.inference_state.execute(bltn_obj, params):
+                    yield result
+        for type_ in docstrings.infer_return_types(self):
+            yield type_
+
+    def get_safe_value(self, default=_sentinel):
+        try:
+            return self.access_handle.get_safe_value()
+        except ValueError:
+            if default == _sentinel:
+                raise
+            return default
+
+    def execute_operation(self, other, operator):
+        try:
+            return ValueSet([create_from_access_path(
+                self.inference_state,
+                self.access_handle.execute_operation(other.access_handle, operator)
+            )])
+        except TypeError:
+            return NO_VALUES
+
+    def execute_annotation(self):
+        if self.access_handle.get_repr() == 'None':
+            # None as an annotation doesn't need to be executed.
+            return ValueSet([self])
+
+        name, args = self.access_handle.get_annotation_name_and_args()
+        arguments = [
+            ValueSet([create_from_access_path(self.inference_state, path)])
+            for path in args
+        ]
+        if name == 'Union':
+            return ValueSet.from_sets(arg.execute_annotation() for arg in arguments)
+        elif name:
+            # While with_generics only exists on very specific objects, we
+            # should probably be fine, because we control all the typing
+            # objects.
+            return ValueSet([
+                v.with_generics(arguments)
+                for v in self.inference_state.typing_module.py__getattribute__(name)
+            ]).execute_annotation()
+        return super(CompiledValue, self).execute_annotation()
+
+    def negate(self):
+        return create_from_access_path(self.inference_state, self.access_handle.negate())
+
+    def get_metaclasses(self):
+        return NO_VALUES
+
+    def _as_context(self):
+        return CompiledContext(self)
+
+    @property
+    def array_type(self):
+        return self.access_handle.get_array_type()
+
+    def get_key_values(self):
+        return [
+            create_from_access_path(self.inference_state, k)
+            for k in self.access_handle.get_key_paths()
+        ]
+
+    def get_type_hint(self, add_class_info=True):
+        if self.access_handle.get_repr() in ('None', "<class 'NoneType'>"):
+            return 'None'
+        return None
+
+
+class CompiledModule(CompiledValue):
+    file_io = None  # For modules
+
+    def _as_context(self):
+        return CompiledModuleContext(self)
+
+    def py__path__(self):
+        paths = self.access_handle.py__path__()
+        if paths is None:
+            return None
+        return map(cast_path, paths)
+
+    def is_package(self):
+        return self.py__path__() is not None
+
+    @property
+    def string_names(self):
+        # For modules
+        name = self.py__name__()
+        if name is None:
+            return ()
+        return tuple(name.split('.'))
+
+    def py__file__(self):
+        return cast_path(self.access_handle.py__file__())
+
+
+class CompiledName(AbstractNameDefinition):
+    def __init__(self, inference_state, parent_value, name):
+        self._inference_state = inference_state
+        self.parent_context = parent_value.as_context()
+        self._parent_value = parent_value
+        self.string_name = name
+
+    def py__doc__(self):
+        value, = self.infer()
+        return value.py__doc__()
+
+    def _get_qualified_names(self):
+        parent_qualified_names = self.parent_context.get_qualified_names()
+        if parent_qualified_names is None:
+            return None
+        return parent_qualified_names + (self.string_name,)
+
+    def get_defining_qualified_value(self):
+        context = self.parent_context
+        if context.is_module() or context.is_class():
+            return self.parent_context.get_value()  # Might be None
+
+        return None
+
+    def __repr__(self):
+        try:
+            name = self.parent_context.name  # __name__ is not defined all the time
+        except AttributeError:
+            name = None
+        return '<%s: (%s).%s>' % (self.__class__.__name__, name, self.string_name)
+
+    @property
+    def api_type(self):
+        api = self.infer()
+        # If we can't find the type, assume it is an instance variable
+        if not api:
+            return "instance"
+        return next(iter(api)).api_type
+
+    @memoize_method
+    def infer(self):
+        return ValueSet([self.infer_compiled_value()])
+
+    def infer_compiled_value(self):
+        return create_from_name(self._inference_state, self._parent_value, self.string_name)
+
+
+class SignatureParamName(ParamNameInterface, AbstractNameDefinition):
+    def __init__(self, compiled_value, signature_param):
+        self.parent_context = compiled_value.parent_context
+        self._signature_param = signature_param
+
+    @property
+    def string_name(self):
+        return self._signature_param.name
+
+    def to_string(self):
+        s = self._kind_string() + self.string_name
+        if self._signature_param.has_annotation:
+            s += ': ' + self._signature_param.annotation_string
+        if self._signature_param.has_default:
+            s += '=' + self._signature_param.default_string
+        return s
+
+    def get_kind(self):
+        return getattr(Parameter, self._signature_param.kind_name)
+
+    def infer(self):
+        p = self._signature_param
+        inference_state = self.parent_context.inference_state
+        values = NO_VALUES
+        if p.has_default:
+            values = ValueSet([create_from_access_path(inference_state, p.default)])
+        if p.has_annotation:
+            annotation = create_from_access_path(inference_state, p.annotation)
+            values |= annotation.execute_with_values()
+        return values
+
+
+class UnresolvableParamName(ParamNameInterface, AbstractNameDefinition):
+    def __init__(self, compiled_value, name, default):
+        self.parent_context = compiled_value.parent_context
+        self.string_name = name
+        self._default = default
+
+    def get_kind(self):
+        return Parameter.POSITIONAL_ONLY
+
+    def to_string(self):
+        string = self.string_name
+        if self._default:
+            string += '=' + self._default
+        return string
+
+    def infer(self):
+        return NO_VALUES
+
+
+class CompiledValueName(ValueNameMixin, AbstractNameDefinition):
+    def __init__(self, value, name):
+        self.string_name = name
+        self._value = value
+        self.parent_context = value.parent_context
+
+
+class EmptyCompiledName(AbstractNameDefinition):
+    """
+    Accessing some names will raise an exception. To avoid not having any
+    completions, just give Jedi the option to return this object. It infers to
+    nothing.
+    """
+    def __init__(self, inference_state, name):
+        self.parent_context = inference_state.builtins_module
+        self.string_name = name
+
+    def infer(self):
+        return NO_VALUES
+
+
+class CompiledValueFilter(AbstractFilter):
+    def __init__(self, inference_state, compiled_value, is_instance=False):
+        self._inference_state = inference_state
+        self.compiled_value = compiled_value
+        self.is_instance = is_instance
+
+    def get(self, name):
+        access_handle = self.compiled_value.access_handle
+        return self._get(
+            name,
+            lambda name, unsafe: access_handle.is_allowed_getattr(name, unsafe),
+            lambda name: name in access_handle.dir(),
+            check_has_attribute=True
+        )
+
+    def _get(self, name, allowed_getattr_callback, in_dir_callback, check_has_attribute=False):
+        """
+        To remove quite a few access calls we introduced the callback here.
+        """
+        # Always use unicode objects in Python 2 from here.
+        name = force_unicode(name)
+
+        if self._inference_state.allow_descriptor_getattr:
+            pass
+
+        has_attribute, is_descriptor = allowed_getattr_callback(
+            name,
+            unsafe=self._inference_state.allow_descriptor_getattr
+        )
+        if check_has_attribute and not has_attribute:
+            return []
+
+        if (is_descriptor or not has_attribute) \
+                and not self._inference_state.allow_descriptor_getattr:
+            return [self._get_cached_name(name, is_empty=True)]
+
+        if self.is_instance and not in_dir_callback(name):
+            return []
+        return [self._get_cached_name(name)]
+
+    @memoize_method
+    def _get_cached_name(self, name, is_empty=False):
+        if is_empty:
+            return EmptyCompiledName(self._inference_state, name)
+        else:
+            return self._create_name(name)
+
+    def values(self):
+        from jedi.inference.compiled import builtin_from_name
+        names = []
+        needs_type_completions, dir_infos = self.compiled_value.access_handle.get_dir_infos()
+        # We could use `unsafe` here as well, especially as a parameter to
+        # get_dir_infos. But this would lead to a lot of property executions
+        # that are probably not wanted. The drawback for this is that we
+        # have a different name for `get` and `values`. For `get` we always
+        # execute.
+        for name in dir_infos:
+            names += self._get(
+                name,
+                lambda name, unsafe: dir_infos[name],
+                lambda name: name in dir_infos,
+            )
+
+        # ``dir`` doesn't include the type names.
+        if not self.is_instance and needs_type_completions:
+            for filter in builtin_from_name(self._inference_state, u'type').get_filters():
+                names += filter.values()
+        return names
+
+    def _create_name(self, name):
+        return CompiledName(
+            self._inference_state,
+            self.compiled_value,
+            name
+        )
+
+    def __repr__(self):
+        return "<%s: %s>" % (self.__class__.__name__, self.compiled_value)
+
+
+docstr_defaults = {
+    'floating point number': u'float',
+    'character': u'str',
+    'integer': u'int',
+    'dictionary': u'dict',
+    'string': u'str',
+}
+
+
+def _parse_function_doc(doc):
+    """
+    Takes a function and returns the params and return value as a tuple.
+    This is nothing more than a docstring parser.
+
+    TODO docstrings like utime(path, (atime, mtime)) and a(b [, b]) -> None
+    TODO docstrings like 'tuple of integers'
+    """
+    doc = force_unicode(doc)
+    # parse round parentheses: def func(a, (b,c))
+    try:
+        count = 0
+        start = doc.index('(')
+        for i, s in enumerate(doc[start:]):
+            if s == '(':
+                count += 1
+            elif s == ')':
+                count -= 1
+            if count == 0:
+                end = start + i
+                break
+        param_str = doc[start + 1:end]
+    except (ValueError, UnboundLocalError):
+        # ValueError for doc.index
+        # UnboundLocalError for undefined end in last line
+        debug.dbg('no brackets found - no param')
+        end = 0
+        param_str = u''
+    else:
+        # remove square brackets, that show an optional param ( = None)
+        def change_options(m):
+            args = m.group(1).split(',')
+            for i, a in enumerate(args):
+                if a and '=' not in a:
+                    args[i] += '=None'
+            return ','.join(args)
+
+        while True:
+            param_str, changes = re.subn(r' ?\[([^\[\]]+)\]',
+                                         change_options, param_str)
+            if changes == 0:
+                break
+    param_str = param_str.replace('-', '_')  # see: isinstance.__doc__
+
+    # parse return value
+    r = re.search(u'-[>-]* ', doc[end:end + 7])
+    if r is None:
+        ret = u''
+    else:
+        index = end + r.end()
+        # get result type, which can contain newlines
+        pattern = re.compile(r'(,\n|[^\n-])+')
+        ret_str = pattern.match(doc, index).group(0).strip()
+        # New object -> object()
+        ret_str = re.sub(r'[nN]ew (.*)', r'\1()', ret_str)
+
+        ret = docstr_defaults.get(ret_str, ret_str)
+
+    return param_str, ret
+
+
+def create_from_name(inference_state, compiled_value, name):
+    access_paths = compiled_value.access_handle.getattr_paths(name, default=None)
+
+    value = None
+    for access_path in access_paths:
+        value = create_cached_compiled_value(
+            inference_state,
+            access_path,
+            parent_context=None if value is None else value.as_context(),
+        )
+    return value
+
+
+def _normalize_create_args(func):
+    """The cache doesn't care about keyword vs. normal args."""
+    def wrapper(inference_state, obj, parent_context=None):
+        return func(inference_state, obj, parent_context)
+    return wrapper
+
+
+def create_from_access_path(inference_state, access_path):
+    value = None
+    for name, access in access_path.accesses:
+        value = create_cached_compiled_value(
+            inference_state,
+            access,
+            parent_context=None if value is None else value.as_context()
+        )
+    return value
+
+
+@_normalize_create_args
+@inference_state_function_cache()
+def create_cached_compiled_value(inference_state, access_handle, parent_context):
+    assert not isinstance(parent_context, CompiledValue)
+    if parent_context is None:
+        cls = CompiledModule
+    else:
+        cls = CompiledValue
+    return cls(inference_state, access_handle, parent_context)

venv/Lib/site-packages/jedi/inference/context.py

@@ -0,0 +1,500 @@
+from abc import abstractmethod
+from contextlib import contextmanager
+
+from parso.tree import search_ancestor
+from parso.python.tree import Name
+
+from jedi.inference.filters import ParserTreeFilter, MergedFilter, \
+    GlobalNameFilter
+from jedi.inference.names import AnonymousParamName, TreeNameDefinition
+from jedi.inference.base_value import NO_VALUES, ValueSet
+from jedi.parser_utils import get_parent_scope
+from jedi import debug
+from jedi import parser_utils
+
+
+class AbstractContext(object):
+    # Must be defined: inference_state and tree_node and parent_context as an attribute/property
+
+    def __init__(self, inference_state):
+        self.inference_state = inference_state
+        self.predefined_names = {}
+
+    @abstractmethod
+    def get_filters(self, until_position=None, origin_scope=None):
+        raise NotImplementedError
+
+    def goto(self, name_or_str, position):
+        from jedi.inference import finder
+        filters = _get_global_filters_for_name(
+            self, name_or_str if isinstance(name_or_str, Name) else None, position,
+        )
+        names = finder.filter_name(filters, name_or_str)
+        debug.dbg('context.goto %s in (%s): %s', name_or_str, self, names)
+        return names
+
+    def py__getattribute__(self, name_or_str, name_context=None, position=None,
+                           analysis_errors=True):
+        """
+        :param position: Position of the last statement -> tuple of line, column
+        """
+        if name_context is None:
+            name_context = self
+        names = self.goto(name_or_str, position)
+
+        string_name = name_or_str.value if isinstance(name_or_str, Name) else name_or_str
+
+        # This paragraph is currently needed for proper branch type inference
+        # (static analysis).
+        found_predefined_types = None
+        if self.predefined_names and isinstance(name_or_str, Name):
+            node = name_or_str
+            while node is not None and not parser_utils.is_scope(node):
+                node = node.parent
+                if node.type in ("if_stmt", "for_stmt", "comp_for", 'sync_comp_for'):
+                    try:
+                        name_dict = self.predefined_names[node]
+                        types = name_dict[string_name]
+                    except KeyError:
+                        continue
+                    else:
+                        found_predefined_types = types
+                        break
+        if found_predefined_types is not None and names:
+            from jedi.inference import flow_analysis
+            check = flow_analysis.reachability_check(
+                context=self,
+                value_scope=self.tree_node,
+                node=name_or_str,
+            )
+            if check is flow_analysis.UNREACHABLE:
+                values = NO_VALUES
+            else:
+                values = found_predefined_types
+        else:
+            values = ValueSet.from_sets(name.infer() for name in names)
+
+        if not names and not values and analysis_errors:
+            if isinstance(name_or_str, Name):
+                from jedi.inference import analysis
+                message = ("NameError: name '%s' is not defined." % string_name)
+                analysis.add(name_context, 'name-error', name_or_str, message)
+
+        debug.dbg('context.names_to_types: %s -> %s', names, values)
+        if values:
+            return values
+        return self._check_for_additional_knowledge(name_or_str, name_context, position)
+
+    def _check_for_additional_knowledge(self, name_or_str, name_context, position):
+        name_context = name_context or self
+        # Add isinstance and other if/assert knowledge.
+        if isinstance(name_or_str, Name) and not name_context.is_instance():
+            flow_scope = name_or_str
+            base_nodes = [name_context.tree_node]
+
+            if any(b.type in ('comp_for', 'sync_comp_for') for b in base_nodes):
+                return NO_VALUES
+            from jedi.inference.finder import check_flow_information
+            while True:
+                flow_scope = get_parent_scope(flow_scope, include_flows=True)
+                n = check_flow_information(name_context, flow_scope,
+                                           name_or_str, position)
+                if n is not None:
+                    return n
+                if flow_scope in base_nodes:
+                    break
+        return NO_VALUES
+
+    def get_root_context(self):
+        parent_context = self.parent_context
+        if parent_context is None:
+            return self
+        return parent_context.get_root_context()
+
+    def is_module(self):
+        return False
+
+    def is_builtins_module(self):
+        return False
+
+    def is_class(self):
+        return False
+
+    def is_stub(self):
+        return False
+
+    def is_instance(self):
+        return False
+
+    def is_compiled(self):
+        return False
+
+    def is_bound_method(self):
+        return False
+
+    @abstractmethod
+    def py__name__(self):
+        raise NotImplementedError
+
+    def get_value(self):
+        raise NotImplementedError
+
+    @property
+    def name(self):
+        return None
+
+    def get_qualified_names(self):
+        return ()
+
+    def py__doc__(self):
+        return ''
+
+    @contextmanager
+    def predefine_names(self, flow_scope, dct):
+        predefined = self.predefined_names
+        predefined[flow_scope] = dct
+        try:
+            yield
+        finally:
+            del predefined[flow_scope]
+
+
+class ValueContext(AbstractContext):
+    """
+    Should be defined, otherwise the API returns empty types.
+    """
+    def __init__(self, value):
+        super(ValueContext, self).__init__(value.inference_state)
+        self._value = value
+
+    @property
+    def tree_node(self):
+        return self._value.tree_node
+
+    @property
+    def parent_context(self):
+        return self._value.parent_context
+
+    def is_module(self):
+        return self._value.is_module()
+
+    def is_builtins_module(self):
+        return self._value == self.inference_state.builtins_module
+
+    def is_class(self):
+        return self._value.is_class()
+
+    def is_stub(self):
+        return self._value.is_stub()
+
+    def is_instance(self):
+        return self._value.is_instance()
+
+    def is_compiled(self):
+        return self._value.is_compiled()
+
+    def is_bound_method(self):
+        return self._value.is_bound_method()
+
+    def py__name__(self):
+        return self._value.py__name__()
+
+    @property
+    def name(self):
+        return self._value.name
+
+    def get_qualified_names(self):
+        return self._value.get_qualified_names()
+
+    def py__doc__(self):
+        return self._value.py__doc__()
+
+    def get_value(self):
+        return self._value
+
+    def __repr__(self):
+        return '%s(%s)' % (self.__class__.__name__, self._value)
+
+
+class TreeContextMixin(object):
+    def infer_node(self, node):
+        from jedi.inference.syntax_tree import infer_node
+        return infer_node(self, node)
+
+    def create_value(self, node):
+        from jedi.inference import value
+
+        if node == self.tree_node:
+            assert self.is_module()
+            return self.get_value()
+
+        parent_context = self.create_context(node)
+
+        if node.type in ('funcdef', 'lambdef'):
+            func = value.FunctionValue.from_context(parent_context, node)
+            if parent_context.is_class():
+                class_value = parent_context.parent_context.create_value(parent_context.tree_node)
+                instance = value.AnonymousInstance(
+                    self.inference_state, parent_context.parent_context, class_value)
+                func = value.BoundMethod(
+                    instance=instance,
+                    class_context=class_value.as_context(),
+                    function=func
+                )
+            return func
+        elif node.type == 'classdef':
+            return value.ClassValue(self.inference_state, parent_context, node)
+        else:
+            raise NotImplementedError("Probably shouldn't happen: %s" % node)
+
+    def create_context(self, node):
+        def from_scope_node(scope_node, is_nested=True):
+            if scope_node == self.tree_node:
+                return self
+
+            if scope_node.type in ('funcdef', 'lambdef', 'classdef'):
+                return self.create_value(scope_node).as_context()
+            elif scope_node.type in ('comp_for', 'sync_comp_for'):
+                parent_scope = parser_utils.get_parent_scope(scope_node)
+                parent_context = from_scope_node(parent_scope)
+                if node.start_pos >= scope_node.children[-1].start_pos:
+                    return parent_context
+                return CompForContext(parent_context, scope_node)
+            raise Exception("There's a scope that was not managed: %s" % scope_node)
+
+        def parent_scope(node):
+            while True:
+                node = node.parent
+
+                if parser_utils.is_scope(node):
+                    return node
+                elif node.type in ('argument', 'testlist_comp'):
+                    if node.children[1].type in ('comp_for', 'sync_comp_for'):
+                        return node.children[1]
+                elif node.type == 'dictorsetmaker':
+                    for n in node.children[1:4]:
+                        # In dictionaries it can be pretty much anything.
+                        if n.type in ('comp_for', 'sync_comp_for'):
+                            return n
+
+        scope_node = parent_scope(node)
+        if scope_node.type in ('funcdef', 'classdef'):
+            colon = scope_node.children[scope_node.children.index(':')]
+            if node.start_pos < colon.start_pos:
+                parent = node.parent
+                if not (parent.type == 'param' and parent.name == node):
+                    scope_node = parent_scope(scope_node)
+        return from_scope_node(scope_node, is_nested=True)
+
+    def create_name(self, tree_name):
+        definition = tree_name.get_definition()
+        if definition and definition.type == 'param' and definition.name == tree_name:
+            funcdef = search_ancestor(definition, 'funcdef', 'lambdef')
+            func = self.create_value(funcdef)
+            return AnonymousParamName(func, tree_name)
+        else:
+            context = self.create_context(tree_name)
+            return TreeNameDefinition(context, tree_name)
+
+
+class FunctionContext(TreeContextMixin, ValueContext):
+    def get_filters(self, until_position=None, origin_scope=None):
+        yield ParserTreeFilter(
+            self.inference_state,
+            parent_context=self,
+            until_position=until_position,
+            origin_scope=origin_scope
+        )
+
+
+class ModuleContext(TreeContextMixin, ValueContext):
+    def py__file__(self):
+        return self._value.py__file__()
+
+    def get_filters(self, until_position=None, origin_scope=None):
+        filters = self._value.get_filters(origin_scope)
+        # Skip the first filter and replace it.
+        next(filters, None)
+        yield MergedFilter(
+            ParserTreeFilter(
+                parent_context=self,
+                until_position=until_position,
+                origin_scope=origin_scope
+            ),
+            self.get_global_filter(),
+        )
+        for f in filters:  # Python 2...
+            yield f
+
+    def get_global_filter(self):
+        return GlobalNameFilter(self, self.tree_node)
+
+    @property
+    def string_names(self):
+        return self._value.string_names
+
+    @property
+    def code_lines(self):
+        return self._value.code_lines
+
+    def get_value(self):
+        """
+        This is the only function that converts a context back to a value.
+        This is necessary for stub -> python conversion and vice versa. However
+        this method shouldn't be moved to AbstractContext.
+        """
+        return self._value
+
+
+class NamespaceContext(TreeContextMixin, ValueContext):
+    def get_filters(self, until_position=None, origin_scope=None):
+        return self._value.get_filters()
+
+    def get_value(self):
+        return self._value
+
+    @property
+    def string_names(self):
+        return self._value.string_names
+
+    def py__file__(self):
+        return self._value.py__file__()
+
+
+class ClassContext(TreeContextMixin, ValueContext):
+    def get_filters(self, until_position=None, origin_scope=None):
+        yield self.get_global_filter(until_position, origin_scope)
+
+    def get_global_filter(self, until_position=None, origin_scope=None):
+        return ParserTreeFilter(
+            parent_context=self,
+            until_position=until_position,
+            origin_scope=origin_scope
+        )
+
+
+class CompForContext(TreeContextMixin, AbstractContext):
+    def __init__(self, parent_context, comp_for):
+        super(CompForContext, self).__init__(parent_context.inference_state)
+        self.tree_node = comp_for
+        self.parent_context = parent_context
+
+    def get_filters(self, until_position=None, origin_scope=None):
+        yield ParserTreeFilter(self)
+
+    def get_value(self):
+        return None
+
+    def py__name__(self):
+        return '<comprehension context>'
+
+    def __repr__(self):
+        return '%s(%s)' % (self.__class__.__name__, self.tree_node)
+
+
+class CompiledContext(ValueContext):
+    def get_filters(self, until_position=None, origin_scope=None):
+        return self._value.get_filters()
+
+
+class CompiledModuleContext(CompiledContext):
+    code_lines = None
+
+    def get_value(self):
+        return self._value
+
+    @property
+    def string_names(self):
+        return self._value.string_names
+
+    def py__file__(self):
+        return self._value.py__file__()
+
+
+def _get_global_filters_for_name(context, name_or_none, position):
+    # For functions and classes the defaults don't belong to the
+    # function and get inferred in the value before the function. So
+    # make sure to exclude the function/class name.
+    if name_or_none is not None:
+        ancestor = search_ancestor(name_or_none, 'funcdef', 'classdef', 'lambdef')
+        lambdef = None
+        if ancestor == 'lambdef':
+            # For lambdas it's even more complicated since parts will
+            # be inferred later.
+            lambdef = ancestor
+            ancestor = search_ancestor(name_or_none, 'funcdef', 'classdef')
+        if ancestor is not None:
+            colon = ancestor.children[-2]
+            if position is not None and position < colon.start_pos:
+                if lambdef is None or position < lambdef.children[-2].start_pos:
+                    position = ancestor.start_pos
+
+    return get_global_filters(context, position, name_or_none)
+
+
+def get_global_filters(context, until_position, origin_scope):
+    """
+    Returns all filters in order of priority for name resolution.
+
+    For global name lookups. The filters will handle name resolution
+    themselves, but here we gather possible filters downwards.
+
+    >>> from jedi._compatibility import u, no_unicode_pprint
+    >>> from jedi import Script
+    >>> script = Script(u('''
+    ... x = ['a', 'b', 'c']
+    ... def func():
+    ...     y = None
+    ... '''))
+    >>> module_node = script._module_node
+    >>> scope = next(module_node.iter_funcdefs())
+    >>> scope
+    <Function: func@3-5>
+    >>> context = script._get_module_context().create_context(scope)
+    >>> filters = list(get_global_filters(context, (4, 0), None))
+
+    First we get the names from the function scope.
+
+    >>> no_unicode_pprint(filters[0])  # doctest: +ELLIPSIS
+    MergedFilter(<ParserTreeFilter: ...>, <GlobalNameFilter: ...>)
+    >>> sorted(str(n) for n in filters[0].values())  # doctest: +NORMALIZE_WHITESPACE
+    ['<TreeNameDefinition: string_name=func start_pos=(3, 4)>',
+     '<TreeNameDefinition: string_name=x start_pos=(2, 0)>']
+    >>> filters[0]._filters[0]._until_position
+    (4, 0)
+    >>> filters[0]._filters[1]._until_position
+
+    Then it yields the names from one level "lower". In this example, this is
+    the module scope (including globals).
+    As a side note, you can see, that the position in the filter is None on the
+    globals filter, because there the whole module is searched.
+
+    >>> list(filters[1].values())  # package modules -> Also empty.
+    []
+    >>> sorted(name.string_name for name in filters[2].values())  # Module attributes
+    ['__doc__', '__name__', '__package__']
+
+    Finally, it yields the builtin filter, if `include_builtin` is
+    true (default).
+
+    >>> list(filters[3].values())  # doctest: +ELLIPSIS
+    [...]
+    """
+    base_context = context
+    from jedi.inference.value.function import BaseFunctionExecutionContext
+    while context is not None:
+        # Names in methods cannot be resolved within the class.
+        for filter in context.get_filters(
+                until_position=until_position,
+                origin_scope=origin_scope):
+            yield filter
+        if isinstance(context, (BaseFunctionExecutionContext, ModuleContext)):
+            # The position should be reset if the current scope is a function.
+            until_position = None
+
+        context = context.parent_context
+
+    b = next(base_context.inference_state.builtins_module.get_filters(), None)
+    assert b is not None
+    # Add builtins to the global scope.
+    yield b

venv/Lib/site-packages/jedi/inference/docstrings.py

@@ -0,0 +1,307 @@
+"""
+Docstrings are another source of information for functions and classes.
+:mod:`jedi.inference.dynamic_params` tries to find all executions of functions,
+while the docstring parsing is much easier. There are three different types of
+docstrings that |jedi| understands:
+
+- `Sphinx <http://sphinx-doc.org/markup/desc.html#info-field-lists>`_
+- `Epydoc <http://epydoc.sourceforge.net/manual-fields.html>`_
+- `Numpydoc <https://github.com/numpy/numpy/blob/master/doc/HOWTO_DOCUMENT.rst.txt>`_
+
+For example, the sphinx annotation ``:type foo: str`` clearly states that the
+type of ``foo`` is ``str``.
+
+As an addition to parameter searching, this module also provides return
+annotations.
+"""
+
+import re
+import warnings
+from textwrap import dedent
+
+from parso import parse, ParserSyntaxError
+
+from jedi._compatibility import u
+from jedi import debug
+from jedi.common import indent_block
+from jedi.inference.cache import inference_state_method_cache
+from jedi.inference.base_value import iterator_to_value_set, ValueSet, \
+    NO_VALUES
+from jedi.inference.lazy_value import LazyKnownValues
+
+
+DOCSTRING_PARAM_PATTERNS = [
+    r'\s*:type\s+%s:\s*([^\n]+)',  # Sphinx
+    r'\s*:param\s+(\w+)\s+%s:[^\n]*',  # Sphinx param with type
+    r'\s*@type\s+%s:\s*([^\n]+)',  # Epydoc
+]
+
+DOCSTRING_RETURN_PATTERNS = [
+    re.compile(r'\s*:rtype:\s*([^\n]+)', re.M),  # Sphinx
+    re.compile(r'\s*@rtype:\s*([^\n]+)', re.M),  # Epydoc
+]
+
+REST_ROLE_PATTERN = re.compile(r':[^`]+:`([^`]+)`')
+
+
+_numpy_doc_string_cache = None
+
+
+def _get_numpy_doc_string_cls():
+    global _numpy_doc_string_cache
+    if isinstance(_numpy_doc_string_cache, (ImportError, SyntaxError)):
+        raise _numpy_doc_string_cache
+    from numpydoc.docscrape import NumpyDocString
+    _numpy_doc_string_cache = NumpyDocString
+    return _numpy_doc_string_cache
+
+
+def _search_param_in_numpydocstr(docstr, param_str):
+    """Search `docstr` (in numpydoc format) for type(-s) of `param_str`."""
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        try:
+            # This is a non-public API. If it ever changes we should be
+            # prepared and return gracefully.
+            params = _get_numpy_doc_string_cls()(docstr)._parsed_data['Parameters']
+        except Exception:
+            return []
+    for p_name, p_type, p_descr in params:
+        if p_name == param_str:
+            m = re.match(r'([^,]+(,[^,]+)*?)(,[ ]*optional)?$', p_type)
+            if m:
+                p_type = m.group(1)
+            return list(_expand_typestr(p_type))
+    return []
+
+
+def _search_return_in_numpydocstr(docstr):
+    """
+    Search `docstr` (in numpydoc format) for type(-s) of function returns.
+    """
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        try:
+            doc = _get_numpy_doc_string_cls()(docstr)
+        except Exception:
+            return
+    try:
+        # This is a non-public API. If it ever changes we should be
+        # prepared and return gracefully.
+        returns = doc._parsed_data['Returns']
+        returns += doc._parsed_data['Yields']
+    except Exception:
+        return
+    for r_name, r_type, r_descr in returns:
+        # Return names are optional and if so the type is in the name
+        if not r_type:
+            r_type = r_name
+        for type_ in _expand_typestr(r_type):
+            yield type_
+
+
+def _expand_typestr(type_str):
+    """
+    Attempts to interpret the possible types in `type_str`
+    """
+    # Check if alternative types are specified with 'or'
+    if re.search(r'\bor\b', type_str):
+        for t in type_str.split('or'):
+            yield t.split('of')[0].strip()
+    # Check if like "list of `type`" and set type to list
+    elif re.search(r'\bof\b', type_str):
+        yield type_str.split('of')[0]
+    # Check if type has is a set of valid literal values eg: {'C', 'F', 'A'}
+    elif type_str.startswith('{'):
+        node = parse(type_str, version='3.7').children[0]
+        if node.type == 'atom':
+            for leaf in node.children[1].children:
+                if leaf.type == 'number':
+                    if '.' in leaf.value:
+                        yield 'float'
+                    else:
+                        yield 'int'
+                elif leaf.type == 'string':
+                    if 'b' in leaf.string_prefix.lower():
+                        yield 'bytes'
+                    else:
+                        yield 'str'
+                # Ignore everything else.
+
+    # Otherwise just work with what we have.
+    else:
+        yield type_str
+
+
+def _search_param_in_docstr(docstr, param_str):
+    """
+    Search `docstr` for type(-s) of `param_str`.
+
+    >>> _search_param_in_docstr(':type param: int', 'param')
+    ['int']
+    >>> _search_param_in_docstr('@type param: int', 'param')
+    ['int']
+    >>> _search_param_in_docstr(
+    ...   ':type param: :class:`threading.Thread`', 'param')
+    ['threading.Thread']
+    >>> bool(_search_param_in_docstr('no document', 'param'))
+    False
+    >>> _search_param_in_docstr(':param int param: some description', 'param')
+    ['int']
+
+    """
+    # look at #40 to see definitions of those params
+    patterns = [re.compile(p % re.escape(param_str))
+                for p in DOCSTRING_PARAM_PATTERNS]
+    for pattern in patterns:
+        match = pattern.search(docstr)
+        if match:
+            return [_strip_rst_role(match.group(1))]
+
+    return _search_param_in_numpydocstr(docstr, param_str)
+
+
+def _strip_rst_role(type_str):
+    """
+    Strip off the part looks like a ReST role in `type_str`.
+
+    >>> _strip_rst_role(':class:`ClassName`')  # strip off :class:
+    'ClassName'
+    >>> _strip_rst_role(':py:obj:`module.Object`')  # works with domain
+    'module.Object'
+    >>> _strip_rst_role('ClassName')  # do nothing when not ReST role
+    'ClassName'
+
+    See also:
+    http://sphinx-doc.org/domains.html#cross-referencing-python-objects
+
+    """
+    match = REST_ROLE_PATTERN.match(type_str)
+    if match:
+        return match.group(1)
+    else:
+        return type_str
+
+
+def _infer_for_statement_string(module_context, string):
+    code = dedent(u("""
+    def pseudo_docstring_stuff():
+        '''
+        Create a pseudo function for docstring statements.
+        Need this docstring so that if the below part is not valid Python this
+        is still a function.
+        '''
+    {}
+    """))
+    if string is None:
+        return []
+
+    for element in re.findall(r'((?:\w+\.)*\w+)\.', string):
+        # Try to import module part in dotted name.
+        # (e.g., 'threading' in 'threading.Thread').
+        string = 'import %s\n' % element + string
+
+    # Take the default grammar here, if we load the Python 2.7 grammar here, it
+    # will be impossible to use `...` (Ellipsis) as a token. Docstring types
+    # don't need to conform with the current grammar.
+    debug.dbg('Parse docstring code %s', string, color='BLUE')
+    grammar = module_context.inference_state.latest_grammar
+    try:
+        module = grammar.parse(code.format(indent_block(string)), error_recovery=False)
+    except ParserSyntaxError:
+        return []
+    try:
+        funcdef = next(module.iter_funcdefs())
+        # First pick suite, then simple_stmt and then the node,
+        # which is also not the last item, because there's a newline.
+        stmt = funcdef.children[-1].children[-1].children[-2]
+    except (AttributeError, IndexError):
+        return []
+
+    if stmt.type not in ('name', 'atom', 'atom_expr'):
+        return []
+
+    from jedi.inference.value import FunctionValue
+    function_value = FunctionValue(
+        module_context.inference_state,
+        module_context,
+        funcdef
+    )
+    func_execution_context = function_value.as_context()
+    # Use the module of the param.
+    # TODO this module is not the module of the param in case of a function
+    # call. In that case it's the module of the function call.
+    # stuffed with content from a function call.
+    return list(_execute_types_in_stmt(func_execution_context, stmt))
+
+
+def _execute_types_in_stmt(module_context, stmt):
+    """
+    Executing all types or general elements that we find in a statement. This
+    doesn't include tuple, list and dict literals, because the stuff they
+    contain is executed. (Used as type information).
+    """
+    definitions = module_context.infer_node(stmt)
+    return ValueSet.from_sets(
+        _execute_array_values(module_context.inference_state, d)
+        for d in definitions
+    )
+
+
+def _execute_array_values(inference_state, array):
+    """
+    Tuples indicate that there's not just one return value, but the listed
+    ones.  `(str, int)` means that it returns a tuple with both types.
+    """
+    from jedi.inference.value.iterable import SequenceLiteralValue, FakeTuple, FakeList
+    if isinstance(array, SequenceLiteralValue) and array.array_type in ('tuple', 'list'):
+        values = []
+        for lazy_value in array.py__iter__():
+            objects = ValueSet.from_sets(
+                _execute_array_values(inference_state, typ)
+                for typ in lazy_value.infer()
+            )
+            values.append(LazyKnownValues(objects))
+        cls = FakeTuple if array.array_type == 'tuple' else FakeList
+        return {cls(inference_state, values)}
+    else:
+        return array.execute_annotation()
+
+
+@inference_state_method_cache()
+def infer_param(function_value, param):
+    def infer_docstring(docstring):
+        return ValueSet(
+            p
+            for param_str in _search_param_in_docstr(docstring, param.name.value)
+            for p in _infer_for_statement_string(module_context, param_str)
+        )
+    module_context = function_value.get_root_context()
+    func = param.get_parent_function()
+    if func.type == 'lambdef':
+        return NO_VALUES
+
+    types = infer_docstring(function_value.py__doc__())
+    if function_value.is_bound_method() \
+            and function_value.py__name__() == '__init__':
+        types |= infer_docstring(function_value.class_context.py__doc__())
+
+    debug.dbg('Found param types for docstring: %s', types, color='BLUE')
+    return types
+
+
+@inference_state_method_cache()
+@iterator_to_value_set
+def infer_return_types(function_value):
+    def search_return_in_docstr(code):
+        for p in DOCSTRING_RETURN_PATTERNS:
+            match = p.search(code)
+            if match:
+                yield _strip_rst_role(match.group(1))
+        # Check for numpy style return hint
+        for type_ in _search_return_in_numpydocstr(code):
+            yield type_
+
+    for type_str in search_return_in_docstr(function_value.py__doc__()):
+        for value in _infer_for_statement_string(function_value.get_root_context(), type_str):
+            yield value

venv/Lib/site-packages/jedi/inference/dynamic_params.py

@@ -0,0 +1,226 @@
+"""
+One of the really important features of |jedi| is to have an option to
+understand code like this::
+
+    def foo(bar):
+        bar. # completion here
+    foo(1)
+
+There's no doubt wheter bar is an ``int`` or not, but if there's also a call
+like ``foo('str')``, what would happen? Well, we'll just show both. Because
+that's what a human would expect.
+
+It works as follows:
+
+- |Jedi| sees a param
+- search for function calls named ``foo``
+- execute these calls and check the input.
+"""
+
+from jedi import settings
+from jedi import debug
+from jedi.parser_utils import get_parent_scope
+from jedi.inference.cache import inference_state_method_cache
+from jedi.inference.arguments import TreeArguments
+from jedi.inference.param import get_executed_param_names
+from jedi.inference.helpers import is_stdlib_path
+from jedi.inference.utils import to_list
+from jedi.inference.value import instance
+from jedi.inference.base_value import ValueSet, NO_VALUES
+from jedi.inference.references import get_module_contexts_containing_name
+from jedi.inference import recursion
+
+
+MAX_PARAM_SEARCHES = 20
+
+
+def _avoid_recursions(func):
+    def wrapper(function_value, param_index):
+        inf = function_value.inference_state
+        with recursion.execution_allowed(inf, function_value.tree_node) as allowed:
+            # We need to catch recursions that may occur, because an
+            # anonymous functions can create an anonymous parameter that is
+            # more or less self referencing.
+            if allowed:
+                inf.dynamic_params_depth += 1
+                try:
+                    return func(function_value, param_index)
+                finally:
+                    inf.dynamic_params_depth -= 1
+            return NO_VALUES
+    return wrapper
+
+
+@debug.increase_indent
+@_avoid_recursions
+def dynamic_param_lookup(function_value, param_index):
+    """
+    A dynamic search for param values. If you try to complete a type:
+
+    >>> def func(foo):
+    ...     foo
+    >>> func(1)
+    >>> func("")
+
+    It is not known what the type ``foo`` without analysing the whole code. You
+    have to look for all calls to ``func`` to find out what ``foo`` possibly
+    is.
+    """
+    funcdef = function_value.tree_node
+
+    if not settings.dynamic_params:
+        return NO_VALUES
+
+    path = function_value.get_root_context().py__file__()
+    if path is not None and is_stdlib_path(path):
+        # We don't want to search for references in the stdlib. Usually people
+        # don't work with it (except if you are a core maintainer, sorry).
+        # This makes everything slower. Just disable it and run the tests,
+        # you will see the slowdown, especially in 3.6.
+        return NO_VALUES
+
+    if funcdef.type == 'lambdef':
+        string_name = _get_lambda_name(funcdef)
+        if string_name is None:
+            return NO_VALUES
+    else:
+        string_name = funcdef.name.value
+    debug.dbg('Dynamic param search in %s.', string_name, color='MAGENTA')
+
+    module_context = function_value.get_root_context()
+    arguments_list = _search_function_arguments(module_context, funcdef, string_name)
+    values = ValueSet.from_sets(
+        get_executed_param_names(
+            function_value, arguments
+        )[param_index].infer()
+        for arguments in arguments_list
+    )
+    debug.dbg('Dynamic param result finished', color='MAGENTA')
+    return values
+
+
+@inference_state_method_cache(default=None)
+@to_list
+def _search_function_arguments(module_context, funcdef, string_name):
+    """
+    Returns a list of param names.
+    """
+    compare_node = funcdef
+    if string_name == '__init__':
+        cls = get_parent_scope(funcdef)
+        if cls.type == 'classdef':
+            string_name = cls.name.value
+            compare_node = cls
+
+    found_arguments = False
+    i = 0
+    inference_state = module_context.inference_state
+
+    if settings.dynamic_params_for_other_modules:
+        module_contexts = get_module_contexts_containing_name(
+            inference_state, [module_context], string_name,
+            # Limit the amounts of files to be opened massively.
+            limit_reduction=5,
+        )
+    else:
+        module_contexts = [module_context]
+
+    for for_mod_context in module_contexts:
+        for name, trailer in _get_potential_nodes(for_mod_context, string_name):
+            i += 1
+
+            # This is a simple way to stop Jedi's dynamic param recursion
+            # from going wild: The deeper Jedi's in the recursion, the less
+            # code should be inferred.
+            if i * inference_state.dynamic_params_depth > MAX_PARAM_SEARCHES:
+                return
+
+            random_context = for_mod_context.create_context(name)
+            for arguments in _check_name_for_execution(
+                    inference_state, random_context, compare_node, name, trailer):
+                found_arguments = True
+                yield arguments
+
+        # If there are results after processing a module, we're probably
+        # good to process. This is a speed optimization.
+        if found_arguments:
+            return
+
+
+def _get_lambda_name(node):
+    stmt = node.parent
+    if stmt.type == 'expr_stmt':
+        first_operator = next(stmt.yield_operators(), None)
+        if first_operator == '=':
+            first = stmt.children[0]
+            if first.type == 'name':
+                return first.value
+
+    return None
+
+
+def _get_potential_nodes(module_value, func_string_name):
+    try:
+        names = module_value.tree_node.get_used_names()[func_string_name]
+    except KeyError:
+        return
+
+    for name in names:
+        bracket = name.get_next_leaf()
+        trailer = bracket.parent
+        if trailer.type == 'trailer' and bracket == '(':
+            yield name, trailer
+
+
+def _check_name_for_execution(inference_state, context, compare_node, name, trailer):
+    from jedi.inference.value.function import BaseFunctionExecutionContext
+
+    def create_args(value):
+        arglist = trailer.children[1]
+        if arglist == ')':
+            arglist = None
+        args = TreeArguments(inference_state, context, arglist, trailer)
+        from jedi.inference.value.instance import InstanceArguments
+        if value.tree_node.type == 'classdef':
+            created_instance = instance.TreeInstance(
+                inference_state,
+                value.parent_context,
+                value,
+                args
+            )
+            return InstanceArguments(created_instance, args)
+        else:
+            if value.is_bound_method():
+                args = InstanceArguments(value.instance, args)
+            return args
+
+    for value in inference_state.infer(context, name):
+        value_node = value.tree_node
+        if compare_node == value_node:
+            yield create_args(value)
+        elif isinstance(value.parent_context, BaseFunctionExecutionContext) \
+                and compare_node.type == 'funcdef':
+            # Here we're trying to find decorators by checking the first
+            # parameter. It's not very generic though. Should find a better
+            # solution that also applies to nested decorators.
+            param_names = value.parent_context.get_param_names()
+            if len(param_names) != 1:
+                continue
+            values = param_names[0].infer()
+            if [v.tree_node for v in values] == [compare_node]:
+                # Found a decorator.
+                module_context = context.get_root_context()
+                execution_context = value.as_context(create_args(value))
+                potential_nodes = _get_potential_nodes(module_context, param_names[0].string_name)
+                for name, trailer in potential_nodes:
+                    if value_node.start_pos < name.start_pos < value_node.end_pos:
+                        random_context = execution_context.create_context(name)
+                        iterator = _check_name_for_execution(
+                            inference_state,
+                            random_context,
+                            compare_node,
+                            name,
+                            trailer
+                        )
+                        for arguments in iterator:
+                            yield arguments

venv/Lib/site-packages/jedi/inference/filters.py

@@ -0,0 +1,353 @@
+"""
+Filters are objects that you can use to filter names in different scopes. They
+are needed for name resolution.
+"""
+from abc import abstractmethod
+import weakref
+
+from parso.tree import search_ancestor
+
+from jedi._compatibility import use_metaclass
+from jedi.inference import flow_analysis
+from jedi.inference.base_value import ValueSet, ValueWrapper, \
+    LazyValueWrapper
+from jedi.parser_utils import get_cached_parent_scope
+from jedi.inference.utils import to_list
+from jedi.inference.names import TreeNameDefinition, ParamName, \
+    AnonymousParamName, AbstractNameDefinition
+
+_definition_name_cache = weakref.WeakKeyDictionary()
+
+
+class AbstractFilter(object):
+    _until_position = None
+
+    def _filter(self, names):
+        if self._until_position is not None:
+            return [n for n in names if n.start_pos < self._until_position]
+        return names
+
+    @abstractmethod
+    def get(self, name):
+        raise NotImplementedError
+
+    @abstractmethod
+    def values(self):
+        raise NotImplementedError
+
+
+class FilterWrapper(object):
+    name_wrapper_class = None
+
+    def __init__(self, wrapped_filter):
+        self._wrapped_filter = wrapped_filter
+
+    def wrap_names(self, names):
+        return [self.name_wrapper_class(name) for name in names]
+
+    def get(self, name):
+        return self.wrap_names(self._wrapped_filter.get(name))
+
+    def values(self):
+        return self.wrap_names(self._wrapped_filter.values())
+
+
+def _get_definition_names(used_names, name_key):
+    try:
+        for_module = _definition_name_cache[used_names]
+    except KeyError:
+        for_module = _definition_name_cache[used_names] = {}
+
+    try:
+        return for_module[name_key]
+    except KeyError:
+        names = used_names.get(name_key, ())
+        result = for_module[name_key] = tuple(
+            name for name in names if name.is_definition(include_setitem=True)
+        )
+        return result
+
+
+class AbstractUsedNamesFilter(AbstractFilter):
+    name_class = TreeNameDefinition
+
+    def __init__(self, parent_context, parser_scope):
+        self._parser_scope = parser_scope
+        self._module_node = self._parser_scope.get_root_node()
+        self._used_names = self._module_node.get_used_names()
+        self.parent_context = parent_context
+
+    def get(self, name):
+        return self._convert_names(self._filter(
+            _get_definition_names(self._used_names, name),
+        ))
+
+    def _convert_names(self, names):
+        return [self.name_class(self.parent_context, name) for name in names]
+
+    def values(self):
+        return self._convert_names(
+            name
+            for name_key in self._used_names
+            for name in self._filter(
+                _get_definition_names(self._used_names, name_key),
+            )
+        )
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self.parent_context)
+
+
+class ParserTreeFilter(AbstractUsedNamesFilter):
+    def __init__(self, parent_context, node_context=None, until_position=None,
+                 origin_scope=None):
+        """
+        node_context is an option to specify a second value for use cases
+        like the class mro where the parent class of a new name would be the
+        value, but for some type inference it's important to have a local
+        value of the other classes.
+        """
+        if node_context is None:
+            node_context = parent_context
+        super(ParserTreeFilter, self).__init__(parent_context, node_context.tree_node)
+        self._node_context = node_context
+        self._origin_scope = origin_scope
+        self._until_position = until_position
+
+    def _filter(self, names):
+        names = super(ParserTreeFilter, self)._filter(names)
+        names = [n for n in names if self._is_name_reachable(n)]
+        return list(self._check_flows(names))
+
+    def _is_name_reachable(self, name):
+        parent = name.parent
+        if parent.type == 'trailer':
+            return False
+        base_node = parent if parent.type in ('classdef', 'funcdef') else name
+        return get_cached_parent_scope(self._used_names, base_node) == self._parser_scope
+
+    def _check_flows(self, names):
+        for name in sorted(names, key=lambda name: name.start_pos, reverse=True):
+            check = flow_analysis.reachability_check(
+                context=self._node_context,
+                value_scope=self._parser_scope,
+                node=name,
+                origin_scope=self._origin_scope
+            )
+            if check is not flow_analysis.UNREACHABLE:
+                yield name
+
+            if check is flow_analysis.REACHABLE:
+                break
+
+
+class _FunctionExecutionFilter(ParserTreeFilter):
+    def __init__(self, parent_context, function_value, until_position, origin_scope):
+        super(_FunctionExecutionFilter, self).__init__(
+            parent_context,
+            until_position=until_position,
+            origin_scope=origin_scope,
+        )
+        self._function_value = function_value
+
+    def _convert_param(self, param, name):
+        raise NotImplementedError
+
+    @to_list
+    def _convert_names(self, names):
+        for name in names:
+            param = search_ancestor(name, 'param')
+            # Here we don't need to check if the param is a default/annotation,
+            # because those are not definitions and never make it to this
+            # point.
+            if param:
+                yield self._convert_param(param, name)
+            else:
+                yield TreeNameDefinition(self.parent_context, name)
+
+
+class FunctionExecutionFilter(_FunctionExecutionFilter):
+    def __init__(self, *args, **kwargs):
+        self._arguments = kwargs.pop('arguments')  # Python 2
+        super(FunctionExecutionFilter, self).__init__(*args, **kwargs)
+
+    def _convert_param(self, param, name):
+        return ParamName(self._function_value, name, self._arguments)
+
+
+class AnonymousFunctionExecutionFilter(_FunctionExecutionFilter):
+    def _convert_param(self, param, name):
+        return AnonymousParamName(self._function_value, name)
+
+
+class GlobalNameFilter(AbstractUsedNamesFilter):
+    def get(self, name):
+        try:
+            names = self._used_names[name]
+        except KeyError:
+            return []
+        return self._convert_names(self._filter(names))
+
+    @to_list
+    def _filter(self, names):
+        for name in names:
+            if name.parent.type == 'global_stmt':
+                yield name
+
+    def values(self):
+        return self._convert_names(
+            name for name_list in self._used_names.values()
+            for name in self._filter(name_list)
+        )
+
+
+class DictFilter(AbstractFilter):
+    def __init__(self, dct):
+        self._dct = dct
+
+    def get(self, name):
+        try:
+            value = self._convert(name, self._dct[name])
+        except KeyError:
+            return []
+        else:
+            return list(self._filter([value]))
+
+    def values(self):
+        def yielder():
+            for item in self._dct.items():
+                try:
+                    yield self._convert(*item)
+                except KeyError:
+                    pass
+        return self._filter(yielder())
+
+    def _convert(self, name, value):
+        return value
+
+    def __repr__(self):
+        keys = ', '.join(self._dct.keys())
+        return '<%s: for {%s}>' % (self.__class__.__name__, keys)
+
+
+class MergedFilter(object):
+    def __init__(self, *filters):
+        self._filters = filters
+
+    def get(self, name):
+        return [n for filter in self._filters for n in filter.get(name)]
+
+    def values(self):
+        return [n for filter in self._filters for n in filter.values()]
+
+    def __repr__(self):
+        return '%s(%s)' % (self.__class__.__name__, ', '.join(str(f) for f in self._filters))
+
+
+class _BuiltinMappedMethod(ValueWrapper):
+    """``Generator.__next__`` ``dict.values`` methods and so on."""
+    api_type = u'function'
+
+    def __init__(self, value, method, builtin_func):
+        super(_BuiltinMappedMethod, self).__init__(builtin_func)
+        self._value = value
+        self._method = method
+
+    def py__call__(self, arguments):
+        # TODO add TypeError if params are given/or not correct.
+        return self._method(self._value, arguments)
+
+
+class SpecialMethodFilter(DictFilter):
+    """
+    A filter for methods that are defined in this module on the corresponding
+    classes like Generator (for __next__, etc).
+    """
+    class SpecialMethodName(AbstractNameDefinition):
+        api_type = u'function'
+
+        def __init__(self, parent_context, string_name, value, builtin_value):
+            callable_, python_version = value
+            if python_version is not None and \
+                    python_version != parent_context.inference_state.environment.version_info.major:
+                raise KeyError
+
+            self.parent_context = parent_context
+            self.string_name = string_name
+            self._callable = callable_
+            self._builtin_value = builtin_value
+
+        def infer(self):
+            for filter in self._builtin_value.get_filters():
+                # We can take the first index, because on builtin methods there's
+                # always only going to be one name. The same is true for the
+                # inferred values.
+                for name in filter.get(self.string_name):
+                    builtin_func = next(iter(name.infer()))
+                    break
+                else:
+                    continue
+                break
+            return ValueSet([
+                _BuiltinMappedMethod(self.parent_context, self._callable, builtin_func)
+            ])
+
+    def __init__(self, value, dct, builtin_value):
+        super(SpecialMethodFilter, self).__init__(dct)
+        self.value = value
+        self._builtin_value = builtin_value
+        """
+        This value is what will be used to introspect the name, where as the
+        other value will be used to execute the function.
+
+        We distinguish, because we have to.
+        """
+
+    def _convert(self, name, value):
+        return self.SpecialMethodName(self.value, name, value, self._builtin_value)
+
+
+class _OverwriteMeta(type):
+    def __init__(cls, name, bases, dct):
+        super(_OverwriteMeta, cls).__init__(name, bases, dct)
+
+        base_dct = {}
+        for base_cls in reversed(cls.__bases__):
+            try:
+                base_dct.update(base_cls.overwritten_methods)
+            except AttributeError:
+                pass
+
+        for func in cls.__dict__.values():
+            try:
+                base_dct.update(func.registered_overwritten_methods)
+            except AttributeError:
+                pass
+        cls.overwritten_methods = base_dct
+
+
+class _AttributeOverwriteMixin(object):
+    def get_filters(self, *args, **kwargs):
+        yield SpecialMethodFilter(self, self.overwritten_methods, self._wrapped_value)
+
+        for filter in self._wrapped_value.get_filters(*args, **kwargs):
+            yield filter
+
+
+class LazyAttributeOverwrite(use_metaclass(_OverwriteMeta, _AttributeOverwriteMixin,
+                                           LazyValueWrapper)):
+    def __init__(self, inference_state):
+        self.inference_state = inference_state
+
+
+class AttributeOverwrite(use_metaclass(_OverwriteMeta, _AttributeOverwriteMixin,
+                                       ValueWrapper)):
+    pass
+
+
+def publish_method(method_name, python_version_match=None):
+    def decorator(func):
+        dct = func.__dict__.setdefault('registered_overwritten_methods', {})
+        dct[method_name] = func, python_version_match
+        return func
+    return decorator

venv/Lib/site-packages/jedi/inference/finder.py

@@ -0,0 +1,146 @@
+"""
+Searching for names with given scope and name. This is very central in Jedi and
+Python. The name resolution is quite complicated with descripter,
+``__getattribute__``, ``__getattr__``, ``global``, etc.
+
+If you want to understand name resolution, please read the first few chapters
+in http://blog.ionelmc.ro/2015/02/09/understanding-python-metaclasses/.
+
+Flow checks
++++++++++++
+
+Flow checks are not really mature. There's only a check for ``isinstance``.  It
+would check whether a flow has the form of ``if isinstance(a, type_or_tuple)``.
+Unfortunately every other thing is being ignored (e.g. a == '' would be easy to
+check for -> a is a string). There's big potential in these checks.
+"""
+
+from parso.tree import search_ancestor
+from parso.python.tree import Name
+
+from jedi import settings
+from jedi.inference.arguments import TreeArguments
+from jedi.inference.value import iterable
+from jedi.inference.base_value import NO_VALUES
+from jedi.parser_utils import is_scope
+
+
+def filter_name(filters, name_or_str):
+    """
+    Searches names that are defined in a scope (the different
+    ``filters``), until a name fits.
+    """
+    string_name = name_or_str.value if isinstance(name_or_str, Name) else name_or_str
+    names = []
+    for filter in filters:
+        names = filter.get(string_name)
+        if names:
+            break
+
+    return list(_remove_del_stmt(names))
+
+
+def _remove_del_stmt(names):
+    # Catch del statements and remove them from results.
+    for name in names:
+        if name.tree_name is not None:
+            definition = name.tree_name.get_definition()
+            if definition is not None and definition.type == 'del_stmt':
+                continue
+        yield name
+
+
+def check_flow_information(value, flow, search_name, pos):
+    """ Try to find out the type of a variable just with the information that
+    is given by the flows: e.g. It is also responsible for assert checks.::
+
+        if isinstance(k, str):
+            k.  # <- completion here
+
+    ensures that `k` is a string.
+    """
+    if not settings.dynamic_flow_information:
+        return None
+
+    result = None
+    if is_scope(flow):
+        # Check for asserts.
+        module_node = flow.get_root_node()
+        try:
+            names = module_node.get_used_names()[search_name.value]
+        except KeyError:
+            return None
+        names = reversed([
+            n for n in names
+            if flow.start_pos <= n.start_pos < (pos or flow.end_pos)
+        ])
+
+        for name in names:
+            ass = search_ancestor(name, 'assert_stmt')
+            if ass is not None:
+                result = _check_isinstance_type(value, ass.assertion, search_name)
+                if result is not None:
+                    return result
+
+    if flow.type in ('if_stmt', 'while_stmt'):
+        potential_ifs = [c for c in flow.children[1::4] if c != ':']
+        for if_test in reversed(potential_ifs):
+            if search_name.start_pos > if_test.end_pos:
+                return _check_isinstance_type(value, if_test, search_name)
+    return result
+
+
+def _get_isinstance_trailer_arglist(node):
+    if node.type in ('power', 'atom_expr') and len(node.children) == 2:
+        # This might be removed if we analyze and, etc
+        first, trailer = node.children
+        if first.type == 'name' and first.value == 'isinstance' \
+                and trailer.type == 'trailer' and trailer.children[0] == '(':
+            return trailer
+    return None
+
+
+def _check_isinstance_type(value, node, search_name):
+    lazy_cls = None
+    trailer = _get_isinstance_trailer_arglist(node)
+    if trailer is not None and len(trailer.children) == 3:
+        arglist = trailer.children[1]
+        args = TreeArguments(value.inference_state, value, arglist, trailer)
+        param_list = list(args.unpack())
+        # Disallow keyword arguments
+        if len(param_list) == 2 and len(arglist.children) == 3:
+            (key1, _), (key2, lazy_value_cls) = param_list
+            if key1 is None and key2 is None:
+                call = _get_call_string(search_name)
+                is_instance_call = _get_call_string(arglist.children[0])
+                # Do a simple get_code comparison of the strings . They should
+                # just have the same code, and everything will be all right.
+                # There are ways that this is not correct, if some stuff is
+                # redefined in between. However here we don't care, because
+                # it's a heuristic that works pretty well.
+                if call == is_instance_call:
+                    lazy_cls = lazy_value_cls
+    if lazy_cls is None:
+        return None
+
+    value_set = NO_VALUES
+    for cls_or_tup in lazy_cls.infer():
+        if isinstance(cls_or_tup, iterable.Sequence) and cls_or_tup.array_type == 'tuple':
+            for lazy_value in cls_or_tup.py__iter__():
+                value_set |= lazy_value.infer().execute_with_values()
+        else:
+            value_set |= cls_or_tup.execute_with_values()
+    return value_set
+
+
+def _get_call_string(node):
+    if node.parent.type == 'atom_expr':
+        return _get_call_string(node.parent)
+
+    code = ''
+    leaf = node.get_first_leaf()
+    end = node.get_last_leaf().end_pos
+    while leaf.start_pos < end:
+        code += leaf.value
+        leaf = leaf.get_next_leaf()
+    return code

venv/Lib/site-packages/jedi/inference/flow_analysis.py

@@ -0,0 +1,123 @@
+from jedi.parser_utils import get_flow_branch_keyword, is_scope, get_parent_scope
+from jedi.inference.recursion import execution_allowed
+from jedi.inference.helpers import is_big_annoying_library
+
+
+class Status(object):
+    lookup_table = {}
+
+    def __init__(self, value, name):
+        self._value = value
+        self._name = name
+        Status.lookup_table[value] = self
+
+    def invert(self):
+        if self is REACHABLE:
+            return UNREACHABLE
+        elif self is UNREACHABLE:
+            return REACHABLE
+        else:
+            return UNSURE
+
+    def __and__(self, other):
+        if UNSURE in (self, other):
+            return UNSURE
+        else:
+            return REACHABLE if self._value and other._value else UNREACHABLE
+
+    def __repr__(self):
+        return '<%s: %s>' % (type(self).__name__, self._name)
+
+
+REACHABLE = Status(True, 'reachable')
+UNREACHABLE = Status(False, 'unreachable')
+UNSURE = Status(None, 'unsure')
+
+
+def _get_flow_scopes(node):
+    while True:
+        node = get_parent_scope(node, include_flows=True)
+        if node is None or is_scope(node):
+            return
+        yield node
+
+
+def reachability_check(context, value_scope, node, origin_scope=None):
+    if is_big_annoying_library(context) \
+            or not context.inference_state.flow_analysis_enabled:
+        return UNSURE
+
+    first_flow_scope = get_parent_scope(node, include_flows=True)
+    if origin_scope is not None:
+        origin_flow_scopes = list(_get_flow_scopes(origin_scope))
+        node_flow_scopes = list(_get_flow_scopes(node))
+
+        branch_matches = True
+        for flow_scope in origin_flow_scopes:
+            if flow_scope in node_flow_scopes:
+                node_keyword = get_flow_branch_keyword(flow_scope, node)
+                origin_keyword = get_flow_branch_keyword(flow_scope, origin_scope)
+                branch_matches = node_keyword == origin_keyword
+                if flow_scope.type == 'if_stmt':
+                    if not branch_matches:
+                        return UNREACHABLE
+                elif flow_scope.type == 'try_stmt':
+                    if not branch_matches and origin_keyword == 'else' \
+                            and node_keyword == 'except':
+                        return UNREACHABLE
+                if branch_matches:
+                    break
+
+        # Direct parents get resolved, we filter scopes that are separate
+        # branches.  This makes sense for autocompletion and static analysis.
+        # For actual Python it doesn't matter, because we're talking about
+        # potentially unreachable code.
+        # e.g. `if 0:` would cause all name lookup within the flow make
+        # unaccessible. This is not a "problem" in Python, because the code is
+        # never called. In Jedi though, we still want to infer types.
+        while origin_scope is not None:
+            if first_flow_scope == origin_scope and branch_matches:
+                return REACHABLE
+            origin_scope = origin_scope.parent
+
+    return _break_check(context, value_scope, first_flow_scope, node)
+
+
+def _break_check(context, value_scope, flow_scope, node):
+    reachable = REACHABLE
+    if flow_scope.type == 'if_stmt':
+        if flow_scope.is_node_after_else(node):
+            for check_node in flow_scope.get_test_nodes():
+                reachable = _check_if(context, check_node)
+                if reachable in (REACHABLE, UNSURE):
+                    break
+            reachable = reachable.invert()
+        else:
+            flow_node = flow_scope.get_corresponding_test_node(node)
+            if flow_node is not None:
+                reachable = _check_if(context, flow_node)
+    elif flow_scope.type in ('try_stmt', 'while_stmt'):
+        return UNSURE
+
+    # Only reachable branches need to be examined further.
+    if reachable in (UNREACHABLE, UNSURE):
+        return reachable
+
+    if value_scope != flow_scope and value_scope != flow_scope.parent:
+        flow_scope = get_parent_scope(flow_scope, include_flows=True)
+        return reachable & _break_check(context, value_scope, flow_scope, node)
+    else:
+        return reachable
+
+
+def _check_if(context, node):
+    with execution_allowed(context.inference_state, node) as allowed:
+        if not allowed:
+            return UNSURE
+
+        types = context.infer_node(node)
+        values = set(x.py__bool__() for x in types)
+        if len(values) == 1:
+            return Status.lookup_table[values.pop()]
+        else:
+            return UNSURE

venv/Lib/site-packages/jedi/inference/gradual/__init__.py

@@ -0,0 +1,4 @@
+"""
+It is unfortunately not well documented how stubs and annotations work in Jedi.
+If somebody needs an introduction, please let me know.
+"""

venv/Lib/site-packages/jedi/inference/gradual/annotation.py

@@ -0,0 +1,439 @@
+"""
+PEP 0484 ( https://www.python.org/dev/peps/pep-0484/ ) describes type hints
+through function annotations. There is a strong suggestion in this document
+that only the type of type hinting defined in PEP0484 should be allowed
+as annotations in future python versions.
+"""
+
+import re
+
+from parso import ParserSyntaxError, parse
+
+from jedi._compatibility import force_unicode, Parameter
+from jedi.inference.cache import inference_state_method_cache
+from jedi.inference.base_value import ValueSet, NO_VALUES
+from jedi.inference.gradual.base import DefineGenericBaseClass, GenericClass
+from jedi.inference.gradual.generics import TupleGenericManager
+from jedi.inference.gradual.type_var import TypeVar
+from jedi.inference.helpers import is_string
+from jedi.inference.compiled import builtin_from_name
+from jedi.inference.param import get_executed_param_names
+from jedi import debug
+from jedi import parser_utils
+
+
+def infer_annotation(context, annotation):
+    """
+    Inferes an annotation node. This means that it inferes the part of
+    `int` here:
+
+        foo: int = 3
+
+    Also checks for forward references (strings)
+    """
+    value_set = context.infer_node(annotation)
+    if len(value_set) != 1:
+        debug.warning("Inferred typing index %s should lead to 1 object, "
+                      " not %s" % (annotation, value_set))
+        return value_set
+
+    inferred_value = list(value_set)[0]
+    if is_string(inferred_value):
+        result = _get_forward_reference_node(context, inferred_value.get_safe_value())
+        if result is not None:
+            return context.infer_node(result)
+    return value_set
+
+
+def _infer_annotation_string(context, string, index=None):
+    node = _get_forward_reference_node(context, string)
+    if node is None:
+        return NO_VALUES
+
+    value_set = context.infer_node(node)
+    if index is not None:
+        value_set = value_set.filter(
+            lambda value: value.array_type == u'tuple'  # noqa
+                            and len(list(value.py__iter__())) >= index
+        ).py__simple_getitem__(index)
+    return value_set
+
+
+def _get_forward_reference_node(context, string):
+    try:
+        new_node = context.inference_state.grammar.parse(
+            force_unicode(string),
+            start_symbol='eval_input',
+            error_recovery=False
+        )
+    except ParserSyntaxError:
+        debug.warning('Annotation not parsed: %s' % string)
+        return None
+    else:
+        module = context.tree_node.get_root_node()
+        parser_utils.move(new_node, module.end_pos[0])
+        new_node.parent = context.tree_node
+        return new_node
+
+
+def _split_comment_param_declaration(decl_text):
+    """
+    Split decl_text on commas, but group generic expressions
+    together.
+
+    For example, given "foo, Bar[baz, biz]" we return
+    ['foo', 'Bar[baz, biz]'].
+
+    """
+    try:
+        node = parse(decl_text, error_recovery=False).children[0]
+    except ParserSyntaxError:
+        debug.warning('Comment annotation is not valid Python: %s' % decl_text)
+        return []
+
+    if node.type in ['name', 'atom_expr', 'power']:
+        return [node.get_code().strip()]
+
+    params = []
+    try:
+        children = node.children
+    except AttributeError:
+        return []
+    else:
+        for child in children:
+            if child.type in ['name', 'atom_expr', 'power']:
+                params.append(child.get_code().strip())
+
+    return params
+
+
+@inference_state_method_cache()
+def infer_param(function_value, param, ignore_stars=False):
+    values = _infer_param(function_value, param)
+    if ignore_stars or not values:
+        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,)),
+        )])
+    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),
+        )])
+    return values
+
+
+def _infer_param(function_value, param):
+    """
+    Infers the type of a function parameter, using type annotations.
+    """
+    annotation = param.annotation
+    if annotation is None:
+        # If no Python 3-style annotation, look for a Python 2-style comment
+        # annotation.
+        # Identify parameters to function in the same sequence as they would
+        # appear in a type comment.
+        all_params = [child for child in param.parent.children
+                      if child.type == 'param']
+
+        node = param.parent.parent
+        comment = parser_utils.get_following_comment_same_line(node)
+        if comment is None:
+            return NO_VALUES
+
+        match = re.match(r"^#\s*type:\s*\(([^#]*)\)\s*->", comment)
+        if not match:
+            return NO_VALUES
+        params_comments = _split_comment_param_declaration(match.group(1))
+
+        # Find the specific param being investigated
+        index = all_params.index(param)
+        # If the number of parameters doesn't match length of type comment,
+        # ignore first parameter (assume it's self).
+        if len(params_comments) != len(all_params):
+            debug.warning(
+                "Comments length != Params length %s %s",
+                params_comments, all_params
+            )
+        if function_value.is_bound_method():
+            if index == 0:
+                # Assume it's self, which is already handled
+                return NO_VALUES
+            index -= 1
+        if index >= len(params_comments):
+            return NO_VALUES
+
+        param_comment = params_comments[index]
+        return _infer_annotation_string(
+            function_value.get_default_param_context(),
+            param_comment
+        )
+    # Annotations are like default params and resolve in the same way.
+    context = function_value.get_default_param_context()
+    return infer_annotation(context, annotation)
+
+
+def py__annotations__(funcdef):
+    dct = {}
+    for function_param in funcdef.get_params():
+        param_annotation = function_param.annotation
+        if param_annotation is not None:
+            dct[function_param.name.value] = param_annotation
+
+    return_annotation = funcdef.annotation
+    if return_annotation:
+        dct['return'] = return_annotation
+    return dct
+
+
+@inference_state_method_cache()
+def infer_return_types(function, arguments):
+    """
+    Infers the type of a function's return value,
+    according to type annotations.
+    """
+    all_annotations = py__annotations__(function.tree_node)
+    annotation = all_annotations.get("return", None)
+    if annotation is None:
+        # If there is no Python 3-type annotation, look for a Python 2-type annotation
+        node = function.tree_node
+        comment = parser_utils.get_following_comment_same_line(node)
+        if comment is None:
+            return NO_VALUES
+
+        match = re.match(r"^#\s*type:\s*\([^#]*\)\s*->\s*([^#]*)", comment)
+        if not match:
+            return NO_VALUES
+
+        return _infer_annotation_string(
+            function.get_default_param_context(),
+            match.group(1).strip()
+        ).execute_annotation()
+
+    context = function.get_default_param_context()
+    unknown_type_vars = find_unknown_type_vars(context, annotation)
+    annotation_values = infer_annotation(context, annotation)
+    if not unknown_type_vars:
+        return annotation_values.execute_annotation()
+
+    type_var_dict = infer_type_vars_for_execution(function, arguments, all_annotations)
+
+    return ValueSet.from_sets(
+        ann.define_generics(type_var_dict)
+        if isinstance(ann, (DefineGenericBaseClass, TypeVar)) else ValueSet({ann})
+        for ann in annotation_values
+    ).execute_annotation()
+
+
+def infer_type_vars_for_execution(function, arguments, annotation_dict):
+    """
+    Some functions use type vars that are not defined by the class, but rather
+    only defined in the function. See for example `iter`. In those cases we
+    want to:
+
+    1. Search for undefined type vars.
+    2. Infer type vars with the execution state we have.
+    3. Return the union of all type vars that have been found.
+    """
+    context = function.get_default_param_context()
+
+    annotation_variable_results = {}
+    executed_param_names = get_executed_param_names(function, arguments)
+    for executed_param_name in executed_param_names:
+        try:
+            annotation_node = annotation_dict[executed_param_name.string_name]
+        except KeyError:
+            continue
+
+        annotation_variables = find_unknown_type_vars(context, annotation_node)
+        if annotation_variables:
+            # Infer unknown type var
+            annotation_value_set = context.infer_node(annotation_node)
+            kind = executed_param_name.get_kind()
+            actual_value_set = executed_param_name.infer()
+            if kind is Parameter.VAR_POSITIONAL:
+                actual_value_set = actual_value_set.merge_types_of_iterate()
+            elif kind is Parameter.VAR_KEYWORD:
+                # TODO _dict_values is not public.
+                actual_value_set = actual_value_set.try_merge('_dict_values')
+            merge_type_var_dicts(
+                annotation_variable_results,
+                annotation_value_set.infer_type_vars(actual_value_set),
+            )
+    return annotation_variable_results
+
+
+def infer_return_for_callable(arguments, param_values, result_values):
+    all_type_vars = {}
+    for pv in param_values:
+        if pv.array_type == 'list':
+            type_var_dict = _infer_type_vars_for_callable(arguments, pv.py__iter__())
+            all_type_vars.update(type_var_dict)
+
+    return ValueSet.from_sets(
+        v.define_generics(all_type_vars)
+        if isinstance(v, (DefineGenericBaseClass, TypeVar))
+        else ValueSet({v})
+        for v in result_values
+    ).execute_annotation()
+
+
+def _infer_type_vars_for_callable(arguments, lazy_params):
+    """
+    Infers type vars for the Calllable class:
+
+        def x() -> Callable[[Callable[..., _T]], _T]: ...
+    """
+    annotation_variable_results = {}
+    for (_, lazy_value), lazy_callable_param in zip(arguments.unpack(), lazy_params):
+        callable_param_values = lazy_callable_param.infer()
+        # Infer unknown type var
+        actual_value_set = lazy_value.infer()
+        merge_type_var_dicts(
+            annotation_variable_results,
+            callable_param_values.infer_type_vars(actual_value_set),
+        )
+    return annotation_variable_results
+
+
+def merge_type_var_dicts(base_dict, new_dict):
+    for type_var_name, values in new_dict.items():
+        if values:
+            try:
+                base_dict[type_var_name] |= values
+            except KeyError:
+                base_dict[type_var_name] = values
+
+
+def merge_pairwise_generics(annotation_value, annotated_argument_class):
+    """
+    Match up the generic parameters from the given argument class to the
+    target annotation.
+
+    This walks the generic parameters immediately within the annotation and
+    argument's type, in order to determine the concrete values of the
+    annotation's parameters for the current case.
+
+    For example, given the following code:
+
+        def values(mapping: Mapping[K, V]) -> List[V]: ...
+
+        for val in values({1: 'a'}):
+            val
+
+    Then this function should be given representations of `Mapping[K, V]`
+    and `Mapping[int, str]`, so that it can determine that `K` is `int and
+    `V` is `str`.
+
+    Note that it is responsibility of the caller to traverse the MRO of the
+    argument type as needed in order to find the type matching the
+    annotation (in this case finding `Mapping[int, str]` as a parent of
+    `Dict[int, str]`).
+
+    Parameters
+    ----------
+
+    `annotation_value`: represents the annotation to infer the concrete
+        parameter types of.
+
+    `annotated_argument_class`: represents the annotated class of the
+        argument being passed to the object annotated by `annotation_value`.
+    """
+
+    type_var_dict = {}
+
+    if not isinstance(annotated_argument_class, DefineGenericBaseClass):
+        return type_var_dict
+
+    annotation_generics = annotation_value.get_generics()
+    actual_generics = annotated_argument_class.get_generics()
+
+    for annotation_generics_set, actual_generic_set in zip(annotation_generics, actual_generics):
+        merge_type_var_dicts(
+            type_var_dict,
+            annotation_generics_set.infer_type_vars(actual_generic_set.execute_annotation()),
+        )
+
+    return type_var_dict
+
+
+def find_type_from_comment_hint_for(context, node, name):
+    return _find_type_from_comment_hint(context, node, node.children[1], name)
+
+
+def find_type_from_comment_hint_with(context, node, name):
+    assert len(node.children[1].children) == 3, \
+        "Can only be here when children[1] is 'foo() as f'"
+    varlist = node.children[1].children[2]
+    return _find_type_from_comment_hint(context, node, varlist, name)
+
+
+def find_type_from_comment_hint_assign(context, node, name):
+    return _find_type_from_comment_hint(context, node, node.children[0], name)
+
+
+def _find_type_from_comment_hint(context, node, varlist, name):
+    index = None
+    if varlist.type in ("testlist_star_expr", "exprlist", "testlist"):
+        # something like "a, b = 1, 2"
+        index = 0
+        for child in varlist.children:
+            if child == name:
+                break
+            if child.type == "operator":
+                continue
+            index += 1
+        else:
+            return []
+
+    comment = parser_utils.get_following_comment_same_line(node)
+    if comment is None:
+        return []
+    match = re.match(r"^#\s*type:\s*([^#]*)", comment)
+    if match is None:
+        return []
+    return _infer_annotation_string(
+        context, match.group(1).strip(), index
+    ).execute_annotation()
+
+
+def find_unknown_type_vars(context, node):
+    def check_node(node):
+        if node.type in ('atom_expr', 'power'):
+            trailer = node.children[-1]
+            if trailer.type == 'trailer' and trailer.children[0] == '[':
+                for subscript_node in _unpack_subscriptlist(trailer.children[1]):
+                    check_node(subscript_node)
+        else:
+            found[:] = _filter_type_vars(context.infer_node(node), found)
+
+    found = []  # We're not using a set, because the order matters.
+    check_node(node)
+    return found
+
+
+def _filter_type_vars(value_set, found=()):
+    new_found = list(found)
+    for type_var in value_set:
+        if isinstance(type_var, TypeVar) and type_var not in found:
+            new_found.append(type_var)
+    return new_found
+
+
+def _unpack_subscriptlist(subscriptlist):
+    if subscriptlist.type == 'subscriptlist':
+        for subscript in subscriptlist.children[::2]:
+            if subscript.type != 'subscript':
+                yield subscript
+    else:
+        if subscriptlist.type != 'subscript':
+            yield subscriptlist

venv/Lib/site-packages/jedi/inference/gradual/base.py

@@ -0,0 +1,430 @@
+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):
+                    for constraint in self._type_var.constraints:
+                        yield constraint
+                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(object):
+    """
+    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(_AnnotatedClassContext, self).get_filters(
+            *args, **kwargs
+        )
+        for f in filters:
+            yield f
+
+        # 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 __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(GenericClass, self).__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(GenericClass, self).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(GenericClass, self).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 != u'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(object):
+    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, u'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 = u'class'
+
+    def __init__(self, parent_context, tree_name):
+        super(_PseudoTreeNameClass, self).__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, u'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 __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(BaseTypingClassWithGenerics, self).__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, u'object').execute_annotation()
+        return object_
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self._generics_manager)

venv/Lib/site-packages/jedi/inference/gradual/conversion.py

@@ -0,0 +1,210 @@
+from jedi import debug
+from jedi.inference.base_value import ValueSet, \
+    NO_VALUES
+from jedi.inference.utils import to_list
+from jedi.inference.gradual.stub_value import StubModuleValue
+from jedi.inference.gradual.typeshed import try_to_load_stub_cached
+from jedi.inference.value.decorator import Decoratee
+
+
+def _stub_to_python_value_set(stub_value, ignore_compiled=False):
+    stub_module_context = stub_value.get_root_context()
+    if not stub_module_context.is_stub():
+        return ValueSet([stub_value])
+
+    decorates = None
+    if isinstance(stub_value, Decoratee):
+        decorates = stub_value._original_value
+
+    was_instance = stub_value.is_instance()
+    if was_instance:
+        arguments = getattr(stub_value, '_arguments', None)
+        stub_value = stub_value.py__class__()
+
+    qualified_names = stub_value.get_qualified_names()
+    if qualified_names is None:
+        return NO_VALUES
+
+    was_bound_method = stub_value.is_bound_method()
+    if was_bound_method:
+        # Infer the object first. We can infer the method later.
+        method_name = qualified_names[-1]
+        qualified_names = qualified_names[:-1]
+        was_instance = True
+        arguments = None
+
+    values = _infer_from_stub(stub_module_context, qualified_names, ignore_compiled)
+    if was_instance:
+        values = ValueSet.from_sets(
+            c.execute_with_values() if arguments is None else c.execute(arguments)
+            for c in values
+            if c.is_class()
+        )
+    if was_bound_method:
+        # Now that the instance has been properly created, we can simply get
+        # the method.
+        values = values.py__getattribute__(method_name)
+    if decorates is not None:
+        values = ValueSet(Decoratee(v, decorates) for v in values)
+    return values
+
+
+def _infer_from_stub(stub_module_context, qualified_names, ignore_compiled):
+    from jedi.inference.compiled.mixed import MixedObject
+    stub_module = stub_module_context.get_value()
+    assert isinstance(stub_module, (StubModuleValue, MixedObject)), stub_module_context
+    non_stubs = stub_module.non_stub_value_set
+    if ignore_compiled:
+        non_stubs = non_stubs.filter(lambda c: not c.is_compiled())
+    for name in qualified_names:
+        non_stubs = non_stubs.py__getattribute__(name)
+    return non_stubs
+
+
+@to_list
+def _try_stub_to_python_names(names, prefer_stub_to_compiled=False):
+    for name in names:
+        module_context = name.get_root_context()
+        if not module_context.is_stub():
+            yield name
+            continue
+
+        if name.api_type == 'module':
+            values = convert_values(name.infer(), ignore_compiled=prefer_stub_to_compiled)
+            if values:
+                for v in values:
+                    yield v.name
+                continue
+        else:
+            v = name.get_defining_qualified_value()
+            if v is not None:
+                converted = _stub_to_python_value_set(v, ignore_compiled=prefer_stub_to_compiled)
+                if converted:
+                    converted_names = converted.goto(name.get_public_name())
+                    if converted_names:
+                        for n in converted_names:
+                            if n.get_root_context().is_stub():
+                                # If it's a stub again, it means we're going in
+                                # a circle. Probably some imports make it a
+                                # stub again.
+                                yield name
+                            else:
+                                yield n
+                        continue
+        yield name
+
+
+def _load_stub_module(module):
+    if module.is_stub():
+        return module
+    return try_to_load_stub_cached(
+        module.inference_state,
+        import_names=module.string_names,
+        python_value_set=ValueSet([module]),
+        parent_module_value=None,
+        sys_path=module.inference_state.get_sys_path(),
+    )
+
+
+@to_list
+def _python_to_stub_names(names, fallback_to_python=False):
+    for name in names:
+        module_context = name.get_root_context()
+        if module_context.is_stub():
+            yield name
+            continue
+
+        if name.api_type == 'module':
+            found_name = False
+            for n in name.goto():
+                if n.api_type == 'module':
+                    values = convert_values(n.infer(), only_stubs=True)
+                    for v in values:
+                        yield v.name
+                        found_name = True
+                else:
+                    for x in _python_to_stub_names([n], fallback_to_python=fallback_to_python):
+                        yield x
+                        found_name = True
+            if found_name:
+                continue
+        else:
+            v = name.get_defining_qualified_value()
+            if v is not None:
+                converted = to_stub(v)
+                if converted:
+                    converted_names = converted.goto(name.get_public_name())
+                    if converted_names:
+                        for n in converted_names:
+                            yield n
+                        continue
+        if fallback_to_python:
+            # This is the part where if we haven't found anything, just return
+            # the stub name.
+            yield name
+
+
+def convert_names(names, only_stubs=False, prefer_stubs=False, prefer_stub_to_compiled=True):
+    if only_stubs and prefer_stubs:
+        raise ValueError("You cannot use both of only_stubs and prefer_stubs.")
+
+    with debug.increase_indent_cm('convert names'):
+        if only_stubs or prefer_stubs:
+            return _python_to_stub_names(names, fallback_to_python=prefer_stubs)
+        else:
+            return _try_stub_to_python_names(
+                names, prefer_stub_to_compiled=prefer_stub_to_compiled)
+
+
+def convert_values(values, only_stubs=False, prefer_stubs=False, ignore_compiled=True):
+    assert not (only_stubs and prefer_stubs)
+    with debug.increase_indent_cm('convert values'):
+        if only_stubs or prefer_stubs:
+            return ValueSet.from_sets(
+                to_stub(value)
+                or (ValueSet({value}) if prefer_stubs else NO_VALUES)
+                for value in values
+            )
+        else:
+            return ValueSet.from_sets(
+                _stub_to_python_value_set(stub_value, ignore_compiled=ignore_compiled)
+                or ValueSet({stub_value})
+                for stub_value in values
+            )
+
+
+def to_stub(value):
+    if value.is_stub():
+        return ValueSet([value])
+
+    was_instance = value.is_instance()
+    if was_instance:
+        value = value.py__class__()
+
+    qualified_names = value.get_qualified_names()
+    stub_module = _load_stub_module(value.get_root_context().get_value())
+    if stub_module is None or qualified_names is None:
+        return NO_VALUES
+
+    was_bound_method = value.is_bound_method()
+    if was_bound_method:
+        # Infer the object first. We can infer the method later.
+        method_name = qualified_names[-1]
+        qualified_names = qualified_names[:-1]
+        was_instance = True
+
+    stub_values = ValueSet([stub_module])
+    for name in qualified_names:
+        stub_values = stub_values.py__getattribute__(name)
+
+    if was_instance:
+        stub_values = ValueSet.from_sets(
+            c.execute_with_values()
+            for c in stub_values
+            if c.is_class()
+        )
+    if was_bound_method:
+        # Now that the instance has been properly created, we can simply get
+        # the method.
+        stub_values = stub_values.py__getattribute__(method_name)
+    return stub_values

venv/Lib/site-packages/jedi/inference/gradual/generics.py

@@ -0,0 +1,101 @@
+"""
+This module is about generics, like the `int` in `List[int]`. It's not about
+the Generic class.
+"""
+
+from jedi import debug
+from jedi.cache import memoize_method
+from jedi.inference.utils import to_tuple
+from jedi.inference.base_value import ValueSet, NO_VALUES
+from jedi.inference.value.iterable import SequenceLiteralValue
+from jedi.inference.helpers import is_string
+
+
+def _resolve_forward_references(context, value_set):
+    for value in value_set:
+        if is_string(value):
+            from jedi.inference.gradual.annotation import _get_forward_reference_node
+            node = _get_forward_reference_node(context, value.get_safe_value())
+            if node is not None:
+                for c in context.infer_node(node):
+                    yield c
+        else:
+            yield value
+
+
+class _AbstractGenericManager(object):
+    def get_index_and_execute(self, index):
+        try:
+            return self[index].execute_annotation()
+        except IndexError:
+            debug.warning('No param #%s found for annotation %s', index, self)
+            return NO_VALUES
+
+    def get_type_hint(self):
+        return '[%s]' % ', '.join(t.get_type_hint(add_class_info=False) for t in self.to_tuple())
+
+
+class LazyGenericManager(_AbstractGenericManager):
+    def __init__(self, context_of_index, index_value):
+        self._context_of_index = context_of_index
+        self._index_value = index_value
+
+    @memoize_method
+    def __getitem__(self, index):
+        return self._tuple()[index]()
+
+    def __len__(self):
+        return len(self._tuple())
+
+    @memoize_method
+    @to_tuple
+    def _tuple(self):
+        def lambda_scoping_in_for_loop_sucks(lazy_value):
+            return lambda: ValueSet(_resolve_forward_references(
+                self._context_of_index,
+                lazy_value.infer()
+            ))
+
+        if isinstance(self._index_value, SequenceLiteralValue):
+            for lazy_value in self._index_value.py__iter__(contextualized_node=None):
+                yield lambda_scoping_in_for_loop_sucks(lazy_value)
+        else:
+            yield lambda: ValueSet(_resolve_forward_references(
+                self._context_of_index,
+                ValueSet([self._index_value])
+            ))
+
+    @to_tuple
+    def to_tuple(self):
+        for callable_ in self._tuple():
+            yield callable_()
+
+    def is_homogenous_tuple(self):
+        if isinstance(self._index_value, SequenceLiteralValue):
+            entries = self._index_value.get_tree_entries()
+            if len(entries) == 2 and entries[1] == '...':
+                return True
+        return False
+
+    def __repr__(self):
+        return '<LazyG>[%s]' % (', '.join(repr(x) for x in self.to_tuple()))
+
+
+class TupleGenericManager(_AbstractGenericManager):
+    def __init__(self, tup):
+        self._tuple = tup
+
+    def __getitem__(self, index):
+        return self._tuple[index]
+
+    def __len__(self):
+        return len(self._tuple)
+
+    def to_tuple(self):
+        return self._tuple
+
+    def is_homogenous_tuple(self):
+        return False
+
+    def __repr__(self):
+        return '<TupG>[%s]' % (', '.join(repr(x) for x in self.to_tuple()))

venv/Lib/site-packages/jedi/inference/gradual/stub_value.py

@@ -0,0 +1,105 @@
+from jedi.inference.base_value import ValueWrapper
+from jedi.inference.value.module import ModuleValue
+from jedi.inference.filters import ParserTreeFilter
+from jedi.inference.names import StubName, StubModuleName
+from jedi.inference.gradual.typing import TypingModuleFilterWrapper
+from jedi.inference.context import ModuleContext
+
+
+class StubModuleValue(ModuleValue):
+    _module_name_class = StubModuleName
+
+    def __init__(self, non_stub_value_set, *args, **kwargs):
+        super(StubModuleValue, self).__init__(*args, **kwargs)
+        self.non_stub_value_set = non_stub_value_set
+
+    def is_stub(self):
+        return True
+
+    def sub_modules_dict(self):
+        """
+        We have to overwrite this, because it's possible to have stubs that
+        don't have code for all the child modules. At the time of writing this
+        there are for example no stubs for `json.tool`.
+        """
+        names = {}
+        for value in self.non_stub_value_set:
+            try:
+                method = value.sub_modules_dict
+            except AttributeError:
+                pass
+            else:
+                names.update(method())
+        names.update(super(StubModuleValue, self).sub_modules_dict())
+        return names
+
+    def _get_stub_filters(self, origin_scope):
+        return [StubFilter(
+            parent_context=self.as_context(),
+            origin_scope=origin_scope
+        )] + list(self.iter_star_filters())
+
+    def get_filters(self, origin_scope=None):
+        filters = super(StubModuleValue, self).get_filters(origin_scope)
+        next(filters, None)  # Ignore the first filter and replace it with our own
+        stub_filters = self._get_stub_filters(origin_scope=origin_scope)
+        for f in stub_filters:
+            yield f
+
+        for f in filters:
+            yield f
+
+    def _as_context(self):
+        return StubModuleContext(self)
+
+
+class StubModuleContext(ModuleContext):
+    def get_filters(self, until_position=None, origin_scope=None):
+        # Make sure to ignore the position, because positions are not relevant
+        # for stubs.
+        return super(StubModuleContext, self).get_filters(origin_scope=origin_scope)
+
+
+class TypingModuleWrapper(StubModuleValue):
+    def get_filters(self, *args, **kwargs):
+        filters = super(TypingModuleWrapper, self).get_filters(*args, **kwargs)
+        f = next(filters, None)
+        assert f is not None
+        yield TypingModuleFilterWrapper(f)
+        for f in filters:
+            yield f
+
+    def _as_context(self):
+        return TypingModuleContext(self)
+
+
+class TypingModuleContext(ModuleContext):
+    def get_filters(self, *args, **kwargs):
+        filters = super(TypingModuleContext, self).get_filters(*args, **kwargs)
+        yield TypingModuleFilterWrapper(next(filters, None))
+        for f in filters:
+            yield f
+
+
+class StubFilter(ParserTreeFilter):
+    name_class = StubName
+
+    def _is_name_reachable(self, name):
+        if not super(StubFilter, self)._is_name_reachable(name):
+            return False
+
+        # Imports in stub files are only public if they have an "as"
+        # export.
+        definition = name.get_definition()
+        if definition.type in ('import_from', 'import_name'):
+            if name.parent.type not in ('import_as_name', 'dotted_as_name'):
+                return False
+        n = name.value
+        # TODO rewrite direct return
+        if n.startswith('_') and not (n.startswith('__') and n.endswith('__')):
+            return False
+        return True
+
+
+class VersionInfo(ValueWrapper):
+    pass

venv/Lib/site-packages/jedi/inference/gradual/type_var.py

@@ -0,0 +1,131 @@
+from jedi._compatibility import unicode, force_unicode
+from jedi import debug
+from jedi.inference.base_value import ValueSet, NO_VALUES, ValueWrapper
+from jedi.inference.gradual.base import BaseTypingValue
+
+
+class TypeVarClass(BaseTypingValue):
+    def py__call__(self, arguments):
+        unpacked = arguments.unpack()
+
+        key, lazy_value = next(unpacked, (None, None))
+        var_name = self._find_string_name(lazy_value)
+        # The name must be given, otherwise it's useless.
+        if var_name is None or key is not None:
+            debug.warning('Found a variable without a name %s', arguments)
+            return NO_VALUES
+
+        return ValueSet([TypeVar.create_cached(
+            self.inference_state,
+            self.parent_context,
+            self._tree_name,
+            var_name,
+            unpacked
+        )])
+
+    def _find_string_name(self, lazy_value):
+        if lazy_value is None:
+            return None
+
+        value_set = lazy_value.infer()
+        if not value_set:
+            return None
+        if len(value_set) > 1:
+            debug.warning('Found multiple values for a type variable: %s', value_set)
+
+        name_value = next(iter(value_set))
+        try:
+            method = name_value.get_safe_value
+        except AttributeError:
+            return None
+        else:
+            safe_value = method(default=None)
+            if self.inference_state.environment.version_info.major == 2:
+                if isinstance(safe_value, bytes):
+                    return force_unicode(safe_value)
+            if isinstance(safe_value, (str, unicode)):
+                return safe_value
+            return None
+
+
+class TypeVar(BaseTypingValue):
+    def __init__(self, parent_context, tree_name, var_name, unpacked_args):
+        super(TypeVar, self).__init__(parent_context, tree_name)
+        self._var_name = var_name
+
+        self._constraints_lazy_values = []
+        self._bound_lazy_value = None
+        self._covariant_lazy_value = None
+        self._contravariant_lazy_value = None
+        for key, lazy_value in unpacked_args:
+            if key is None:
+                self._constraints_lazy_values.append(lazy_value)
+            else:
+                if key == 'bound':
+                    self._bound_lazy_value = lazy_value
+                elif key == 'covariant':
+                    self._covariant_lazy_value = lazy_value
+                elif key == 'contravariant':
+                    self._contra_variant_lazy_value = lazy_value
+                else:
+                    debug.warning('Invalid TypeVar param name %s', key)
+
+    def py__name__(self):
+        return self._var_name
+
+    def get_filters(self, *args, **kwargs):
+        return iter([])
+
+    def _get_classes(self):
+        if self._bound_lazy_value is not None:
+            return self._bound_lazy_value.infer()
+        if self._constraints_lazy_values:
+            return self.constraints
+        debug.warning('Tried to infer the TypeVar %s without a given type', self._var_name)
+        return NO_VALUES
+
+    def is_same_class(self, other):
+        # Everything can match an undefined type var.
+        return True
+
+    @property
+    def constraints(self):
+        return ValueSet.from_sets(
+            lazy.infer() for lazy in self._constraints_lazy_values
+        )
+
+    def define_generics(self, type_var_dict):
+        try:
+            found = type_var_dict[self.py__name__()]
+        except KeyError:
+            pass
+        else:
+            if found:
+                return found
+        return ValueSet({self})
+
+    def execute_annotation(self):
+        return self._get_classes().execute_annotation()
+
+    def infer_type_vars(self, value_set):
+        def iterate():
+            for v in value_set:
+                cls = v.py__class__()
+                if v.is_function() or v.is_class():
+                    cls = TypeWrapper(cls, v)
+                yield cls
+
+        annotation_name = self.py__name__()
+        return {annotation_name: ValueSet(iterate())}
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self.py__name__())
+
+
+class TypeWrapper(ValueWrapper):
+    def __init__(self, wrapped_value, original_value):
+        super(TypeWrapper, self).__init__(wrapped_value)
+        self._original_value = original_value
+
+    def execute_annotation(self):
+        return ValueSet({self._original_value})

venv/Lib/site-packages/jedi/inference/gradual/typeshed.py

@@ -0,0 +1,312 @@
+import os
+import re
+from functools import wraps
+from collections import namedtuple
+
+from jedi import settings
+from jedi.file_io import FileIO
+from jedi._compatibility import FileNotFoundError, cast_path
+from jedi.parser_utils import get_cached_code_lines
+from jedi.inference.base_value import ValueSet, NO_VALUES
+from jedi.inference.gradual.stub_value import TypingModuleWrapper, StubModuleValue
+from jedi.inference.value import ModuleValue
+
+_jedi_path = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+TYPESHED_PATH = os.path.join(_jedi_path, 'third_party', 'typeshed')
+DJANGO_INIT_PATH = os.path.join(_jedi_path, 'third_party', 'django-stubs',
+                                'django-stubs', '__init__.pyi')
+
+_IMPORT_MAP = dict(
+    _collections='collections',
+    _socket='socket',
+)
+
+PathInfo = namedtuple('PathInfo', 'path is_third_party')
+
+
+def _merge_create_stub_map(path_infos):
+    map_ = {}
+    for directory_path_info in path_infos:
+        map_.update(_create_stub_map(directory_path_info))
+    return map_
+
+
+def _create_stub_map(directory_path_info):
+    """
+    Create a mapping of an importable name in Python to a stub file.
+    """
+    def generate():
+        try:
+            listed = os.listdir(directory_path_info.path)
+        except (FileNotFoundError, OSError):
+            # OSError is Python 2
+            return
+
+        for entry in listed:
+            entry = cast_path(entry)
+            path = os.path.join(directory_path_info.path, entry)
+            if os.path.isdir(path):
+                init = os.path.join(path, '__init__.pyi')
+                if os.path.isfile(init):
+                    yield entry, PathInfo(init, directory_path_info.is_third_party)
+            elif entry.endswith('.pyi') and os.path.isfile(path):
+                name = entry[:-4]
+                if name != '__init__':
+                    yield name, PathInfo(path, directory_path_info.is_third_party)
+
+    # Create a dictionary from the tuple generator.
+    return dict(generate())
+
+
+def _get_typeshed_directories(version_info):
+    check_version_list = ['2and3', str(version_info.major)]
+    for base in ['stdlib', 'third_party']:
+        base_path = os.path.join(TYPESHED_PATH, base)
+        base_list = os.listdir(base_path)
+        for base_list_entry in base_list:
+            match = re.match(r'(\d+)\.(\d+)$', base_list_entry)
+            if match is not None:
+                if int(match.group(1)) == version_info.major \
+                        and int(match.group(2)) <= version_info.minor:
+                    check_version_list.append(base_list_entry)
+
+        for check_version in check_version_list:
+            is_third_party = base != 'stdlib'
+            yield PathInfo(os.path.join(base_path, check_version), is_third_party)
+
+
+_version_cache = {}
+
+
+def _cache_stub_file_map(version_info):
+    """
+    Returns a map of an importable name in Python to a stub file.
+    """
+    # TODO this caches the stub files indefinitely, maybe use a time cache
+    # for that?
+    version = version_info[:2]
+    try:
+        return _version_cache[version]
+    except KeyError:
+        pass
+
+    _version_cache[version] = file_set = \
+        _merge_create_stub_map(_get_typeshed_directories(version_info))
+    return file_set
+
+
+def import_module_decorator(func):
+    @wraps(func)
+    def wrapper(inference_state, import_names, parent_module_value, sys_path, prefer_stubs):
+        python_value_set = inference_state.module_cache.get(import_names)
+        if python_value_set is None:
+            if parent_module_value is not None and parent_module_value.is_stub():
+                parent_module_values = parent_module_value.non_stub_value_set
+            else:
+                parent_module_values = [parent_module_value]
+            if import_names == ('os', 'path'):
+                # This is a huge exception, we follow a nested import
+                # ``os.path``, because it's a very important one in Python
+                # that is being achieved by messing with ``sys.modules`` in
+                # ``os``.
+                python_value_set = ValueSet.from_sets(
+                    func(inference_state, (n,), None, sys_path,)
+                    for n in [u'posixpath', u'ntpath', u'macpath', u'os2emxpath']
+                )
+            else:
+                python_value_set = ValueSet.from_sets(
+                    func(inference_state, import_names, p, sys_path,)
+                    for p in parent_module_values
+                )
+            inference_state.module_cache.add(import_names, python_value_set)
+
+        if not prefer_stubs:
+            return python_value_set
+
+        stub = try_to_load_stub_cached(inference_state, import_names, python_value_set,
+                                       parent_module_value, sys_path)
+        if stub is not None:
+            return ValueSet([stub])
+        return python_value_set
+
+    return wrapper
+
+
+def try_to_load_stub_cached(inference_state, import_names, *args, **kwargs):
+    if import_names is None:
+        return None
+
+    try:
+        return inference_state.stub_module_cache[import_names]
+    except KeyError:
+        pass
+
+    # TODO is this needed? where are the exceptions coming from that make this
+    # necessary? Just remove this line.
+    inference_state.stub_module_cache[import_names] = None
+    inference_state.stub_module_cache[import_names] = result = \
+        _try_to_load_stub(inference_state, import_names, *args, **kwargs)
+    return result
+
+
+def _try_to_load_stub(inference_state, import_names, python_value_set,
+                      parent_module_value, sys_path):
+    """
+    Trying to load a stub for a set of import_names.
+
+    This is modelled to work like "PEP 561 -- Distributing and Packaging Type
+    Information", see https://www.python.org/dev/peps/pep-0561.
+    """
+    if parent_module_value is None and len(import_names) > 1:
+        try:
+            parent_module_value = try_to_load_stub_cached(
+                inference_state, import_names[:-1], NO_VALUES,
+                parent_module_value=None, sys_path=sys_path)
+        except KeyError:
+            pass
+
+    # 1. Try to load foo-stubs folders on path for import name foo.
+    if len(import_names) == 1:
+        # foo-stubs
+        for p in sys_path:
+            p = cast_path(p)
+            init = os.path.join(p, *import_names) + '-stubs' + os.path.sep + '__init__.pyi'
+            m = _try_to_load_stub_from_file(
+                inference_state,
+                python_value_set,
+                file_io=FileIO(init),
+                import_names=import_names,
+            )
+            if m is not None:
+                return m
+        if import_names[0] == 'django' and python_value_set:
+            return _try_to_load_stub_from_file(
+                inference_state,
+                python_value_set,
+                file_io=FileIO(DJANGO_INIT_PATH),
+                import_names=import_names,
+            )
+
+    # 2. Try to load pyi files next to py files.
+    for c in python_value_set:
+        try:
+            method = c.py__file__
+        except AttributeError:
+            pass
+        else:
+            file_path = method()
+            file_paths = []
+            if c.is_namespace():
+                file_paths = [os.path.join(p, '__init__.pyi') for p in c.py__path__()]
+            elif file_path is not None and file_path.endswith('.py'):
+                file_paths = [file_path + 'i']
+
+            for file_path in file_paths:
+                m = _try_to_load_stub_from_file(
+                    inference_state,
+                    python_value_set,
+                    # The file path should end with .pyi
+                    file_io=FileIO(file_path),
+                    import_names=import_names,
+                )
+                if m is not None:
+                    return m
+
+    # 3. Try to load typeshed
+    m = _load_from_typeshed(inference_state, python_value_set, parent_module_value, import_names)
+    if m is not None:
+        return m
+
+    # 4. Try to load pyi file somewhere if python_value_set was not defined.
+    if not python_value_set:
+        if parent_module_value is not None:
+            check_path = parent_module_value.py__path__() or []
+            # In case import_names
+            names_for_path = (import_names[-1],)
+        else:
+            check_path = sys_path
+            names_for_path = import_names
+
+        for p in check_path:
+            m = _try_to_load_stub_from_file(
+                inference_state,
+                python_value_set,
+                file_io=FileIO(os.path.join(p, *names_for_path) + '.pyi'),
+                import_names=import_names,
+            )
+            if m is not None:
+                return m
+
+    # If no stub is found, that's fine, the calling function has to deal with
+    # it.
+    return None
+
+
+def _load_from_typeshed(inference_state, python_value_set, parent_module_value, import_names):
+    import_name = import_names[-1]
+    map_ = None
+    if len(import_names) == 1:
+        map_ = _cache_stub_file_map(inference_state.grammar.version_info)
+        import_name = _IMPORT_MAP.get(import_name, import_name)
+    elif isinstance(parent_module_value, ModuleValue):
+        if not parent_module_value.is_package():
+            # Only if it's a package (= a folder) something can be
+            # imported.
+            return None
+        paths = parent_module_value.py__path__()
+        # Once the initial package has been loaded, the sub packages will
+        # always be loaded, regardless if they are there or not. This makes
+        # sense, IMO, because stubs take preference, even if the original
+        # library doesn't provide a module (it could be dynamic). ~dave
+        map_ = _merge_create_stub_map([PathInfo(p, is_third_party=False) for p in paths])
+
+    if map_ is not None:
+        path_info = map_.get(import_name)
+        if path_info is not None and (not path_info.is_third_party or python_value_set):
+            return _try_to_load_stub_from_file(
+                inference_state,
+                python_value_set,
+                file_io=FileIO(path_info.path),
+                import_names=import_names,
+            )
+
+
+def _try_to_load_stub_from_file(inference_state, python_value_set, file_io, import_names):
+    try:
+        stub_module_node = parse_stub_module(inference_state, file_io)
+    except (OSError, IOError):  # IOError is Python 2 only
+        # The file that you're looking for doesn't exist (anymore).
+        return None
+    else:
+        return create_stub_module(
+            inference_state, python_value_set, stub_module_node, file_io,
+            import_names
+        )
+
+
+def parse_stub_module(inference_state, file_io):
+    return inference_state.parse(
+        file_io=file_io,
+        cache=True,
+        diff_cache=settings.fast_parser,
+        cache_path=settings.cache_directory,
+        use_latest_grammar=True
+    )
+
+
+def create_stub_module(inference_state, python_value_set, stub_module_node, file_io, import_names):
+    if import_names == ('typing',):
+        module_cls = TypingModuleWrapper
+    else:
+        module_cls = StubModuleValue
+    file_name = os.path.basename(file_io.path)
+    stub_module_value = module_cls(
+        python_value_set, inference_state, stub_module_node,
+        file_io=file_io,
+        string_names=import_names,
+        # The code was loaded with latest_grammar, so use
+        # that.
+        code_lines=get_cached_code_lines(inference_state.latest_grammar, file_io.path),
+        is_package=file_name == '__init__.pyi',
+    )
+    return stub_module_value

venv/Lib/site-packages/jedi/inference/gradual/typing.py

@@ -0,0 +1,485 @@
+"""
+We need to somehow work with the typing objects. Since the typing objects are
+pretty bare we need to add all the Jedi customizations to make them work as
+values.
+
+This file deals with all the typing.py cases.
+"""
+import itertools
+
+from jedi._compatibility import unicode
+from jedi import debug
+from jedi.inference.compiled import builtin_from_name, create_simple_object
+from jedi.inference.base_value import ValueSet, NO_VALUES, Value, \
+    LazyValueWrapper
+from jedi.inference.lazy_value import LazyKnownValues
+from jedi.inference.arguments import repack_with_argument_clinic
+from jedi.inference.filters import FilterWrapper
+from jedi.inference.names import NameWrapper, ValueName
+from jedi.inference.value.klass import ClassMixin
+from jedi.inference.gradual.base import BaseTypingValue, \
+    BaseTypingClassWithGenerics, BaseTypingInstance
+from jedi.inference.gradual.type_var import TypeVarClass
+from jedi.inference.gradual.generics import LazyGenericManager, TupleGenericManager
+
+_PROXY_CLASS_TYPES = 'Tuple Generic Protocol Callable Type'.split()
+_TYPE_ALIAS_TYPES = {
+    'List': 'builtins.list',
+    'Dict': 'builtins.dict',
+    'Set': 'builtins.set',
+    'FrozenSet': 'builtins.frozenset',
+    'ChainMap': 'collections.ChainMap',
+    'Counter': 'collections.Counter',
+    'DefaultDict': 'collections.defaultdict',
+    'Deque': 'collections.deque',
+}
+_PROXY_TYPES = 'Optional Union ClassVar'.split()
+
+
+class TypingModuleName(NameWrapper):
+    def infer(self):
+        return ValueSet(self._remap())
+
+    def _remap(self):
+        name = self.string_name
+        inference_state = self.parent_context.inference_state
+        try:
+            actual = _TYPE_ALIAS_TYPES[name]
+        except KeyError:
+            pass
+        else:
+            yield TypeAlias.create_cached(
+                inference_state, self.parent_context, self.tree_name, actual)
+            return
+
+        if name in _PROXY_CLASS_TYPES:
+            yield ProxyTypingClassValue.create_cached(
+                inference_state, self.parent_context, self.tree_name)
+        elif name in _PROXY_TYPES:
+            yield ProxyTypingValue.create_cached(
+                inference_state, self.parent_context, self.tree_name)
+        elif name == 'runtime':
+            # We don't want anything here, not sure what this function is
+            # supposed to do, since it just appears in the stubs and shouldn't
+            # have any effects there (because it's never executed).
+            return
+        elif name == 'TypeVar':
+            yield TypeVarClass.create_cached(
+                inference_state, self.parent_context, self.tree_name)
+        elif name == 'Any':
+            yield AnyClass.create_cached(
+                inference_state, self.parent_context, self.tree_name)
+        elif name == 'TYPE_CHECKING':
+            # This is needed for e.g. imports that are only available for type
+            # checking or are in cycles. The user can then check this variable.
+            yield builtin_from_name(inference_state, u'True')
+        elif name == 'overload':
+            yield OverloadFunction.create_cached(
+                inference_state, self.parent_context, self.tree_name)
+        elif name == 'NewType':
+            yield NewTypeFunction.create_cached(
+                inference_state, self.parent_context, self.tree_name)
+        elif name == 'cast':
+            yield CastFunction.create_cached(
+                inference_state, self.parent_context, self.tree_name)
+        elif name == 'TypedDict':
+            # TODO doesn't even exist in typeshed/typing.py, yet. But will be
+            # added soon.
+            yield TypedDictClass.create_cached(
+                inference_state, self.parent_context, self.tree_name)
+        elif name in ('no_type_check', 'no_type_check_decorator'):
+            # This is not necessary, as long as we are not doing type checking.
+            for c in self._wrapped_name.infer():  # Fuck my life Python 2
+                yield c
+        else:
+            # Everything else shouldn't be relevant for type checking.
+            for c in self._wrapped_name.infer():  # Fuck my life Python 2
+                yield c
+
+
+class TypingModuleFilterWrapper(FilterWrapper):
+    name_wrapper_class = TypingModuleName
+
+
+class ProxyWithGenerics(BaseTypingClassWithGenerics):
+    def execute_annotation(self):
+        string_name = self._tree_name.value
+
+        if string_name == 'Union':
+            # This is kind of a special case, because we have Unions (in Jedi
+            # ValueSets).
+            return self.gather_annotation_classes().execute_annotation()
+        elif string_name == 'Optional':
+            # Optional is basically just saying it's either None or the actual
+            # type.
+            return self.gather_annotation_classes().execute_annotation() \
+                | ValueSet([builtin_from_name(self.inference_state, u'None')])
+        elif string_name == 'Type':
+            # The type is actually already given in the index_value
+            return self._generics_manager[0]
+        elif string_name == 'ClassVar':
+            # For now don't do anything here, ClassVars are always used.
+            return self._generics_manager[0].execute_annotation()
+
+        mapped = {
+            'Tuple': Tuple,
+            'Generic': Generic,
+            'Protocol': Protocol,
+            'Callable': Callable,
+        }
+        cls = mapped[string_name]
+        return ValueSet([cls(
+            self.parent_context,
+            self,
+            self._tree_name,
+            generics_manager=self._generics_manager,
+        )])
+
+    def gather_annotation_classes(self):
+        return ValueSet.from_sets(self._generics_manager.to_tuple())
+
+    def _create_instance_with_generics(self, generics_manager):
+        return ProxyWithGenerics(
+            self.parent_context,
+            self._tree_name,
+            generics_manager
+        )
+
+    def infer_type_vars(self, value_set):
+        annotation_generics = self.get_generics()
+
+        if not annotation_generics:
+            return {}
+
+        annotation_name = self.py__name__()
+        if annotation_name == 'Optional':
+            # Optional[T] is equivalent to Union[T, None]. In Jedi unions
+            # are represented by members within a ValueSet, so we extract
+            # the T from the Optional[T] by removing the None value.
+            none = builtin_from_name(self.inference_state, u'None')
+            return annotation_generics[0].infer_type_vars(
+                value_set.filter(lambda x: x != none),
+            )
+
+        return {}
+
+
+class ProxyTypingValue(BaseTypingValue):
+    index_class = ProxyWithGenerics
+
+    def with_generics(self, generics_tuple):
+        return self.index_class.create_cached(
+            self.inference_state,
+            self.parent_context,
+            self._tree_name,
+            generics_manager=TupleGenericManager(generics_tuple)
+        )
+
+    def py__getitem__(self, index_value_set, contextualized_node):
+        return ValueSet(
+            self.index_class.create_cached(
+                self.inference_state,
+                self.parent_context,
+                self._tree_name,
+                generics_manager=LazyGenericManager(
+                    context_of_index=contextualized_node.context,
+                    index_value=index_value,
+                )
+            ) for index_value in index_value_set
+        )
+
+
+class _TypingClassMixin(ClassMixin):
+    def py__bases__(self):
+        return [LazyKnownValues(
+            self.inference_state.builtins_module.py__getattribute__('object')
+        )]
+
+    def get_metaclasses(self):
+        return []
+
+    @property
+    def name(self):
+        return ValueName(self, self._tree_name)
+
+
+class TypingClassWithGenerics(ProxyWithGenerics, _TypingClassMixin):
+    def infer_type_vars(self, value_set):
+        type_var_dict = {}
+        annotation_generics = self.get_generics()
+
+        if not annotation_generics:
+            return type_var_dict
+
+        annotation_name = self.py__name__()
+        if annotation_name == 'Type':
+            return annotation_generics[0].infer_type_vars(
+                # This is basically a trick to avoid extra code: We execute the
+                # incoming classes to be able to use the normal code for type
+                # var inference.
+                value_set.execute_annotation(),
+            )
+
+        elif annotation_name == 'Callable':
+            if len(annotation_generics) == 2:
+                return annotation_generics[1].infer_type_vars(
+                    value_set.execute_annotation(),
+                )
+
+        elif annotation_name == 'Tuple':
+            tuple_annotation, = self.execute_annotation()
+            return tuple_annotation.infer_type_vars(value_set)
+
+        return type_var_dict
+
+    def _create_instance_with_generics(self, generics_manager):
+        return TypingClassWithGenerics(
+            self.parent_context,
+            self._tree_name,
+            generics_manager
+        )
+
+
+class ProxyTypingClassValue(ProxyTypingValue, _TypingClassMixin):
+    index_class = TypingClassWithGenerics
+
+
+class TypeAlias(LazyValueWrapper):
+    def __init__(self, parent_context, origin_tree_name, actual):
+        self.inference_state = parent_context.inference_state
+        self.parent_context = parent_context
+        self._origin_tree_name = origin_tree_name
+        self._actual = actual  # e.g. builtins.list
+
+    @property
+    def name(self):
+        return ValueName(self, self._origin_tree_name)
+
+    def py__name__(self):
+        return self.name.string_name
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self._actual)
+
+    def _get_wrapped_value(self):
+        module_name, class_name = self._actual.split('.')
+        if self.inference_state.environment.version_info.major == 2 and module_name == 'builtins':
+            module_name = '__builtin__'
+
+        # TODO use inference_state.import_module?
+        from jedi.inference.imports import Importer
+        module, = Importer(
+            self.inference_state, [module_name], self.inference_state.builtins_module
+        ).follow()
+        classes = module.py__getattribute__(class_name)
+        # There should only be one, because it's code that we control.
+        assert len(classes) == 1, classes
+        cls = next(iter(classes))
+        return cls
+
+    def gather_annotation_classes(self):
+        return ValueSet([self._get_wrapped_value()])
+
+
+class Callable(BaseTypingInstance):
+    def py__call__(self, arguments):
+        """
+            def x() -> Callable[[Callable[..., _T]], _T]: ...
+        """
+        # The 0th index are the arguments.
+        try:
+            param_values = self._generics_manager[0]
+            result_values = self._generics_manager[1]
+        except IndexError:
+            debug.warning('Callable[...] defined without two arguments')
+            return NO_VALUES
+        else:
+            from jedi.inference.gradual.annotation import infer_return_for_callable
+            return infer_return_for_callable(arguments, param_values, result_values)
+
+
+class Tuple(BaseTypingInstance):
+    def _is_homogenous(self):
+        # To specify a variable-length tuple of homogeneous type, Tuple[T, ...]
+        # is used.
+        return self._generics_manager.is_homogenous_tuple()
+
+    def py__simple_getitem__(self, index):
+        if self._is_homogenous():
+            return self._generics_manager.get_index_and_execute(0)
+        else:
+            if isinstance(index, int):
+                return self._generics_manager.get_index_and_execute(index)
+
+            debug.dbg('The getitem type on Tuple was %s' % index)
+            return NO_VALUES
+
+    def py__iter__(self, contextualized_node=None):
+        if self._is_homogenous():
+            yield LazyKnownValues(self._generics_manager.get_index_and_execute(0))
+        else:
+            for v in self._generics_manager.to_tuple():
+                yield LazyKnownValues(v.execute_annotation())
+
+    def py__getitem__(self, index_value_set, contextualized_node):
+        if self._is_homogenous():
+            return self._generics_manager.get_index_and_execute(0)
+
+        return ValueSet.from_sets(
+            self._generics_manager.to_tuple()
+        ).execute_annotation()
+
+    def _get_wrapped_value(self):
+        tuple_, = self.inference_state.builtins_module \
+            .py__getattribute__('tuple').execute_annotation()
+        return tuple_
+
+    @property
+    def name(self):
+        return self._wrapped_value.name
+
+    def infer_type_vars(self, value_set):
+        # Circular
+        from jedi.inference.gradual.annotation import merge_pairwise_generics, merge_type_var_dicts
+
+        value_set = value_set.filter(
+            lambda x: x.py__name__().lower() == 'tuple',
+        )
+
+        if self._is_homogenous():
+            # The parameter annotation is of the form `Tuple[T, ...]`,
+            # so we treat the incoming tuple like a iterable sequence
+            # rather than a positional container of elements.
+            return self._class_value.get_generics()[0].infer_type_vars(
+                value_set.merge_types_of_iterate(),
+            )
+
+        else:
+            # The parameter annotation has only explicit type parameters
+            # (e.g: `Tuple[T]`, `Tuple[T, U]`, `Tuple[T, U, V]`, etc.) so we
+            # treat the incoming values as needing to match the annotation
+            # exactly, just as we would for non-tuple annotations.
+
+            type_var_dict = {}
+            for element in value_set:
+                try:
+                    method = element.get_annotated_class_object
+                except AttributeError:
+                    # This might still happen, because the tuple name matching
+                    # above is not 100% correct, so just catch the remaining
+                    # cases here.
+                    continue
+
+                py_class = method()
+                merge_type_var_dicts(
+                    type_var_dict,
+                    merge_pairwise_generics(self._class_value, py_class),
+                )
+
+            return type_var_dict
+
+
+class Generic(BaseTypingInstance):
+    pass
+
+
+class Protocol(BaseTypingInstance):
+    pass
+
+
+class AnyClass(BaseTypingValue):
+    def execute_annotation(self):
+        debug.warning('Used Any - returned no results')
+        return NO_VALUES
+
+
+class OverloadFunction(BaseTypingValue):
+    @repack_with_argument_clinic('func, /')
+    def py__call__(self, func_value_set):
+        # Just pass arguments through.
+        return func_value_set
+
+
+class NewTypeFunction(BaseTypingValue):
+    def py__call__(self, arguments):
+        ordered_args = arguments.unpack()
+        next(ordered_args, (None, None))
+        _, second_arg = next(ordered_args, (None, None))
+        if second_arg is None:
+            return NO_VALUES
+        return ValueSet(
+            NewType(
+                self.inference_state,
+                contextualized_node.context,
+                contextualized_node.node,
+                second_arg.infer(),
+            ) for contextualized_node in arguments.get_calling_nodes())
+
+
+class NewType(Value):
+    def __init__(self, inference_state, parent_context, tree_node, type_value_set):
+        super(NewType, self).__init__(inference_state, parent_context)
+        self._type_value_set = type_value_set
+        self.tree_node = tree_node
+
+    def py__class__(self):
+        c, = self._type_value_set.py__class__()
+        return c
+
+    def py__call__(self, arguments):
+        return self._type_value_set.execute_annotation()
+
+    @property
+    def name(self):
+        from jedi.inference.compiled.value import CompiledValueName
+        return CompiledValueName(self, 'NewType')
+
+
+class CastFunction(BaseTypingValue):
+    @repack_with_argument_clinic('type, object, /')
+    def py__call__(self, type_value_set, object_value_set):
+        return type_value_set.execute_annotation()
+
+
+class TypedDictClass(BaseTypingValue):
+    """
+    This class has no responsibilities and is just here to make sure that typed
+    dicts can be identified.
+    """
+
+
+class TypedDict(LazyValueWrapper):
+    """Represents the instance version of ``TypedDictClass``."""
+    def __init__(self, definition_class):
+        self.inference_state = definition_class.inference_state
+        self.parent_context = definition_class.parent_context
+        self.tree_node = definition_class.tree_node
+        self._definition_class = definition_class
+
+    @property
+    def name(self):
+        return ValueName(self, self.tree_node.name)
+
+    def py__simple_getitem__(self, index):
+        if isinstance(index, unicode):
+            return ValueSet.from_sets(
+                name.infer()
+                for filter in self._definition_class.get_filters(is_instance=True)
+                for name in filter.get(index)
+            )
+        return NO_VALUES
+
+    def get_key_values(self):
+        filtered_values = itertools.chain.from_iterable((
+            f.values()
+            for f in self._definition_class.get_filters(is_instance=True)
+        ))
+        return ValueSet({
+            create_simple_object(self.inference_state, v.string_name)
+            for v in filtered_values
+        })
+
+    def _get_wrapped_value(self):
+        d, = self.inference_state.builtins_module.py__getattribute__('dict')
+        result, = d.execute_with_values()
+        return result

venv/Lib/site-packages/jedi/inference/gradual/utils.py

@@ -0,0 +1,30 @@
+import os
+
+from jedi.inference.gradual.typeshed import TYPESHED_PATH, create_stub_module
+
+
+def load_proper_stub_module(inference_state, file_io, import_names, module_node):
+    """
+    This function is given a random .pyi file and should return the proper
+    module.
+    """
+    path = file_io.path
+    assert path.endswith('.pyi')
+    if path.startswith(TYPESHED_PATH):
+        # /foo/stdlib/3/os/__init__.pyi -> stdlib/3/os/__init__
+        rest = path[len(TYPESHED_PATH) + 1: -4]
+        split_paths = tuple(rest.split(os.path.sep))
+        # Remove the stdlib/3 or third_party/3.5 part
+        import_names = split_paths[2:]
+        if import_names[-1] == '__init__':
+            import_names = import_names[:-1]
+
+    if import_names is not None:
+        actual_value_set = inference_state.import_module(import_names, prefer_stubs=False)
+
+        stub = create_stub_module(
+            inference_state, actual_value_set, module_node, file_io, import_names
+        )
+        inference_state.stub_module_cache[import_names] = stub
+        return stub
+    return None

venv/Lib/site-packages/jedi/inference/helpers.py

@@ -0,0 +1,207 @@
+import copy
+import sys
+import re
+import os
+from itertools import chain
+from contextlib import contextmanager
+
+from parso.python import tree
+
+from jedi._compatibility import unicode
+
+
+def is_stdlib_path(path):
+    # Python standard library paths look like this:
+    # /usr/lib/python3.5/...
+    # TODO The implementation below is probably incorrect and not complete.
+    if 'dist-packages' in path or 'site-packages' in path:
+        return False
+
+    base_path = os.path.join(sys.prefix, 'lib', 'python')
+    return bool(re.match(re.escape(base_path) + r'\d.\d', path))
+
+
+def deep_ast_copy(obj):
+    """
+    Much, much faster than copy.deepcopy, but just for parser tree nodes.
+    """
+    # If it's already in the cache, just return it.
+    new_obj = copy.copy(obj)
+
+    # Copy children
+    new_children = []
+    for child in obj.children:
+        if isinstance(child, tree.Leaf):
+            new_child = copy.copy(child)
+            new_child.parent = new_obj
+        else:
+            new_child = deep_ast_copy(child)
+            new_child.parent = new_obj
+        new_children.append(new_child)
+    new_obj.children = new_children
+
+    return new_obj
+
+
+def infer_call_of_leaf(context, leaf, cut_own_trailer=False):
+    """
+    Creates a "call" node that consist of all ``trailer`` and ``power``
+    objects.  E.g. if you call it with ``append``::
+
+        list([]).append(3) or None
+
+    You would get a node with the content ``list([]).append`` back.
+
+    This generates a copy of the original ast node.
+
+    If you're using the leaf, e.g. the bracket `)` it will return ``list([])``.
+
+    We use this function for two purposes. Given an expression ``bar.foo``,
+    we may want to
+      - infer the type of ``foo`` to offer completions after foo
+      - infer the type of ``bar`` to be able to jump to the definition of foo
+    The option ``cut_own_trailer`` must be set to true for the second purpose.
+    """
+    trailer = leaf.parent
+    if trailer.type == 'fstring':
+        from jedi.inference import compiled
+        return compiled.get_string_value_set(context.inference_state)
+
+    # The leaf may not be the last or first child, because there exist three
+    # different trailers: `( x )`, `[ x ]` and `.x`. In the first two examples
+    # we should not match anything more than x.
+    if trailer.type != 'trailer' or leaf not in (trailer.children[0], trailer.children[-1]):
+        if leaf == ':':
+            # Basically happens with foo[:] when the cursor is on the colon
+            from jedi.inference.base_value import NO_VALUES
+            return NO_VALUES
+        if trailer.type == 'atom':
+            return context.infer_node(trailer)
+        return context.infer_node(leaf)
+
+    power = trailer.parent
+    index = power.children.index(trailer)
+    if cut_own_trailer:
+        cut = index
+    else:
+        cut = index + 1
+
+    if power.type == 'error_node':
+        start = index
+        while True:
+            start -= 1
+            base = power.children[start]
+            if base.type != 'trailer':
+                break
+        trailers = power.children[start + 1:cut]
+    else:
+        base = power.children[0]
+        trailers = power.children[1:cut]
+
+    if base == 'await':
+        base = trailers[0]
+        trailers = trailers[1:]
+
+    values = context.infer_node(base)
+    from jedi.inference.syntax_tree import infer_trailer
+    for trailer in trailers:
+        values = infer_trailer(context, values, trailer)
+    return values
+
+
+def get_names_of_node(node):
+    try:
+        children = node.children
+    except AttributeError:
+        if node.type == 'name':
+            return [node]
+        else:
+            return []
+    else:
+        return list(chain.from_iterable(get_names_of_node(c) for c in children))
+
+
+def is_string(value):
+    if value.inference_state.environment.version_info.major == 2:
+        str_classes = (unicode, bytes)
+    else:
+        str_classes = (unicode,)
+    return value.is_compiled() and isinstance(value.get_safe_value(default=None), str_classes)
+
+
+def is_literal(value):
+    return is_number(value) or is_string(value)
+
+
+def _get_safe_value_or_none(value, accept):
+    value = value.get_safe_value(default=None)
+    if isinstance(value, accept):
+        return value
+
+
+def get_int_or_none(value):
+    return _get_safe_value_or_none(value, int)
+
+
+def get_str_or_none(value):
+    return _get_safe_value_or_none(value, (bytes, unicode))
+
+
+def is_number(value):
+    return _get_safe_value_or_none(value, (int, float)) is not None
+
+
+class SimpleGetItemNotFound(Exception):
+    pass
+
+
+@contextmanager
+def reraise_getitem_errors(*exception_classes):
+    try:
+        yield
+    except exception_classes as e:
+        raise SimpleGetItemNotFound(e)
+
+
+def parse_dotted_names(nodes, is_import_from, until_node=None):
+    level = 0
+    names = []
+    for node in nodes[1:]:
+        if node in ('.', '...'):
+            if not names:
+                level += len(node.value)
+        elif node.type == 'dotted_name':
+            for n in node.children[::2]:
+                names.append(n)
+                if n is until_node:
+                    break
+            else:
+                continue
+            break
+        elif node.type == 'name':
+            names.append(node)
+            if node is until_node:
+                break
+        elif node == ',':
+            if not is_import_from:
+                names = []
+        else:
+            # Here if the keyword `import` comes along it stops checking
+            # for names.
+            break
+    return level, names
+
+
+def values_from_qualified_names(inference_state, *names):
+    return inference_state.import_module(names[:-1]).py__getattribute__(names[-1])
+
+
+def is_big_annoying_library(context):
+    string_names = context.get_root_context().string_names
+    if string_names is None:
+        return False
+
+    # Especially pandas and tensorflow are huge complicated Python libraries
+    # that get even slower than they already are when Jedi tries to undrstand
+    # dynamic features like decorators, ifs and other stuff.
+    return string_names[0] in ('pandas', 'numpy', 'tensorflow', 'matplotlib')

venv/Lib/site-packages/jedi/inference/imports.py

@@ -0,0 +1,563 @@
+"""
+:mod:`jedi.inference.imports` is here to resolve import statements and return
+the modules/classes/functions/whatever, which they stand for. However there's
+not any actual importing done. This module is about finding modules in the
+filesystem. This can be quite tricky sometimes, because Python imports are not
+always that simple.
+
+This module uses imp for python up to 3.2 and importlib for python 3.3 on; the
+correct implementation is delegated to _compatibility.
+
+This module also supports import autocompletion, which means to complete
+statements like ``from datetim`` (cursor at the end would return ``datetime``).
+"""
+import os
+
+from parso.python import tree
+from parso.tree import search_ancestor
+
+from jedi._compatibility import ImplicitNSInfo, force_unicode, FileNotFoundError
+from jedi import debug
+from jedi import settings
+from jedi.file_io import FolderIO
+from jedi.parser_utils import get_cached_code_lines
+from jedi.inference import sys_path
+from jedi.inference import helpers
+from jedi.inference import compiled
+from jedi.inference import analysis
+from jedi.inference.utils import unite
+from jedi.inference.cache import inference_state_method_cache
+from jedi.inference.names import ImportName, SubModuleName
+from jedi.inference.base_value import ValueSet, NO_VALUES
+from jedi.inference.gradual.typeshed import import_module_decorator, \
+    create_stub_module, parse_stub_module
+from jedi.plugins import plugin_manager
+
+
+class ModuleCache(object):
+    def __init__(self):
+        self._name_cache = {}
+
+    def add(self, string_names, value_set):
+        if string_names is not None:
+            self._name_cache[string_names] = value_set
+
+    def get(self, string_names):
+        return self._name_cache.get(string_names)
+
+
+# This memoization is needed, because otherwise we will infinitely loop on
+# certain imports.
+@inference_state_method_cache(default=NO_VALUES)
+def infer_import(context, tree_name):
+    module_context = context.get_root_context()
+    from_import_name, import_path, level, values = \
+        _prepare_infer_import(module_context, tree_name)
+    if values:
+
+        if from_import_name is not None:
+            values = values.py__getattribute__(
+                from_import_name,
+                name_context=context,
+                analysis_errors=False
+            )
+
+            if not values:
+                path = import_path + (from_import_name,)
+                importer = Importer(context.inference_state, path, module_context, level)
+                values = importer.follow()
+    debug.dbg('after import: %s', values)
+    return values
+
+
+@inference_state_method_cache(default=[])
+def goto_import(context, tree_name):
+    module_context = context.get_root_context()
+    from_import_name, import_path, level, values = \
+        _prepare_infer_import(module_context, tree_name)
+    if not values:
+        return []
+
+    if from_import_name is not None:
+        names = unite([
+            c.goto(
+                from_import_name,
+                name_context=context,
+                analysis_errors=False
+            ) for c in values
+        ])
+        # Avoid recursion on the same names.
+        if names and not any(n.tree_name is tree_name for n in names):
+            return names
+
+        path = import_path + (from_import_name,)
+        importer = Importer(context.inference_state, path, module_context, level)
+        values = importer.follow()
+    return set(s.name for s in values)
+
+
+def _prepare_infer_import(module_context, tree_name):
+    import_node = search_ancestor(tree_name, 'import_name', 'import_from')
+    import_path = import_node.get_path_for_name(tree_name)
+    from_import_name = None
+    try:
+        from_names = import_node.get_from_names()
+    except AttributeError:
+        # Is an import_name
+        pass
+    else:
+        if len(from_names) + 1 == len(import_path):
+            # We have to fetch the from_names part first and then check
+            # if from_names exists in the modules.
+            from_import_name = import_path[-1]
+            import_path = from_names
+
+    importer = Importer(module_context.inference_state, tuple(import_path),
+                        module_context, import_node.level)
+
+    return from_import_name, tuple(import_path), import_node.level, importer.follow()
+
+
+def _add_error(value, name, message):
+    if hasattr(name, 'parent') and value is not None:
+        analysis.add(value, 'import-error', name, message)
+    else:
+        debug.warning('ImportError without origin: ' + message)
+
+
+def _level_to_base_import_path(project_path, directory, level):
+    """
+    In case the level is outside of the currently known package (something like
+    import .....foo), we can still try our best to help the user for
+    completions.
+    """
+    for i in range(level - 1):
+        old = directory
+        directory = os.path.dirname(directory)
+        if old == directory:
+            return None, None
+
+    d = directory
+    level_import_paths = []
+    # Now that we are on the level that the user wants to be, calculate the
+    # import path for it.
+    while True:
+        if d == project_path:
+            return level_import_paths, d
+        dir_name = os.path.basename(d)
+        if dir_name:
+            level_import_paths.insert(0, dir_name)
+            d = os.path.dirname(d)
+        else:
+            return None, directory
+
+
+class Importer(object):
+    def __init__(self, inference_state, import_path, module_context, level=0):
+        """
+        An implementation similar to ``__import__``. Use `follow`
+        to actually follow the imports.
+
+        *level* specifies whether to use absolute or relative imports. 0 (the
+        default) means only perform absolute imports. Positive values for level
+        indicate the number of parent directories to search relative to the
+        directory of the module calling ``__import__()`` (see PEP 328 for the
+        details).
+
+        :param import_path: List of namespaces (strings or Names).
+        """
+        debug.speed('import %s %s' % (import_path, module_context))
+        self._inference_state = inference_state
+        self.level = level
+        self._module_context = module_context
+
+        self._fixed_sys_path = None
+        self._infer_possible = True
+        if level:
+            base = module_context.get_value().py__package__()
+            # We need to care for two cases, the first one is if it's a valid
+            # Python import. This import has a properly defined module name
+            # chain like `foo.bar.baz` and an import in baz is made for
+            # `..lala.` It can then resolve to `foo.bar.lala`.
+            # The else here is a heuristic for all other cases, if for example
+            # in `foo` you search for `...bar`, it's obviously out of scope.
+            # However since Jedi tries to just do it's best, we help the user
+            # here, because he might have specified something wrong in his
+            # project.
+            if level <= len(base):
+                # Here we basically rewrite the level to 0.
+                base = tuple(base)
+                if level > 1:
+                    base = base[:-level + 1]
+                import_path = base + tuple(import_path)
+            else:
+                path = module_context.py__file__()
+                project_path = self._inference_state.project.path
+                import_path = list(import_path)
+                if path is None:
+                    # If no path is defined, our best guess is that the current
+                    # file is edited by a user on the current working
+                    # directory. We need to add an initial path, because it
+                    # will get removed as the name of the current file.
+                    directory = project_path
+                else:
+                    directory = os.path.dirname(path)
+
+                base_import_path, base_directory = _level_to_base_import_path(
+                    project_path, directory, level,
+                )
+                if base_directory is None:
+                    # Everything is lost, the relative import does point
+                    # somewhere out of the filesystem.
+                    self._infer_possible = False
+                else:
+                    self._fixed_sys_path = [force_unicode(base_directory)]
+
+                if base_import_path is None:
+                    if import_path:
+                        _add_error(
+                            module_context, import_path[0],
+                            message='Attempted relative import beyond top-level package.'
+                        )
+                else:
+                    import_path = base_import_path + import_path
+        self.import_path = import_path
+
+    @property
+    def _str_import_path(self):
+        """Returns the import path as pure strings instead of `Name`."""
+        return tuple(
+            name.value if isinstance(name, tree.Name) else name
+            for name in self.import_path
+        )
+
+    def _sys_path_with_modifications(self, is_completion):
+        if self._fixed_sys_path is not None:
+            return self._fixed_sys_path
+
+        return (
+            # For import completions we don't want to see init paths, but for
+            # inference we want to show the user as much as possible.
+            # See GH #1446.
+            self._inference_state.get_sys_path(add_init_paths=not is_completion)
+            + sys_path.check_sys_path_modifications(self._module_context)
+        )
+
+    def follow(self):
+        if not self.import_path or not self._infer_possible:
+            return NO_VALUES
+
+        # Check caches first
+        from_cache = self._inference_state.stub_module_cache.get(self._str_import_path)
+        if from_cache is not None:
+            return ValueSet({from_cache})
+        from_cache = self._inference_state.module_cache.get(self._str_import_path)
+        if from_cache is not None:
+            return from_cache
+
+        sys_path = self._sys_path_with_modifications(is_completion=False)
+
+        return import_module_by_names(
+            self._inference_state, self.import_path, sys_path, self._module_context
+        )
+
+    def _get_module_names(self, search_path=None, in_module=None):
+        """
+        Get the names of all modules in the search_path. This means file names
+        and not names defined in the files.
+        """
+        if search_path is None:
+            sys_path = self._sys_path_with_modifications(is_completion=True)
+        else:
+            sys_path = search_path
+        return list(iter_module_names(
+            self._inference_state, self._module_context, sys_path,
+            module_cls=ImportName if in_module is None else SubModuleName,
+            add_builtin_modules=search_path is None and in_module is None,
+        ))
+
+    def completion_names(self, inference_state, only_modules=False):
+        """
+        :param only_modules: Indicates wheter it's possible to import a
+            definition that is not defined in a module.
+        """
+        if not self._infer_possible:
+            return []
+
+        names = []
+        if self.import_path:
+            # flask
+            if self._str_import_path == ('flask', 'ext'):
+                # List Flask extensions like ``flask_foo``
+                for mod in self._get_module_names():
+                    modname = mod.string_name
+                    if modname.startswith('flask_'):
+                        extname = modname[len('flask_'):]
+                        names.append(ImportName(self._module_context, extname))
+                # Now the old style: ``flaskext.foo``
+                for dir in self._sys_path_with_modifications(is_completion=True):
+                    flaskext = os.path.join(dir, 'flaskext')
+                    if os.path.isdir(flaskext):
+                        names += self._get_module_names([flaskext])
+
+            values = self.follow()
+            for value in values:
+                # Non-modules are not completable.
+                if value.api_type != 'module':  # not a module
+                    continue
+                if not value.is_compiled():
+                    # sub_modules_dict is not implemented for compiled modules.
+                    names += value.sub_modules_dict().values()
+
+            if not only_modules:
+                from jedi.inference.gradual.conversion import convert_values
+
+                both_values = values | convert_values(values)
+                for c in both_values:
+                    for filter in c.get_filters():
+                        names += filter.values()
+        else:
+            if self.level:
+                # We only get here if the level cannot be properly calculated.
+                names += self._get_module_names(self._fixed_sys_path)
+            else:
+                # This is just the list of global imports.
+                names += self._get_module_names()
+        return names
+
+
+def import_module_by_names(inference_state, import_names, sys_path=None,
+                           module_context=None, prefer_stubs=True):
+    if sys_path is None:
+        sys_path = inference_state.get_sys_path()
+
+    str_import_names = tuple(
+        force_unicode(i.value if isinstance(i, tree.Name) else i)
+        for i in import_names
+    )
+    value_set = [None]
+    for i, name in enumerate(import_names):
+        value_set = ValueSet.from_sets([
+            import_module(
+                inference_state,
+                str_import_names[:i+1],
+                parent_module_value,
+                sys_path,
+                prefer_stubs=prefer_stubs,
+            ) for parent_module_value in value_set
+        ])
+        if not value_set:
+            message = 'No module named ' + '.'.join(str_import_names)
+            if module_context is not None:
+                _add_error(module_context, name, message)
+            else:
+                debug.warning(message)
+            return NO_VALUES
+    return value_set
+
+
+@plugin_manager.decorate()
+@import_module_decorator
+def import_module(inference_state, import_names, parent_module_value, sys_path):
+    """
+    This method is very similar to importlib's `_gcd_import`.
+    """
+    if import_names[0] in settings.auto_import_modules:
+        module = _load_builtin_module(inference_state, import_names, sys_path)
+        if module is None:
+            return NO_VALUES
+        return ValueSet([module])
+
+    module_name = '.'.join(import_names)
+    if parent_module_value is None:
+        # Override the sys.path. It works only good that way.
+        # Injecting the path directly into `find_module` did not work.
+        file_io_or_ns, is_pkg = inference_state.compiled_subprocess.get_module_info(
+            string=import_names[-1],
+            full_name=module_name,
+            sys_path=sys_path,
+            is_global_search=True,
+        )
+        if is_pkg is None:
+            return NO_VALUES
+    else:
+        paths = parent_module_value.py__path__()
+        if paths is None:
+            # The module might not be a package.
+            return NO_VALUES
+
+        for path in paths:
+            # At the moment we are only using one path. So this is
+            # not important to be correct.
+            if not isinstance(path, list):
+                path = [path]
+            file_io_or_ns, is_pkg = inference_state.compiled_subprocess.get_module_info(
+                string=import_names[-1],
+                path=path,
+                full_name=module_name,
+                is_global_search=False,
+            )
+            if is_pkg is not None:
+                break
+        else:
+            return NO_VALUES
+
+    if isinstance(file_io_or_ns, ImplicitNSInfo):
+        from jedi.inference.value.namespace import ImplicitNamespaceValue
+        module = ImplicitNamespaceValue(
+            inference_state,
+            string_names=tuple(file_io_or_ns.name.split('.')),
+            paths=file_io_or_ns.paths,
+        )
+    elif file_io_or_ns is None:
+        module = _load_builtin_module(inference_state, import_names, sys_path)
+        if module is None:
+            return NO_VALUES
+    else:
+        module = _load_python_module(
+            inference_state, file_io_or_ns,
+            import_names=import_names,
+            is_package=is_pkg,
+        )
+
+    if parent_module_value is None:
+        debug.dbg('global search_module %s: %s', import_names[-1], module)
+    else:
+        debug.dbg('search_module %s in paths %s: %s', module_name, paths, module)
+    return ValueSet([module])
+
+
+def _load_python_module(inference_state, file_io,
+                        import_names=None, is_package=False):
+    module_node = inference_state.parse(
+        file_io=file_io,
+        cache=True,
+        diff_cache=settings.fast_parser,
+        cache_path=settings.cache_directory,
+    )
+
+    from jedi.inference.value import ModuleValue
+    return ModuleValue(
+        inference_state, module_node,
+        file_io=file_io,
+        string_names=import_names,
+        code_lines=get_cached_code_lines(inference_state.grammar, file_io.path),
+        is_package=is_package,
+    )
+
+
+def _load_builtin_module(inference_state, import_names=None, sys_path=None):
+    project = inference_state.project
+    if sys_path is None:
+        sys_path = inference_state.get_sys_path()
+    if not project._load_unsafe_extensions:
+        safe_paths = project._get_base_sys_path(inference_state)
+        sys_path = [p for p in sys_path if p in safe_paths]
+
+    dotted_name = '.'.join(import_names)
+    assert dotted_name is not None
+    module = compiled.load_module(inference_state, dotted_name=dotted_name, sys_path=sys_path)
+    if module is None:
+        # The file might raise an ImportError e.g. and therefore not be
+        # importable.
+        return None
+    return module
+
+
+def load_module_from_path(inference_state, file_io, import_names=None, is_package=None):
+    """
+    This should pretty much only be used for get_modules_containing_name. It's
+    here to ensure that a random path is still properly loaded into the Jedi
+    module structure.
+    """
+    path = file_io.path
+    if import_names is None:
+        e_sys_path = inference_state.get_sys_path()
+        import_names, is_package = sys_path.transform_path_to_dotted(e_sys_path, path)
+    else:
+        assert isinstance(is_package, bool)
+
+    is_stub = file_io.path.endswith('.pyi')
+    if is_stub:
+        folder_io = file_io.get_parent_folder()
+        if folder_io.path.endswith('-stubs'):
+            folder_io = FolderIO(folder_io.path[:-6])
+        if file_io.path.endswith('__init__.pyi'):
+            python_file_io = folder_io.get_file_io('__init__.py')
+        else:
+            python_file_io = folder_io.get_file_io(import_names[-1] + '.py')
+
+        try:
+            v = load_module_from_path(
+                inference_state, python_file_io,
+                import_names, is_package=is_package
+            )
+            values = ValueSet([v])
+        except FileNotFoundError:
+            values = NO_VALUES
+
+        return create_stub_module(
+            inference_state, values, parse_stub_module(inference_state, file_io),
+            file_io, import_names
+        )
+    else:
+        module = _load_python_module(
+            inference_state, file_io,
+            import_names=import_names,
+            is_package=is_package,
+        )
+        inference_state.module_cache.add(import_names, ValueSet([module]))
+        return module
+
+
+def load_namespace_from_path(inference_state, folder_io):
+    import_names, is_package = sys_path.transform_path_to_dotted(
+        inference_state.get_sys_path(),
+        folder_io.path
+    )
+    from jedi.inference.value.namespace import ImplicitNamespaceValue
+    return ImplicitNamespaceValue(inference_state, import_names, [folder_io.path])
+
+
+def follow_error_node_imports_if_possible(context, name):
+    error_node = tree.search_ancestor(name, 'error_node')
+    if error_node is not None:
+        # Get the first command start of a started simple_stmt. The error
+        # node is sometimes a small_stmt and sometimes a simple_stmt. Check
+        # for ; leaves that start a new statements.
+        start_index = 0
+        for index, n in enumerate(error_node.children):
+            if n.start_pos > name.start_pos:
+                break
+            if n == ';':
+                start_index = index + 1
+        nodes = error_node.children[start_index:]
+        first_name = nodes[0].get_first_leaf().value
+
+        # Make it possible to infer stuff like `import foo.` or
+        # `from foo.bar`.
+        if first_name in ('from', 'import'):
+            is_import_from = first_name == 'from'
+            level, names = helpers.parse_dotted_names(
+                nodes,
+                is_import_from=is_import_from,
+                until_node=name,
+            )
+            return Importer(
+                context.inference_state, names, context.get_root_context(), level).follow()
+    return None
+
+
+def iter_module_names(inference_state, module_context, search_path,
+                      module_cls=ImportName, add_builtin_modules=True):
+    """
+    Get the names of all modules in the search_path. This means file names
+    and not names defined in the files.
+    """
+    # add builtin module names
+    if add_builtin_modules:
+        for name in inference_state.compiled_subprocess.get_builtin_module_names():
+            yield module_cls(module_context, name)
+
+    for name in inference_state.compiled_subprocess.iter_module_names(search_path):
+        yield module_cls(module_context, name)

venv/Lib/site-packages/jedi/inference/lazy_value.py

@@ -0,0 +1,61 @@
+from jedi.inference.base_value import ValueSet, NO_VALUES
+from jedi.common import monkeypatch
+
+
+class AbstractLazyValue(object):
+    def __init__(self, data, min=1, max=1):
+        self.data = data
+        self.min = min
+        self.max = max
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self.data)
+
+    def infer(self):
+        raise NotImplementedError
+
+
+class LazyKnownValue(AbstractLazyValue):
+    """data is a Value."""
+    def infer(self):
+        return ValueSet([self.data])
+
+
+class LazyKnownValues(AbstractLazyValue):
+    """data is a ValueSet."""
+    def infer(self):
+        return self.data
+
+
+class LazyUnknownValue(AbstractLazyValue):
+    def __init__(self, min=1, max=1):
+        super(LazyUnknownValue, self).__init__(None, min, max)
+
+    def infer(self):
+        return NO_VALUES
+
+
+class LazyTreeValue(AbstractLazyValue):
+    def __init__(self, context, node, min=1, max=1):
+        super(LazyTreeValue, self).__init__(node, min, max)
+        self.context = context
+        # We need to save the predefined names. It's an unfortunate side effect
+        # that needs to be tracked otherwise results will be wrong.
+        self._predefined_names = dict(context.predefined_names)
+
+    def infer(self):
+        with monkeypatch(self.context, 'predefined_names', self._predefined_names):
+            return self.context.infer_node(self.data)
+
+
+def get_merged_lazy_value(lazy_values):
+    if len(lazy_values) > 1:
+        return MergedLazyValues(lazy_values)
+    else:
+        return lazy_values[0]
+
+
+class MergedLazyValues(AbstractLazyValue):
+    """data is a list of lazy values."""
+    def infer(self):
+        return ValueSet.from_sets(l.infer() for l in self.data)

venv/Lib/site-packages/jedi/inference/names.py

@@ -0,0 +1,660 @@
+from abc import abstractmethod
+
+from parso.tree import search_ancestor
+
+from jedi._compatibility import Parameter
+from jedi.parser_utils import find_statement_documentation, clean_scope_docstring
+from jedi.inference.utils import unite
+from jedi.inference.base_value import ValueSet, NO_VALUES
+from jedi.inference import docstrings
+from jedi.cache import memoize_method
+from jedi.inference.helpers import deep_ast_copy, infer_call_of_leaf
+from jedi.plugins import plugin_manager
+
+
+def _merge_name_docs(names):
+    doc = ''
+    for name in names:
+        if doc:
+            # In case we have multiple values, just return all of them
+            # separated by a few dashes.
+            doc += '\n' + '-' * 30 + '\n'
+        doc += name.py__doc__()
+    return doc
+
+
+class AbstractNameDefinition(object):
+    start_pos = None
+    string_name = None
+    parent_context = None
+    tree_name = None
+    is_value_name = True
+    """
+    Used for the Jedi API to know if it's a keyword or an actual name.
+    """
+
+    @abstractmethod
+    def infer(self):
+        raise NotImplementedError
+
+    @abstractmethod
+    def goto(self):
+        # Typically names are already definitions and therefore a goto on that
+        # name will always result on itself.
+        return {self}
+
+    def get_qualified_names(self, include_module_names=False):
+        qualified_names = self._get_qualified_names()
+        if qualified_names is None or not include_module_names:
+            return qualified_names
+
+        module_names = self.get_root_context().string_names
+        if module_names is None:
+            return None
+        return module_names + qualified_names
+
+    def _get_qualified_names(self):
+        # By default, a name has no qualified names.
+        return None
+
+    def get_root_context(self):
+        return self.parent_context.get_root_context()
+
+    def get_public_name(self):
+        return self.string_name
+
+    def __repr__(self):
+        if self.start_pos is None:
+            return '<%s: string_name=%s>' % (self.__class__.__name__, self.string_name)
+        return '<%s: string_name=%s start_pos=%s>' % (self.__class__.__name__,
+                                                      self.string_name, self.start_pos)
+
+    def is_import(self):
+        return False
+
+    def py__doc__(self):
+        return ''
+
+    @property
+    def api_type(self):
+        return self.parent_context.api_type
+
+    def get_defining_qualified_value(self):
+        """
+        Returns either None or the value that is public and qualified. Won't
+        return a function, because a name in a function is never public.
+        """
+        return None
+
+
+class AbstractArbitraryName(AbstractNameDefinition):
+    """
+    When you e.g. want to complete dicts keys, you probably want to complete
+    string literals, which is not really a name, but for Jedi we use this
+    concept of Name for completions as well.
+    """
+    is_value_name = False
+
+    def __init__(self, inference_state, string):
+        self.inference_state = inference_state
+        self.string_name = string
+        self.parent_context = inference_state.builtins_module
+
+    def infer(self):
+        return NO_VALUES
+
+
+class AbstractTreeName(AbstractNameDefinition):
+    def __init__(self, parent_context, tree_name):
+        self.parent_context = parent_context
+        self.tree_name = tree_name
+
+    def get_qualified_names(self, include_module_names=False):
+        import_node = search_ancestor(self.tree_name, 'import_name', 'import_from')
+        # For import nodes we cannot just have names, because it's very unclear
+        # how they would look like. For now we just ignore them in most cases.
+        # In case of level == 1, it works always, because it's like a submodule
+        # lookup.
+        if import_node is not None and not (import_node.level == 1
+                                            and self.get_root_context().get_value().is_package()):
+            # TODO improve the situation for when level is present.
+            if include_module_names and not import_node.level:
+                return tuple(n.value for n in import_node.get_path_for_name(self.tree_name))
+            else:
+                return None
+
+        return super(AbstractTreeName, self).get_qualified_names(include_module_names)
+
+    def _get_qualified_names(self):
+        parent_names = self.parent_context.get_qualified_names()
+        if parent_names is None:
+            return None
+        return parent_names + (self.tree_name.value,)
+
+    def get_defining_qualified_value(self):
+        if self.is_import():
+            raise NotImplementedError("Shouldn't really happen, please report")
+        elif self.parent_context:
+            return self.parent_context.get_value()  # Might be None
+        return None
+
+    def goto(self):
+        context = self.parent_context
+        name = self.tree_name
+        definition = name.get_definition(import_name_always=True)
+        if definition is not None:
+            type_ = definition.type
+            if type_ == 'expr_stmt':
+                # Only take the parent, because if it's more complicated than just
+                # a name it's something you can "goto" again.
+                is_simple_name = name.parent.type not in ('power', 'trailer')
+                if is_simple_name:
+                    return [self]
+            elif type_ in ('import_from', 'import_name'):
+                from jedi.inference.imports import goto_import
+                module_names = goto_import(context, name)
+                return module_names
+            else:
+                return [self]
+        else:
+            from jedi.inference.imports import follow_error_node_imports_if_possible
+            values = follow_error_node_imports_if_possible(context, name)
+            if values is not None:
+                return [value.name for value in values]
+
+        par = name.parent
+        node_type = par.type
+        if node_type == 'argument' and par.children[1] == '=' and par.children[0] == name:
+            # Named param goto.
+            trailer = par.parent
+            if trailer.type == 'arglist':
+                trailer = trailer.parent
+            if trailer.type != 'classdef':
+                if trailer.type == 'decorator':
+                    value_set = context.infer_node(trailer.children[1])
+                else:
+                    i = trailer.parent.children.index(trailer)
+                    to_infer = trailer.parent.children[:i]
+                    if to_infer[0] == 'await':
+                        to_infer.pop(0)
+                    value_set = context.infer_node(to_infer[0])
+                    from jedi.inference.syntax_tree import infer_trailer
+                    for trailer in to_infer[1:]:
+                        value_set = infer_trailer(context, value_set, trailer)
+                param_names = []
+                for value in value_set:
+                    for signature in value.get_signatures():
+                        for param_name in signature.get_param_names():
+                            if param_name.string_name == name.value:
+                                param_names.append(param_name)
+                return param_names
+        elif node_type == 'dotted_name':  # Is a decorator.
+            index = par.children.index(name)
+            if index > 0:
+                new_dotted = deep_ast_copy(par)
+                new_dotted.children[index - 1:] = []
+                values = context.infer_node(new_dotted)
+                return unite(
+                    value.goto(name, name_context=context)
+                    for value in values
+                )
+
+        if node_type == 'trailer' and par.children[0] == '.':
+            values = infer_call_of_leaf(context, name, cut_own_trailer=True)
+            return values.goto(name, name_context=context)
+        else:
+            stmt = search_ancestor(
+                name, 'expr_stmt', 'lambdef'
+            ) or name
+            if stmt.type == 'lambdef':
+                stmt = name
+            return context.goto(name, position=stmt.start_pos)
+
+    def is_import(self):
+        imp = search_ancestor(self.tree_name, 'import_from', 'import_name')
+        return imp is not None
+
+    @property
+    def string_name(self):
+        return self.tree_name.value
+
+    @property
+    def start_pos(self):
+        return self.tree_name.start_pos
+
+
+class ValueNameMixin(object):
+    def infer(self):
+        return ValueSet([self._value])
+
+    def py__doc__(self):
+        doc = self._value.py__doc__()
+        if not doc and self._value.is_stub():
+            from jedi.inference.gradual.conversion import convert_names
+            names = convert_names([self], prefer_stub_to_compiled=False)
+            if self not in names:
+                return _merge_name_docs(names)
+        return doc
+
+    def _get_qualified_names(self):
+        return self._value.get_qualified_names()
+
+    def get_root_context(self):
+        if self.parent_context is None:  # A module
+            return self._value.as_context()
+        return super(ValueNameMixin, self).get_root_context()
+
+    def get_defining_qualified_value(self):
+        context = self.parent_context
+        if context.is_module() or context.is_class():
+            return self.parent_context.get_value()  # Might be None
+        return None
+
+    @property
+    def api_type(self):
+        return self._value.api_type
+
+
+class ValueName(ValueNameMixin, AbstractTreeName):
+    def __init__(self, value, tree_name):
+        super(ValueName, self).__init__(value.parent_context, tree_name)
+        self._value = value
+
+    def goto(self):
+        return ValueSet([self._value.name])
+
+
+class TreeNameDefinition(AbstractTreeName):
+    _API_TYPES = dict(
+        import_name='module',
+        import_from='module',
+        funcdef='function',
+        param='param',
+        classdef='class',
+    )
+
+    def infer(self):
+        # Refactor this, should probably be here.
+        from jedi.inference.syntax_tree import tree_name_to_values
+        return tree_name_to_values(
+            self.parent_context.inference_state,
+            self.parent_context,
+            self.tree_name
+        )
+
+    @property
+    def api_type(self):
+        definition = self.tree_name.get_definition(import_name_always=True)
+        if definition is None:
+            return 'statement'
+        return self._API_TYPES.get(definition.type, 'statement')
+
+    def assignment_indexes(self):
+        """
+        Returns an array of tuple(int, node) of the indexes that are used in
+        tuple assignments.
+
+        For example if the name is ``y`` in the following code::
+
+            x, (y, z) = 2, ''
+
+        would result in ``[(1, xyz_node), (0, yz_node)]``.
+
+        When searching for b in the case ``a, *b, c = [...]`` it will return::
+
+            [(slice(1, -1), abc_node)]
+        """
+        indexes = []
+        is_star_expr = False
+        node = self.tree_name.parent
+        compare = self.tree_name
+        while node is not None:
+            if node.type in ('testlist', 'testlist_comp', 'testlist_star_expr', 'exprlist'):
+                for i, child in enumerate(node.children):
+                    if child == compare:
+                        index = int(i / 2)
+                        if is_star_expr:
+                            from_end = int((len(node.children) - i) / 2)
+                            index = slice(index, -from_end)
+                        indexes.insert(0, (index, node))
+                        break
+                else:
+                    raise LookupError("Couldn't find the assignment.")
+                is_star_expr = False
+            elif node.type == 'star_expr':
+                is_star_expr = True
+            elif node.type in ('expr_stmt', 'sync_comp_for'):
+                break
+
+            compare = node
+            node = node.parent
+        return indexes
+
+    def py__doc__(self):
+        api_type = self.api_type
+        if api_type in ('function', 'class'):
+            # Make sure the names are not TreeNameDefinitions anymore.
+            return clean_scope_docstring(self.tree_name.get_definition())
+
+        if api_type == 'module':
+            names = self.goto()
+            if self not in names:
+                return _merge_name_docs(names)
+
+        if api_type == 'statement' and self.tree_name.is_definition():
+            return find_statement_documentation(self.tree_name.get_definition())
+        return ''
+
+
+class _ParamMixin(object):
+    def maybe_positional_argument(self, include_star=True):
+        options = [Parameter.POSITIONAL_ONLY, Parameter.POSITIONAL_OR_KEYWORD]
+        if include_star:
+            options.append(Parameter.VAR_POSITIONAL)
+        return self.get_kind() in options
+
+    def maybe_keyword_argument(self, include_stars=True):
+        options = [Parameter.KEYWORD_ONLY, Parameter.POSITIONAL_OR_KEYWORD]
+        if include_stars:
+            options.append(Parameter.VAR_KEYWORD)
+        return self.get_kind() in options
+
+    def _kind_string(self):
+        kind = self.get_kind()
+        if kind == Parameter.VAR_POSITIONAL:  # *args
+            return '*'
+        if kind == Parameter.VAR_KEYWORD:  # **kwargs
+            return '**'
+        return ''
+
+    def get_qualified_names(self, include_module_names=False):
+        return None
+
+
+class ParamNameInterface(_ParamMixin):
+    api_type = u'param'
+
+    def get_kind(self):
+        raise NotImplementedError
+
+    def to_string(self):
+        raise NotImplementedError
+
+    def get_executed_param_name(self):
+        """
+        For dealing with type inference and working around the graph, we
+        sometimes want to have the param name of the execution. This feels a
+        bit strange and we might have to refactor at some point.
+
+        For now however it exists to avoid infering params when we don't really
+        need them (e.g. when we can just instead use annotations.
+        """
+        return None
+
+    @property
+    def star_count(self):
+        kind = self.get_kind()
+        if kind == Parameter.VAR_POSITIONAL:
+            return 1
+        if kind == Parameter.VAR_KEYWORD:
+            return 2
+        return 0
+
+
+class BaseTreeParamName(ParamNameInterface, AbstractTreeName):
+    annotation_node = None
+    default_node = None
+
+    def to_string(self):
+        output = self._kind_string() + self.get_public_name()
+        annotation = self.annotation_node
+        default = self.default_node
+        if annotation is not None:
+            output += ': ' + annotation.get_code(include_prefix=False)
+        if default is not None:
+            output += '=' + default.get_code(include_prefix=False)
+        return output
+
+    def get_public_name(self):
+        name = self.string_name
+        if name.startswith('__'):
+            # Params starting with __ are an equivalent to positional only
+            # variables in typeshed.
+            name = name[2:]
+        return name
+
+    def goto(self, **kwargs):
+        return [self]
+
+
+class _ActualTreeParamName(BaseTreeParamName):
+    def __init__(self, function_value, tree_name):
+        super(_ActualTreeParamName, self).__init__(
+            function_value.get_default_param_context(), tree_name)
+        self.function_value = function_value
+
+    def _get_param_node(self):
+        return search_ancestor(self.tree_name, 'param')
+
+    @property
+    def annotation_node(self):
+        return self._get_param_node().annotation
+
+    def infer_annotation(self, execute_annotation=True, ignore_stars=False):
+        from jedi.inference.gradual.annotation import infer_param
+        values = infer_param(
+            self.function_value, self._get_param_node(),
+            ignore_stars=ignore_stars)
+        if execute_annotation:
+            values = values.execute_annotation()
+        return values
+
+    def infer_default(self):
+        node = self.default_node
+        if node is None:
+            return NO_VALUES
+        return self.parent_context.infer_node(node)
+
+    @property
+    def default_node(self):
+        return self._get_param_node().default
+
+    def get_kind(self):
+        tree_param = self._get_param_node()
+        if tree_param.star_count == 1:  # *args
+            return Parameter.VAR_POSITIONAL
+        if tree_param.star_count == 2:  # **kwargs
+            return Parameter.VAR_KEYWORD
+
+        # Params starting with __ are an equivalent to positional only
+        # variables in typeshed.
+        if tree_param.name.value.startswith('__'):
+            return Parameter.POSITIONAL_ONLY
+
+        parent = tree_param.parent
+        param_appeared = False
+        for p in parent.children:
+            if param_appeared:
+                if p == '/':
+                    return Parameter.POSITIONAL_ONLY
+            else:
+                if p == '*':
+                    return Parameter.KEYWORD_ONLY
+                if p.type == 'param':
+                    if p.star_count:
+                        return Parameter.KEYWORD_ONLY
+                    if p == tree_param:
+                        param_appeared = True
+        return Parameter.POSITIONAL_OR_KEYWORD
+
+    def infer(self):
+        values = self.infer_annotation()
+        if values:
+            return values
+
+        doc_params = docstrings.infer_param(self.function_value, self._get_param_node())
+        return doc_params
+
+
+class AnonymousParamName(_ActualTreeParamName):
+    @plugin_manager.decorate(name='goto_anonymous_param')
+    def goto(self):
+        return super(AnonymousParamName, self).goto()
+
+    @plugin_manager.decorate(name='infer_anonymous_param')
+    def infer(self):
+        values = super(AnonymousParamName, self).infer()
+        if values:
+            return values
+        from jedi.inference.dynamic_params import dynamic_param_lookup
+        param = self._get_param_node()
+        values = dynamic_param_lookup(self.function_value, param.position_index)
+        if values:
+            return values
+
+        if param.star_count == 1:
+            from jedi.inference.value.iterable import FakeTuple
+            value = FakeTuple(self.function_value.inference_state, [])
+        elif param.star_count == 2:
+            from jedi.inference.value.iterable import FakeDict
+            value = FakeDict(self.function_value.inference_state, {})
+        elif param.default is None:
+            return NO_VALUES
+        else:
+            return self.function_value.parent_context.infer_node(param.default)
+        return ValueSet({value})
+
+
+class ParamName(_ActualTreeParamName):
+    def __init__(self, function_value, tree_name, arguments):
+        super(ParamName, self).__init__(function_value, tree_name)
+        self.arguments = arguments
+
+    def infer(self):
+        values = super(ParamName, self).infer()
+        if values:
+            return values
+
+        return self.get_executed_param_name().infer()
+
+    def get_executed_param_name(self):
+        from jedi.inference.param import get_executed_param_names
+        params_names = get_executed_param_names(self.function_value, self.arguments)
+        return params_names[self._get_param_node().position_index]
+
+
+class ParamNameWrapper(_ParamMixin):
+    def __init__(self, param_name):
+        self._wrapped_param_name = param_name
+
+    def __getattr__(self, name):
+        return getattr(self._wrapped_param_name, name)
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self._wrapped_param_name)
+
+
+class ImportName(AbstractNameDefinition):
+    start_pos = (1, 0)
+    _level = 0
+
+    def __init__(self, parent_context, string_name):
+        self._from_module_context = parent_context
+        self.string_name = string_name
+
+    def get_qualified_names(self, include_module_names=False):
+        if include_module_names:
+            if self._level:
+                assert self._level == 1, "Everything else is not supported for now"
+                module_names = self._from_module_context.string_names
+                if module_names is None:
+                    return module_names
+                return module_names + (self.string_name,)
+            return (self.string_name,)
+        return ()
+
+    @property
+    def parent_context(self):
+        m = self._from_module_context
+        import_values = self.infer()
+        if not import_values:
+            return m
+        # It's almost always possible to find the import or to not find it. The
+        # importing returns only one value, pretty much always.
+        return next(iter(import_values)).as_context()
+
+    @memoize_method
+    def infer(self):
+        from jedi.inference.imports import Importer
+        m = self._from_module_context
+        return Importer(m.inference_state, [self.string_name], m, level=self._level).follow()
+
+    def goto(self):
+        return [m.name for m in self.infer()]
+
+    @property
+    def api_type(self):
+        return 'module'
+
+    def py__doc__(self):
+        return _merge_name_docs(self.goto())
+
+
+class SubModuleName(ImportName):
+    _level = 1
+
+
+class NameWrapper(object):
+    def __init__(self, wrapped_name):
+        self._wrapped_name = wrapped_name
+
+    def __getattr__(self, name):
+        return getattr(self._wrapped_name, name)
+
+    def __repr__(self):
+        return '%s(%s)' % (self.__class__.__name__, self._wrapped_name)
+
+
+class StubNameMixin(object):
+    def py__doc__(self):
+        from jedi.inference.gradual.conversion import convert_names
+        # Stubs are not complicated and we can just follow simple statements
+        # that have an equals in them, because they typically make something
+        # else public. See e.g. stubs for `requests`.
+        names = [self]
+        if self.api_type == 'statement' and '=' in self.tree_name.get_definition().children:
+            names = [v.name for v in self.infer()]
+
+        names = convert_names(names, prefer_stub_to_compiled=False)
+        if self in names:
+            return super(StubNameMixin, self).py__doc__()
+        else:
+            # We have signatures ourselves in stubs, so don't use signatures
+            # from the implementation.
+            return _merge_name_docs(names)
+
+
+# From here on down we make looking up the sys.version_info fast.
+class StubName(StubNameMixin, TreeNameDefinition):
+    def infer(self):
+        inferred = super(StubName, self).infer()
+        if self.string_name == 'version_info' and self.get_root_context().py__name__() == 'sys':
+            from jedi.inference.gradual.stub_value import VersionInfo
+            return ValueSet(VersionInfo(c) for c in inferred)
+        return inferred
+
+
+class ModuleName(ValueNameMixin, AbstractNameDefinition):
+    start_pos = 1, 0
+
+    def __init__(self, value, name):
+        self._value = value
+        self._name = name
+
+    @property
+    def string_name(self):
+        return self._name
+
+
+class StubModuleName(StubNameMixin, ModuleName):
+    pass

venv/Lib/site-packages/jedi/inference/param.py

@@ -0,0 +1,258 @@
+from collections import defaultdict
+
+from jedi import debug
+from jedi.inference.utils import PushBackIterator
+from jedi.inference import analysis
+from jedi.inference.lazy_value import LazyKnownValue, \
+    LazyTreeValue, LazyUnknownValue
+from jedi.inference.value import iterable
+from jedi._compatibility import Parameter
+from jedi.inference.names import ParamName
+
+
+def _add_argument_issue(error_name, lazy_value, message):
+    if isinstance(lazy_value, LazyTreeValue):
+        node = lazy_value.data
+        if node.parent.type == 'argument':
+            node = node.parent
+        return analysis.add(lazy_value.context, error_name, node, message)
+
+
+class ExecutedParamName(ParamName):
+    def __init__(self, function_value, arguments, param_node, lazy_value, is_default=False):
+        super(ExecutedParamName, self).__init__(
+            function_value, param_node.name, arguments=arguments)
+        self._lazy_value = lazy_value
+        self._is_default = is_default
+
+    def infer(self):
+        return self._lazy_value.infer()
+
+    def matches_signature(self):
+        if self._is_default:
+            return True
+        argument_values = self.infer().py__class__()
+        if self.get_kind() in (Parameter.VAR_POSITIONAL, Parameter.VAR_KEYWORD):
+            return True
+        annotations = self.infer_annotation(execute_annotation=False)
+        if not annotations:
+            # If we cannot infer annotations - or there aren't any - pretend
+            # that the signature matches.
+            return True
+        matches = any(c1.is_sub_class_of(c2)
+                      for c1 in argument_values
+                      for c2 in annotations.gather_annotation_classes())
+        debug.dbg("param compare %s: %s <=> %s",
+                  matches, argument_values, annotations, color='BLUE')
+        return matches
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self.string_name)
+
+
+def get_executed_param_names_and_issues(function_value, arguments):
+    """
+    Return a tuple of:
+      - a list of `ExecutedParamName`s corresponding to the arguments of the
+        function execution `function_value`, containing the inferred value of
+        those arguments (whether explicit or default)
+      - a list of the issues encountered while building that list
+
+    For example, given:
+    ```
+    def foo(a, b, c=None, d='d'): ...
+
+    foo(42, c='c')
+    ```
+
+    Then for the execution of `foo`, this will return a tuple containing:
+      - a list with entries for each parameter a, b, c & d; the entries for a,
+        c, & d will have their values (42, 'c' and 'd' respectively) included.
+      - a list with a single entry about the lack of a value for `b`
+    """
+    def too_many_args(argument):
+        m = _error_argument_count(funcdef, len(unpacked_va))
+        # Just report an error for the first param that is not needed (like
+        # cPython).
+        if arguments.get_calling_nodes():
+            # There might not be a valid calling node so check for that first.
+            issues.append(
+                _add_argument_issue(
+                    'type-error-too-many-arguments',
+                    argument,
+                    message=m
+                )
+            )
+        else:
+            issues.append(None)
+            debug.warning('non-public warning: %s', m)
+
+    issues = []  # List[Optional[analysis issue]]
+    result_params = []
+    param_dict = {}
+    funcdef = function_value.tree_node
+    # Default params are part of the value where the function was defined.
+    # This means that they might have access on class variables that the
+    # function itself doesn't have.
+    default_param_context = function_value.get_default_param_context()
+
+    for param in funcdef.get_params():
+        param_dict[param.name.value] = param
+    unpacked_va = list(arguments.unpack(funcdef))
+    var_arg_iterator = PushBackIterator(iter(unpacked_va))
+
+    non_matching_keys = defaultdict(lambda: [])
+    keys_used = {}
+    keys_only = False
+    had_multiple_value_error = False
+    for param in funcdef.get_params():
+        # The value and key can both be null. There, the defaults apply.
+        # args / kwargs will just be empty arrays / dicts, respectively.
+        # Wrong value count is just ignored. If you try to test cases that are
+        # not allowed in Python, Jedi will maybe not show any completions.
+        is_default = False
+        key, argument = next(var_arg_iterator, (None, None))
+        while key is not None:
+            keys_only = True
+            try:
+                key_param = param_dict[key]
+            except KeyError:
+                non_matching_keys[key] = argument
+            else:
+                if key in keys_used:
+                    had_multiple_value_error = True
+                    m = ("TypeError: %s() got multiple values for keyword argument '%s'."
+                         % (funcdef.name, key))
+                    for contextualized_node in arguments.get_calling_nodes():
+                        issues.append(
+                            analysis.add(contextualized_node.context,
+                                         'type-error-multiple-values',
+                                         contextualized_node.node, message=m)
+                        )
+                else:
+                    keys_used[key] = ExecutedParamName(
+                        function_value, arguments, key_param, argument)
+            key, argument = next(var_arg_iterator, (None, None))
+
+        try:
+            result_params.append(keys_used[param.name.value])
+            continue
+        except KeyError:
+            pass
+
+        if param.star_count == 1:
+            # *args param
+            lazy_value_list = []
+            if argument is not None:
+                lazy_value_list.append(argument)
+                for key, argument in var_arg_iterator:
+                    # Iterate until a key argument is found.
+                    if key:
+                        var_arg_iterator.push_back((key, argument))
+                        break
+                    lazy_value_list.append(argument)
+            seq = iterable.FakeTuple(function_value.inference_state, lazy_value_list)
+            result_arg = LazyKnownValue(seq)
+        elif param.star_count == 2:
+            if argument is not None:
+                too_many_args(argument)
+            # **kwargs param
+            dct = iterable.FakeDict(function_value.inference_state, dict(non_matching_keys))
+            result_arg = LazyKnownValue(dct)
+            non_matching_keys = {}
+        else:
+            # normal param
+            if argument is None:
+                # No value: Return an empty container
+                if param.default is None:
+                    result_arg = LazyUnknownValue()
+                    if not keys_only:
+                        for contextualized_node in arguments.get_calling_nodes():
+                            m = _error_argument_count(funcdef, len(unpacked_va))
+                            issues.append(
+                                analysis.add(
+                                    contextualized_node.context,
+                                    'type-error-too-few-arguments',
+                                    contextualized_node.node,
+                                    message=m,
+                                )
+                            )
+                else:
+                    result_arg = LazyTreeValue(default_param_context, param.default)
+                    is_default = True
+            else:
+                result_arg = argument
+
+        result_params.append(ExecutedParamName(
+            function_value, arguments, param, result_arg, is_default=is_default
+        ))
+        if not isinstance(result_arg, LazyUnknownValue):
+            keys_used[param.name.value] = result_params[-1]
+
+    if keys_only:
+        # All arguments should be handed over to the next function. It's not
+        # about the values inside, it's about the names. Jedi needs to now that
+        # there's nothing to find for certain names.
+        for k in set(param_dict) - set(keys_used):
+            param = param_dict[k]
+
+            if not (non_matching_keys or had_multiple_value_error
+                    or param.star_count or param.default):
+                # add a warning only if there's not another one.
+                for contextualized_node in arguments.get_calling_nodes():
+                    m = _error_argument_count(funcdef, len(unpacked_va))
+                    issues.append(
+                        analysis.add(contextualized_node.context,
+                                     'type-error-too-few-arguments',
+                                     contextualized_node.node, message=m)
+                    )
+
+    for key, lazy_value in non_matching_keys.items():
+        m = "TypeError: %s() got an unexpected keyword argument '%s'." \
+            % (funcdef.name, key)
+        issues.append(
+            _add_argument_issue(
+                'type-error-keyword-argument',
+                lazy_value,
+                message=m
+            )
+        )
+
+    remaining_arguments = list(var_arg_iterator)
+    if remaining_arguments:
+        first_key, lazy_value = remaining_arguments[0]
+        too_many_args(lazy_value)
+    return result_params, issues
+
+
+def get_executed_param_names(function_value, arguments):
+    """
+    Return a list of `ExecutedParamName`s corresponding to the arguments of the
+    function execution `function_value`, containing the inferred value of those
+    arguments (whether explicit or default). Any issues building this list (for
+    example required arguments which are missing in the invocation) are ignored.
+
+    For example, given:
+    ```
+    def foo(a, b, c=None, d='d'): ...
+
+    foo(42, c='c')
+    ```
+
+    Then for the execution of `foo`, this will return a list containing entries
+    for each parameter a, b, c & d; the entries for a, c, & d will have their
+    values (42, 'c' and 'd' respectively) included.
+    """
+    return get_executed_param_names_and_issues(function_value, arguments)[0]
+
+
+def _error_argument_count(funcdef, actual_count):
+    params = funcdef.get_params()
+    default_arguments = sum(1 for p in params if p.default or p.star_count)
+
+    if default_arguments == 0:
+        before = 'exactly '
+    else:
+        before = 'from %s to ' % (len(params) - default_arguments)
+    return ('TypeError: %s() takes %s%s arguments (%s given).'
+            % (funcdef.name, before, len(params), actual_count))

venv/Lib/site-packages/jedi/inference/parser_cache.py

@@ -0,0 +1,6 @@
+from jedi.inference.cache import inference_state_function_cache
+
+
+@inference_state_function_cache()
+def get_yield_exprs(inference_state, funcdef):
+    return list(funcdef.iter_yield_exprs())

venv/Lib/site-packages/jedi/inference/recursion.py

@@ -0,0 +1,153 @@
+"""
+Recursions are the recipe of |jedi| to conquer Python code. However, someone
+must stop recursions going mad. Some settings are here to make |jedi| stop at
+the right time. You can read more about them :ref:`here <settings-recursion>`.
+
+Next to the internal ``jedi.inference.cache`` this module also makes |jedi| not
+thread-safe, because ``execution_recursion_decorator`` uses class variables to
+count the function calls.
+
+.. _settings-recursion:
+
+Settings
+~~~~~~~~~~
+
+Recursion settings are important if you don't want extremly
+recursive python code to go absolutely crazy.
+
+The default values are based on experiments while completing the |jedi| library
+itself (inception!). But I don't think there's any other Python library that
+uses recursion in a similarly extreme way. Completion should also be fast and
+therefore the quality might not always be maximal.
+
+.. autodata:: recursion_limit
+.. autodata:: total_function_execution_limit
+.. autodata:: per_function_execution_limit
+.. autodata:: per_function_recursion_limit
+"""
+
+from contextlib import contextmanager
+
+from jedi import debug
+from jedi.inference.base_value import NO_VALUES
+
+
+recursion_limit = 15
+"""
+Like :func:`sys.getrecursionlimit()`, just for |jedi|.
+"""
+total_function_execution_limit = 200
+"""
+This is a hard limit of how many non-builtin functions can be executed.
+"""
+per_function_execution_limit = 6
+"""
+The maximal amount of times a specific function may be executed.
+"""
+per_function_recursion_limit = 2
+"""
+A function may not be executed more than this number of times recursively.
+"""
+
+
+class RecursionDetector(object):
+    def __init__(self):
+        self.pushed_nodes = []
+
+
+@contextmanager
+def execution_allowed(inference_state, node):
+    """
+    A decorator to detect recursions in statements. In a recursion a statement
+    at the same place, in the same module may not be executed two times.
+    """
+    pushed_nodes = inference_state.recursion_detector.pushed_nodes
+
+    if node in pushed_nodes:
+        debug.warning('catched stmt recursion: %s @%s', node,
+                      getattr(node, 'start_pos', None))
+        yield False
+    else:
+        try:
+            pushed_nodes.append(node)
+            yield True
+        finally:
+            pushed_nodes.pop()
+
+
+def execution_recursion_decorator(default=NO_VALUES):
+    def decorator(func):
+        def wrapper(self, **kwargs):
+            detector = self.inference_state.execution_recursion_detector
+            limit_reached = detector.push_execution(self)
+            try:
+                if limit_reached:
+                    result = default
+                else:
+                    result = func(self, **kwargs)
+            finally:
+                detector.pop_execution()
+            return result
+        return wrapper
+    return decorator
+
+
+class ExecutionRecursionDetector(object):
+    """
+    Catches recursions of executions.
+    """
+    def __init__(self, inference_state):
+        self._inference_state = inference_state
+
+        self._recursion_level = 0
+        self._parent_execution_funcs = []
+        self._funcdef_execution_counts = {}
+        self._execution_count = 0
+
+    def pop_execution(self):
+        self._parent_execution_funcs.pop()
+        self._recursion_level -= 1
+
+    def push_execution(self, execution):
+        funcdef = execution.tree_node
+
+        # These two will be undone in pop_execution.
+        self._recursion_level += 1
+        self._parent_execution_funcs.append(funcdef)
+
+        module_context = execution.get_root_context()
+
+        if module_context.is_builtins_module():
+            # We have control over builtins so we know they are not recursing
+            # like crazy. Therefore we just let them execute always, because
+            # they usually just help a lot with getting good results.
+            return False
+
+        if self._recursion_level > recursion_limit:
+            debug.warning('Recursion limit (%s) reached', recursion_limit)
+            return True
+
+        if self._execution_count >= total_function_execution_limit:
+            debug.warning('Function execution limit (%s) reached', total_function_execution_limit)
+            return True
+        self._execution_count += 1
+
+        if self._funcdef_execution_counts.setdefault(funcdef, 0) >= per_function_execution_limit:
+            if module_context.py__name__() == 'typing':
+                return False
+            debug.warning(
+                'Per function execution limit (%s) reached: %s',
+                per_function_execution_limit,
+                funcdef
+            )
+            return True
+        self._funcdef_execution_counts[funcdef] += 1
+
+        if self._parent_execution_funcs.count(funcdef) > per_function_recursion_limit:
+            debug.warning(
+                'Per function recursion limit (%s) reached: %s',
+                per_function_recursion_limit,
+                funcdef
+            )
+            return True
+        return False

venv/Lib/site-packages/jedi/inference/references.py

@@ -0,0 +1,299 @@
+import os
+import re
+
+from parso import python_bytes_to_unicode
+
+from jedi._compatibility import FileNotFoundError
+from jedi.debug import dbg
+from jedi.file_io import KnownContentFileIO
+from jedi.inference.imports import SubModuleName, load_module_from_path
+from jedi.inference.filters import ParserTreeFilter
+from jedi.inference.gradual.conversion import convert_names
+
+_IGNORE_FOLDERS = ('.tox', '.venv', 'venv', '__pycache__')
+
+_OPENED_FILE_LIMIT = 2000
+"""
+Stats from a 2016 Lenovo Notebook running Linux:
+With os.walk, it takes about 10s to scan 11'000 files (without filesystem
+caching). Once cached it only takes 5s. So it is expected that reading all
+those files might take a few seconds, but not a lot more.
+"""
+_PARSED_FILE_LIMIT = 30
+"""
+For now we keep the amount of parsed files really low, since parsing might take
+easily 100ms for bigger files.
+"""
+
+
+def _resolve_names(definition_names, avoid_names=()):
+    for name in definition_names:
+        if name in avoid_names:
+            # Avoiding recursions here, because goto on a module name lands
+            # on the same module.
+            continue
+
+        if not isinstance(name, SubModuleName):
+            # SubModuleNames are not actually existing names but created
+            # names when importing something like `import foo.bar.baz`.
+            yield name
+
+        if name.api_type == 'module':
+            for n in _resolve_names(name.goto(), definition_names):
+                yield n
+
+
+def _dictionarize(names):
+    return dict(
+        (n if n.tree_name is None else n.tree_name, n)
+        for n in names
+    )
+
+
+def _find_defining_names(module_context, tree_name):
+    found_names = _find_names(module_context, tree_name)
+
+    for name in list(found_names):
+        # Convert from/to stubs, because those might also be usages.
+        found_names |= set(convert_names(
+            [name],
+            only_stubs=not name.get_root_context().is_stub(),
+            prefer_stub_to_compiled=False
+        ))
+
+    found_names |= set(_find_global_variables(found_names, tree_name.value))
+    for name in list(found_names):
+        if name.api_type == 'param' or name.tree_name is None \
+                or name.tree_name.parent.type == 'trailer':
+            continue
+        found_names |= set(_add_names_in_same_context(name.parent_context, name.string_name))
+    return set(_resolve_names(found_names))
+
+
+def _find_names(module_context, tree_name):
+    name = module_context.create_name(tree_name)
+    found_names = set(name.goto())
+    found_names.add(name)
+
+    return set(_resolve_names(found_names))
+
+
+def _add_names_in_same_context(context, string_name):
+    if context.tree_node is None:
+        return
+
+    until_position = None
+    while True:
+        filter_ = ParserTreeFilter(
+            parent_context=context,
+            until_position=until_position,
+        )
+        names = set(filter_.get(string_name))
+        if not names:
+            break
+        for name in names:
+            yield name
+        ordered = sorted(names, key=lambda x: x.start_pos)
+        until_position = ordered[0].start_pos
+
+
+def _find_global_variables(names, search_name):
+    for name in names:
+        if name.tree_name is None:
+            continue
+        module_context = name.get_root_context()
+        try:
+            method = module_context.get_global_filter
+        except AttributeError:
+            continue
+        else:
+            for global_name in method().get(search_name):
+                yield global_name
+                c = module_context.create_context(global_name.tree_name)
+                for n in _add_names_in_same_context(c, global_name.string_name):
+                    yield n
+
+
+def find_references(module_context, tree_name, only_in_module=False):
+    inf = module_context.inference_state
+    search_name = tree_name.value
+
+    # We disable flow analysis, because if we have ifs that are only true in
+    # certain cases, we want both sides.
+    try:
+        inf.flow_analysis_enabled = False
+        found_names = _find_defining_names(module_context, tree_name)
+    finally:
+        inf.flow_analysis_enabled = True
+
+    found_names_dct = _dictionarize(found_names)
+
+    module_contexts = [module_context]
+    if not only_in_module:
+        module_contexts.extend(
+            m for m in set(d.get_root_context() for d in found_names)
+            if m != module_context and m.tree_node is not None
+        )
+    # For param no search for other modules is necessary.
+    if only_in_module or any(n.api_type == 'param' for n in found_names):
+        potential_modules = module_contexts
+    else:
+        potential_modules = get_module_contexts_containing_name(
+            inf,
+            module_contexts,
+            search_name,
+        )
+
+    non_matching_reference_maps = {}
+    for module_context in potential_modules:
+        for name_leaf in module_context.tree_node.get_used_names().get(search_name, []):
+            new = _dictionarize(_find_names(module_context, name_leaf))
+            if any(tree_name in found_names_dct for tree_name in new):
+                found_names_dct.update(new)
+                for tree_name in new:
+                    for dct in non_matching_reference_maps.get(tree_name, []):
+                        # A reference that was previously searched for matches
+                        # with a now found name. Merge.
+                        found_names_dct.update(dct)
+                    try:
+                        del non_matching_reference_maps[tree_name]
+                    except KeyError:
+                        pass
+            else:
+                for name in new:
+                    non_matching_reference_maps.setdefault(name, []).append(new)
+    result = found_names_dct.values()
+    if only_in_module:
+        return [n for n in result if n.get_root_context() == module_context]
+    return result
+
+
+def _check_fs(inference_state, file_io, regex):
+    try:
+        code = file_io.read()
+    except FileNotFoundError:
+        return None
+    code = python_bytes_to_unicode(code, errors='replace')
+    if not regex.search(code):
+        return None
+    new_file_io = KnownContentFileIO(file_io.path, code)
+    m = load_module_from_path(inference_state, new_file_io)
+    if m.is_compiled():
+        return None
+    return m.as_context()
+
+
+def gitignored_lines(folder_io, file_io):
+    ignored_paths = set()
+    ignored_names = set()
+    for l in file_io.read().splitlines():
+        if not l or l.startswith(b'#'):
+            continue
+
+        p = l.decode('utf-8', 'ignore')
+        if p.startswith('/'):
+            name = p[1:]
+            if name.endswith(os.path.sep):
+                name = name[:-1]
+            ignored_paths.add(os.path.join(folder_io.path, name))
+        else:
+            ignored_names.add(p)
+    return ignored_paths, ignored_names
+
+
+def recurse_find_python_folders_and_files(folder_io, except_paths=()):
+    except_paths = set(except_paths)
+    for root_folder_io, folder_ios, file_ios in folder_io.walk():
+        # Delete folders that we don't want to iterate over.
+        for file_io in file_ios:
+            path = file_io.path
+            if path.endswith('.py') or path.endswith('.pyi'):
+                if path not in except_paths:
+                    yield None, file_io
+
+            if path.endswith('.gitignore'):
+                ignored_paths, ignored_names = \
+                    gitignored_lines(root_folder_io, file_io)
+                except_paths |= ignored_paths
+
+        folder_ios[:] = [
+            folder_io
+            for folder_io in folder_ios
+            if folder_io.path not in except_paths
+            and folder_io.get_base_name() not in _IGNORE_FOLDERS
+        ]
+        for folder_io in folder_ios:
+            yield folder_io, None
+
+
+def recurse_find_python_files(folder_io, except_paths=()):
+    for folder_io, file_io in recurse_find_python_folders_and_files(folder_io, except_paths):
+        if file_io is not None:
+            yield file_io
+
+
+def _find_python_files_in_sys_path(inference_state, module_contexts):
+    sys_path = inference_state.get_sys_path()
+    except_paths = set()
+    yielded_paths = [m.py__file__() for m in module_contexts]
+    for module_context in module_contexts:
+        file_io = module_context.get_value().file_io
+        if file_io is None:
+            continue
+
+        folder_io = file_io.get_parent_folder()
+        while True:
+            path = folder_io.path
+            if not any(path.startswith(p) for p in sys_path) or path in except_paths:
+                break
+            for file_io in recurse_find_python_files(folder_io, except_paths):
+                if file_io.path not in yielded_paths:
+                    yield file_io
+            except_paths.add(path)
+            folder_io = folder_io.get_parent_folder()
+
+
+def get_module_contexts_containing_name(inference_state, module_contexts, name,
+                                        limit_reduction=1):
+    """
+    Search a name in the directories of modules.
+
+    :param limit_reduction: Divides the limits on opening/parsing files by this
+        factor.
+    """
+    # Skip non python modules
+    for module_context in module_contexts:
+        if module_context.is_compiled():
+            continue
+        yield module_context
+
+    # Very short names are not searched in other modules for now to avoid lots
+    # of file lookups.
+    if len(name) <= 2:
+        return
+
+    file_io_iterator = _find_python_files_in_sys_path(inference_state, module_contexts)
+    for x in search_in_file_ios(inference_state, file_io_iterator, name,
+                                limit_reduction=limit_reduction):
+        yield x  # Python 2...
+
+
+def search_in_file_ios(inference_state, file_io_iterator, name, limit_reduction=1):
+    parse_limit = _PARSED_FILE_LIMIT / limit_reduction
+    open_limit = _OPENED_FILE_LIMIT / limit_reduction
+    file_io_count = 0
+    parsed_file_count = 0
+    regex = re.compile(r'\b' + re.escape(name) + r'\b')
+    for file_io in file_io_iterator:
+        file_io_count += 1
+        m = _check_fs(inference_state, file_io, regex)
+        if m is not None:
+            parsed_file_count += 1
+            yield m
+            if parsed_file_count >= parse_limit:
+                dbg('Hit limit of parsed files: %s', parse_limit)
+                break
+
+        if file_io_count >= open_limit:
+            dbg('Hit limit of opened files: %s', open_limit)
+            break

venv/Lib/site-packages/jedi/inference/signature.py

@@ -0,0 +1,151 @@
+from jedi._compatibility import Parameter
+from jedi.cache import memoize_method
+from jedi import debug
+from jedi import parser_utils
+
+
+class _SignatureMixin(object):
+    def to_string(self):
+        def param_strings():
+            is_positional = False
+            is_kw_only = False
+            for n in self.get_param_names(resolve_stars=True):
+                kind = n.get_kind()
+                is_positional |= kind == Parameter.POSITIONAL_ONLY
+                if is_positional and kind != Parameter.POSITIONAL_ONLY:
+                    yield '/'
+                    is_positional = False
+
+                if kind == Parameter.VAR_POSITIONAL:
+                    is_kw_only = True
+                elif kind == Parameter.KEYWORD_ONLY and not is_kw_only:
+                    yield '*'
+                    is_kw_only = True
+
+                yield n.to_string()
+
+            if is_positional:
+                yield '/'
+
+        s = self.name.string_name + '(' + ', '.join(param_strings()) + ')'
+        annotation = self.annotation_string
+        if annotation:
+            s += ' -> ' + annotation
+        return s
+
+
+class AbstractSignature(_SignatureMixin):
+    def __init__(self, value, is_bound=False):
+        self.value = value
+        self.is_bound = is_bound
+
+    @property
+    def name(self):
+        return self.value.name
+
+    @property
+    def annotation_string(self):
+        return ''
+
+    def get_param_names(self, resolve_stars=False):
+        param_names = self._function_value.get_param_names()
+        if self.is_bound:
+            return param_names[1:]
+        return param_names
+
+    def bind(self, value):
+        raise NotImplementedError
+
+    def matches_signature(self, arguments):
+        return True
+
+    def __repr__(self):
+        if self.value is self._function_value:
+            return '<%s: %s>' % (self.__class__.__name__, self.value)
+        return '<%s: %s, %s>' % (self.__class__.__name__, self.value, self._function_value)
+
+
+class TreeSignature(AbstractSignature):
+    def __init__(self, value, function_value=None, is_bound=False):
+        super(TreeSignature, self).__init__(value, is_bound)
+        self._function_value = function_value or value
+
+    def bind(self, value):
+        return TreeSignature(value, self._function_value, is_bound=True)
+
+    @property
+    def _annotation(self):
+        # Classes don't need annotations, even if __init__ has one. They always
+        # return themselves.
+        if self.value.is_class():
+            return None
+        return self._function_value.tree_node.annotation
+
+    @property
+    def annotation_string(self):
+        a = self._annotation
+        if a is None:
+            return ''
+        return a.get_code(include_prefix=False)
+
+    @memoize_method
+    def get_param_names(self, resolve_stars=False):
+        params = self._function_value.get_param_names()
+        if resolve_stars:
+            from jedi.inference.star_args import process_params
+            params = process_params(params)
+        if self.is_bound:
+            return params[1:]
+        return params
+
+    def matches_signature(self, arguments):
+        from jedi.inference.param import get_executed_param_names_and_issues
+        executed_param_names, issues = \
+            get_executed_param_names_and_issues(self._function_value, arguments)
+        if issues:
+            return False
+
+        matches = all(executed_param_name.matches_signature()
+                      for executed_param_name in executed_param_names)
+        if debug.enable_notice:
+            tree_node = self._function_value.tree_node
+            signature = parser_utils.get_signature(tree_node)
+            if matches:
+                debug.dbg("Overloading match: %s@%s (%s)",
+                          signature, tree_node.start_pos[0], arguments, color='BLUE')
+            else:
+                debug.dbg("Overloading no match: %s@%s (%s)",
+                          signature, tree_node.start_pos[0], arguments, color='BLUE')
+        return matches
+
+
+class BuiltinSignature(AbstractSignature):
+    def __init__(self, value, return_string, function_value=None, is_bound=False):
+        super(BuiltinSignature, self).__init__(value, is_bound)
+        self._return_string = return_string
+        self.__function_value = function_value
+
+    @property
+    def annotation_string(self):
+        return self._return_string
+
+    @property
+    def _function_value(self):
+        if self.__function_value is None:
+            return self.value
+        return self.__function_value
+
+    def bind(self, value):
+        return BuiltinSignature(
+            value, self._return_string,
+            function_value=self.value,
+            is_bound=True
+        )
+
+
+class SignatureWrapper(_SignatureMixin):
+    def __init__(self, wrapped_signature):
+        self._wrapped_signature = wrapped_signature
+
+    def __getattr__(self, name):
+        return getattr(self._wrapped_signature, name)

venv/Lib/site-packages/jedi/inference/star_args.py

@@ -0,0 +1,217 @@
+"""
+This module is responsible for inferring *args and **kwargs for signatures.
+
+This means for example in this case::
+
+    def foo(a, b, c): ...
+
+    def bar(*args):
+        return foo(1, *args)
+
+The signature here for bar should be `bar(b, c)` instead of bar(*args).
+"""
+
+from jedi._compatibility import Parameter
+from jedi.inference.utils import to_list
+from jedi.inference.names import ParamNameWrapper
+from jedi.inference.helpers import is_big_annoying_library
+
+
+def _iter_nodes_for_param(param_name):
+    from parso.python.tree import search_ancestor
+    from jedi.inference.arguments import TreeArguments
+
+    execution_context = param_name.parent_context
+    function_node = execution_context.tree_node
+    module_node = function_node.get_root_node()
+    start = function_node.children[-1].start_pos
+    end = function_node.children[-1].end_pos
+    for name in module_node.get_used_names().get(param_name.string_name):
+        if start <= name.start_pos < end:
+            # Is used in the function
+            argument = name.parent
+            if argument.type == 'argument' \
+                    and argument.children[0] == '*' * param_name.star_count:
+                # No support for Python 2.7 here, but they are end-of-life
+                # anyway
+                trailer = search_ancestor(argument, 'trailer')
+                if trailer is not None:  # Make sure we're in a function
+                    context = execution_context.create_context(trailer)
+                    if _goes_to_param_name(param_name, context, name):
+                        values = _to_callables(context, trailer)
+
+                        args = TreeArguments.create_cached(
+                            execution_context.inference_state,
+                            context=context,
+                            argument_node=trailer.children[1],
+                            trailer=trailer,
+                        )
+                        for c in values:
+                            yield c, args
+
+
+def _goes_to_param_name(param_name, context, potential_name):
+    if potential_name.type != 'name':
+        return False
+    from jedi.inference.names import TreeNameDefinition
+    found = TreeNameDefinition(context, potential_name).goto()
+    return any(param_name.parent_context == p.parent_context
+               and param_name.start_pos == p.start_pos
+               for p in found)
+
+
+def _to_callables(context, trailer):
+    from jedi.inference.syntax_tree import infer_trailer
+
+    atom_expr = trailer.parent
+    index = atom_expr.children[0] == 'await'
+    # Infer atom first
+    values = context.infer_node(atom_expr.children[index])
+    for trailer2 in atom_expr.children[index + 1:]:
+        if trailer == trailer2:
+            break
+        values = infer_trailer(context, values, trailer2)
+    return values
+
+
+def _remove_given_params(arguments, param_names):
+    count = 0
+    used_keys = set()
+    for key, _ in arguments.unpack():
+        if key is None:
+            count += 1
+        else:
+            used_keys.add(key)
+
+    for p in param_names:
+        if count and p.maybe_positional_argument():
+            count -= 1
+            continue
+        if p.string_name in used_keys and p.maybe_keyword_argument():
+            continue
+        yield p
+
+
+@to_list
+def process_params(param_names, star_count=3):  # default means both * and **
+    if param_names:
+        if is_big_annoying_library(param_names[0].parent_context):
+            # At first this feature can look innocent, but it does a lot of
+            # type inference in some cases, so we just ditch it.
+            for p in param_names:
+                yield p
+            return
+
+    used_names = set()
+    arg_callables = []
+    kwarg_callables = []
+
+    kw_only_names = []
+    kwarg_names = []
+    arg_names = []
+    original_arg_name = None
+    original_kwarg_name = None
+    for p in param_names:
+        kind = p.get_kind()
+        if kind == Parameter.VAR_POSITIONAL:
+            if star_count & 1:
+                arg_callables = _iter_nodes_for_param(p)
+                original_arg_name = p
+        elif p.get_kind() == Parameter.VAR_KEYWORD:
+            if star_count & 2:
+                kwarg_callables = list(_iter_nodes_for_param(p))
+                original_kwarg_name = p
+        elif kind == Parameter.KEYWORD_ONLY:
+            if star_count & 2:
+                kw_only_names.append(p)
+        elif kind == Parameter.POSITIONAL_ONLY:
+            if star_count & 1:
+                yield p
+        else:
+            if star_count == 1:
+                yield ParamNameFixedKind(p, Parameter.POSITIONAL_ONLY)
+            elif star_count == 2:
+                kw_only_names.append(ParamNameFixedKind(p, Parameter.KEYWORD_ONLY))
+            else:
+                used_names.add(p.string_name)
+                yield p
+
+    # First process *args
+    longest_param_names = ()
+    found_arg_signature = False
+    found_kwarg_signature = False
+    for func_and_argument in arg_callables:
+        func, arguments = func_and_argument
+        new_star_count = star_count
+        if func_and_argument in kwarg_callables:
+            kwarg_callables.remove(func_and_argument)
+        else:
+            new_star_count = 1
+
+        for signature in func.get_signatures():
+            found_arg_signature = True
+            if new_star_count == 3:
+                found_kwarg_signature = True
+            args_for_this_func = []
+            for p in process_params(
+                    list(_remove_given_params(
+                        arguments,
+                        signature.get_param_names(resolve_stars=False)
+                    )), new_star_count):
+                if p.get_kind() == Parameter.VAR_KEYWORD:
+                    kwarg_names.append(p)
+                elif p.get_kind() == Parameter.VAR_POSITIONAL:
+                    arg_names.append(p)
+                elif p.get_kind() == Parameter.KEYWORD_ONLY:
+                    kw_only_names.append(p)
+                else:
+                    args_for_this_func.append(p)
+            if len(args_for_this_func) > len(longest_param_names):
+                longest_param_names = args_for_this_func
+
+    for p in longest_param_names:
+        if star_count == 1 and p.get_kind() != Parameter.VAR_POSITIONAL:
+            yield ParamNameFixedKind(p, Parameter.POSITIONAL_ONLY)
+        else:
+            if p.get_kind() == Parameter.POSITIONAL_OR_KEYWORD:
+                used_names.add(p.string_name)
+            yield p
+
+    if not found_arg_signature and original_arg_name is not None:
+        yield original_arg_name
+    elif arg_names:
+        yield arg_names[0]
+
+    # Then process **kwargs
+    for func, arguments in kwarg_callables:
+        for signature in func.get_signatures():
+            found_kwarg_signature = True
+            for p in process_params(
+                    list(_remove_given_params(
+                        arguments,
+                        signature.get_param_names(resolve_stars=False)
+                    )), star_count=2):
+                if p.get_kind() == Parameter.VAR_KEYWORD:
+                    kwarg_names.append(p)
+                elif p.get_kind() == Parameter.KEYWORD_ONLY:
+                    kw_only_names.append(p)
+
+    for p in kw_only_names:
+        if p.string_name in used_names:
+            continue
+        yield p
+        used_names.add(p.string_name)
+
+    if not found_kwarg_signature and original_kwarg_name is not None:
+        yield original_kwarg_name
+    elif kwarg_names:
+        yield kwarg_names[0]
+
+
+class ParamNameFixedKind(ParamNameWrapper):
+    def __init__(self, param_name, new_kind):
+        super(ParamNameFixedKind, self).__init__(param_name)
+        self._new_kind = new_kind
+
+    def get_kind(self):
+        return self._new_kind

venv/Lib/site-packages/jedi/inference/syntax_tree.py

@@ -0,0 +1,884 @@
+"""
+Functions inferring the syntax tree.
+"""
+import copy
+
+from parso.python import tree
+
+from jedi._compatibility import force_unicode, unicode
+from jedi import debug
+from jedi import parser_utils
+from jedi.inference.base_value import ValueSet, NO_VALUES, ContextualizedNode, \
+    iterator_to_value_set, iterate_values
+from jedi.inference.lazy_value import LazyTreeValue
+from jedi.inference import compiled
+from jedi.inference import recursion
+from jedi.inference import analysis
+from jedi.inference import imports
+from jedi.inference import arguments
+from jedi.inference.value import ClassValue, FunctionValue
+from jedi.inference.value import iterable
+from jedi.inference.value.dynamic_arrays import ListModification, DictModification
+from jedi.inference.value import TreeInstance
+from jedi.inference.helpers import is_string, is_literal, is_number, \
+    get_names_of_node, is_big_annoying_library
+from jedi.inference.compiled.access import COMPARISON_OPERATORS
+from jedi.inference.cache import inference_state_method_cache
+from jedi.inference.gradual.stub_value import VersionInfo
+from jedi.inference.gradual import annotation
+from jedi.inference.names import TreeNameDefinition
+from jedi.inference.context import CompForContext
+from jedi.inference.value.decorator import Decoratee
+from jedi.plugins import plugin_manager
+
+operator_to_magic_method = {
+    '+': '__add__',
+    '-': '__sub__',
+    '*': '__mul__',
+    '@': '__matmul__',
+    '/': '__truediv__',
+    '//': '__floordiv__',
+    '%': '__mod__',
+    '**': '__pow__',
+    '<<': '__lshift__',
+    '>>': '__rshift__',
+    '&': '__and__',
+    '|': '__or__',
+    '^': '__xor__',
+}
+
+reverse_operator_to_magic_method = {
+    k: '__r' + v[2:] for k, v in operator_to_magic_method.items()
+}
+
+
+def _limit_value_infers(func):
+    """
+    This is for now the way how we limit type inference going wild. There are
+    other ways to ensure recursion limits as well. This is mostly necessary
+    because of instance (self) access that can be quite tricky to limit.
+
+    I'm still not sure this is the way to go, but it looks okay for now and we
+    can still go anther way in the future. Tests are there. ~ dave
+    """
+    def wrapper(context, *args, **kwargs):
+        n = context.tree_node
+        inference_state = context.inference_state
+        try:
+            inference_state.inferred_element_counts[n] += 1
+            maximum = 300
+            if context.parent_context is None \
+                    and context.get_value() is inference_state.builtins_module:
+                # Builtins should have a more generous inference limit.
+                # It is important that builtins can be executed, otherwise some
+                # functions that depend on certain builtins features would be
+                # broken, see e.g. GH #1432
+                maximum *= 100
+
+            if inference_state.inferred_element_counts[n] > maximum:
+                debug.warning('In value %s there were too many inferences.', n)
+                return NO_VALUES
+        except KeyError:
+            inference_state.inferred_element_counts[n] = 1
+        return func(context, *args, **kwargs)
+
+    return wrapper
+
+
+def infer_node(context, element):
+    if isinstance(context, CompForContext):
+        return _infer_node(context, element)
+
+    if_stmt = element
+    while if_stmt is not None:
+        if_stmt = if_stmt.parent
+        if if_stmt.type in ('if_stmt', 'for_stmt'):
+            break
+        if parser_utils.is_scope(if_stmt):
+            if_stmt = None
+            break
+    predefined_if_name_dict = context.predefined_names.get(if_stmt)
+    # TODO there's a lot of issues with this one. We actually should do
+    # this in a different way. Caching should only be active in certain
+    # cases and this all sucks.
+    if predefined_if_name_dict is None and if_stmt \
+            and if_stmt.type == 'if_stmt' and context.inference_state.is_analysis:
+        if_stmt_test = if_stmt.children[1]
+        name_dicts = [{}]
+        # If we already did a check, we don't want to do it again -> If
+        # value.predefined_names is filled, we stop.
+        # We don't want to check the if stmt itself, it's just about
+        # the content.
+        if element.start_pos > if_stmt_test.end_pos:
+            # Now we need to check if the names in the if_stmt match the
+            # names in the suite.
+            if_names = get_names_of_node(if_stmt_test)
+            element_names = get_names_of_node(element)
+            str_element_names = [e.value for e in element_names]
+            if any(i.value in str_element_names for i in if_names):
+                for if_name in if_names:
+                    definitions = context.inference_state.infer(context, if_name)
+                    # Every name that has multiple different definitions
+                    # causes the complexity to rise. The complexity should
+                    # never fall below 1.
+                    if len(definitions) > 1:
+                        if len(name_dicts) * len(definitions) > 16:
+                            debug.dbg('Too many options for if branch inference %s.', if_stmt)
+                            # There's only a certain amount of branches
+                            # Jedi can infer, otherwise it will take to
+                            # long.
+                            name_dicts = [{}]
+                            break
+
+                        original_name_dicts = list(name_dicts)
+                        name_dicts = []
+                        for definition in definitions:
+                            new_name_dicts = list(original_name_dicts)
+                            for i, name_dict in enumerate(new_name_dicts):
+                                new_name_dicts[i] = name_dict.copy()
+                                new_name_dicts[i][if_name.value] = ValueSet([definition])
+
+                            name_dicts += new_name_dicts
+                    else:
+                        for name_dict in name_dicts:
+                            name_dict[if_name.value] = definitions
+        if len(name_dicts) > 1:
+            result = NO_VALUES
+            for name_dict in name_dicts:
+                with context.predefine_names(if_stmt, name_dict):
+                    result |= _infer_node(context, element)
+            return result
+        else:
+            return _infer_node_if_inferred(context, element)
+    else:
+        if predefined_if_name_dict:
+            return _infer_node(context, element)
+        else:
+            return _infer_node_if_inferred(context, element)
+
+
+def _infer_node_if_inferred(context, element):
+    """
+    TODO This function is temporary: Merge with infer_node.
+    """
+    parent = element
+    while parent is not None:
+        parent = parent.parent
+        predefined_if_name_dict = context.predefined_names.get(parent)
+        if predefined_if_name_dict is not None:
+            return _infer_node(context, element)
+    return _infer_node_cached(context, element)
+
+
+@inference_state_method_cache(default=NO_VALUES)
+def _infer_node_cached(context, element):
+    return _infer_node(context, element)
+
+
+@debug.increase_indent
+@_limit_value_infers
+def _infer_node(context, element):
+    debug.dbg('infer_node %s@%s in %s', element, element.start_pos, context)
+    inference_state = context.inference_state
+    typ = element.type
+    if typ in ('name', 'number', 'string', 'atom', 'strings', 'keyword', 'fstring'):
+        return infer_atom(context, element)
+    elif typ == 'lambdef':
+        return ValueSet([FunctionValue.from_context(context, element)])
+    elif typ == 'expr_stmt':
+        return infer_expr_stmt(context, element)
+    elif typ in ('power', 'atom_expr'):
+        first_child = element.children[0]
+        children = element.children[1:]
+        had_await = False
+        if first_child.type == 'keyword' and first_child.value == 'await':
+            had_await = True
+            first_child = children.pop(0)
+
+        value_set = context.infer_node(first_child)
+        for (i, trailer) in enumerate(children):
+            if trailer == '**':  # has a power operation.
+                right = context.infer_node(children[i + 1])
+                value_set = _infer_comparison(
+                    context,
+                    value_set,
+                    trailer,
+                    right
+                )
+                break
+            value_set = infer_trailer(context, value_set, trailer)
+
+        if had_await:
+            return value_set.py__await__().py__stop_iteration_returns()
+        return value_set
+    elif typ in ('testlist_star_expr', 'testlist',):
+        # The implicit tuple in statements.
+        return ValueSet([iterable.SequenceLiteralValue(inference_state, context, element)])
+    elif typ in ('not_test', 'factor'):
+        value_set = context.infer_node(element.children[-1])
+        for operator in element.children[:-1]:
+            value_set = infer_factor(value_set, operator)
+        return value_set
+    elif typ == 'test':
+        # `x if foo else y` case.
+        return (context.infer_node(element.children[0])
+                | context.infer_node(element.children[-1]))
+    elif typ == 'operator':
+        # Must be an ellipsis, other operators are not inferred.
+        # In Python 2 ellipsis is coded as three single dot tokens, not
+        # as one token 3 dot token.
+        if element.value not in ('.', '...'):
+            origin = element.parent
+            raise AssertionError("unhandled operator %s in %s " % (repr(element.value), origin))
+        return ValueSet([compiled.builtin_from_name(inference_state, u'Ellipsis')])
+    elif typ == 'dotted_name':
+        value_set = infer_atom(context, element.children[0])
+        for next_name in element.children[2::2]:
+            value_set = value_set.py__getattribute__(next_name, name_context=context)
+        return value_set
+    elif typ == 'eval_input':
+        return context.infer_node(element.children[0])
+    elif typ == 'annassign':
+        return annotation.infer_annotation(context, element.children[1]) \
+            .execute_annotation()
+    elif typ == 'yield_expr':
+        if len(element.children) and element.children[1].type == 'yield_arg':
+            # Implies that it's a yield from.
+            element = element.children[1].children[1]
+            generators = context.infer_node(element) \
+                .py__getattribute__('__iter__').execute_with_values()
+            return generators.py__stop_iteration_returns()
+
+        # Generator.send() is not implemented.
+        return NO_VALUES
+    elif typ == 'namedexpr_test':
+        return context.infer_node(element.children[2])
+    else:
+        return infer_or_test(context, element)
+
+
+def infer_trailer(context, atom_values, trailer):
+    trailer_op, node = trailer.children[:2]
+    if node == ')':  # `arglist` is optional.
+        node = None
+
+    if trailer_op == '[':
+        trailer_op, node, _ = trailer.children
+        return atom_values.get_item(
+            _infer_subscript_list(context, node),
+            ContextualizedNode(context, trailer)
+        )
+    else:
+        debug.dbg('infer_trailer: %s in %s', trailer, atom_values)
+        if trailer_op == '.':
+            return atom_values.py__getattribute__(
+                name_context=context,
+                name_or_str=node
+            )
+        else:
+            assert trailer_op == '(', 'trailer_op is actually %s' % trailer_op
+            args = arguments.TreeArguments(context.inference_state, context, node, trailer)
+            return atom_values.execute(args)
+
+
+def infer_atom(context, atom):
+    """
+    Basically to process ``atom`` nodes. The parser sometimes doesn't
+    generate the node (because it has just one child). In that case an atom
+    might be a name or a literal as well.
+    """
+    state = context.inference_state
+    if atom.type == 'name':
+        if atom.value in ('True', 'False', 'None'):
+            # Python 2...
+            return ValueSet([compiled.builtin_from_name(state, atom.value)])
+
+        # This is the first global lookup.
+        stmt = tree.search_ancestor(
+            atom, 'expr_stmt', 'lambdef'
+        ) or atom
+        if stmt.type == 'lambdef':
+            stmt = atom
+        position = stmt.start_pos
+        if _is_annotation_name(atom):
+            # Since Python 3.7 (with from __future__ import annotations),
+            # annotations are essentially strings and can reference objects
+            # that are defined further down in code. Therefore just set the
+            # position to None, so the finder will not try to stop at a certain
+            # position in the module.
+            position = None
+        return context.py__getattribute__(atom, position=position)
+    elif atom.type == 'keyword':
+        # For False/True/None
+        if atom.value in ('False', 'True', 'None'):
+            return ValueSet([compiled.builtin_from_name(state, atom.value)])
+        elif atom.value == 'print':
+            # print e.g. could be inferred like this in Python 2.7
+            return NO_VALUES
+        elif atom.value == 'yield':
+            # Contrary to yield from, yield can just appear alone to return a
+            # value when used with `.send()`.
+            return NO_VALUES
+        assert False, 'Cannot infer the keyword %s' % atom
+
+    elif isinstance(atom, tree.Literal):
+        string = state.compiled_subprocess.safe_literal_eval(atom.value)
+        return ValueSet([compiled.create_simple_object(state, string)])
+    elif atom.type == 'strings':
+        # Will be multiple string.
+        value_set = infer_atom(context, atom.children[0])
+        for string in atom.children[1:]:
+            right = infer_atom(context, string)
+            value_set = _infer_comparison(context, value_set, u'+', right)
+        return value_set
+    elif atom.type == 'fstring':
+        return compiled.get_string_value_set(state)
+    else:
+        c = atom.children
+        # Parentheses without commas are not tuples.
+        if c[0] == '(' and not len(c) == 2 \
+                and not(c[1].type == 'testlist_comp'
+                        and len(c[1].children) > 1):
+            return context.infer_node(c[1])
+
+        try:
+            comp_for = c[1].children[1]
+        except (IndexError, AttributeError):
+            pass
+        else:
+            if comp_for == ':':
+                # Dict comprehensions have a colon at the 3rd index.
+                try:
+                    comp_for = c[1].children[3]
+                except IndexError:
+                    pass
+
+            if comp_for.type in ('comp_for', 'sync_comp_for'):
+                return ValueSet([iterable.comprehension_from_atom(
+                    state, context, atom
+                )])
+
+        # It's a dict/list/tuple literal.
+        array_node = c[1]
+        try:
+            array_node_c = array_node.children
+        except AttributeError:
+            array_node_c = []
+        if c[0] == '{' and (array_node == '}' or ':' in array_node_c
+                            or '**' in array_node_c):
+            new_value = iterable.DictLiteralValue(state, context, atom)
+        else:
+            new_value = iterable.SequenceLiteralValue(state, context, atom)
+        return ValueSet([new_value])
+
+
+@_limit_value_infers
+def infer_expr_stmt(context, stmt, seek_name=None):
+    with recursion.execution_allowed(context.inference_state, stmt) as allowed:
+        if allowed:
+            if seek_name is not None:
+                pep0484_values = \
+                    annotation.find_type_from_comment_hint_assign(context, stmt, seek_name)
+                if pep0484_values:
+                    return pep0484_values
+
+            return _infer_expr_stmt(context, stmt, seek_name)
+    return NO_VALUES
+
+
+@debug.increase_indent
+def _infer_expr_stmt(context, stmt, seek_name=None):
+    """
+    The starting point of the completion. A statement always owns a call
+    list, which are the calls, that a statement does. In case multiple
+    names are defined in the statement, `seek_name` returns the result for
+    this name.
+
+    expr_stmt: testlist_star_expr (annassign | augassign (yield_expr|testlist) |
+                     ('=' (yield_expr|testlist_star_expr))*)
+    annassign: ':' test ['=' test]
+    augassign: ('+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' | '^=' |
+                '<<=' | '>>=' | '**=' | '//=')
+
+    :param stmt: A `tree.ExprStmt`.
+    """
+    def check_setitem(stmt):
+        atom_expr = stmt.children[0]
+        if atom_expr.type not in ('atom_expr', 'power'):
+            return False, None
+        name = atom_expr.children[0]
+        if name.type != 'name' or len(atom_expr.children) != 2:
+            return False, None
+        trailer = atom_expr.children[-1]
+        return trailer.children[0] == '[', trailer.children[1]
+
+    debug.dbg('infer_expr_stmt %s (%s)', stmt, seek_name)
+    rhs = stmt.get_rhs()
+
+    value_set = context.infer_node(rhs)
+
+    if seek_name:
+        n = TreeNameDefinition(context, seek_name)
+        value_set = check_tuple_assignments(n, value_set)
+
+    first_operator = next(stmt.yield_operators(), None)
+    is_setitem, subscriptlist = check_setitem(stmt)
+    is_annassign = first_operator not in ('=', None) and first_operator.type == 'operator'
+    if is_annassign or is_setitem:
+        # `=` is always the last character in aug assignments -> -1
+        name = stmt.get_defined_names(include_setitem=True)[0].value
+        left_values = context.py__getattribute__(name, position=stmt.start_pos)
+
+        if is_setitem:
+            def to_mod(v):
+                c = ContextualizedSubscriptListNode(context, subscriptlist)
+                if v.array_type == 'dict':
+                    return DictModification(v, value_set, c)
+                elif v.array_type == 'list':
+                    return ListModification(v, value_set, c)
+                return v
+
+            value_set = ValueSet(to_mod(v) for v in left_values)
+        else:
+            operator = copy.copy(first_operator)
+            operator.value = operator.value[:-1]
+            for_stmt = tree.search_ancestor(stmt, 'for_stmt')
+            if for_stmt is not None and for_stmt.type == 'for_stmt' and value_set \
+                    and parser_utils.for_stmt_defines_one_name(for_stmt):
+                # Iterate through result and add the values, that's possible
+                # only in for loops without clutter, because they are
+                # predictable. Also only do it, if the variable is not a tuple.
+                node = for_stmt.get_testlist()
+                cn = ContextualizedNode(context, node)
+                ordered = list(cn.infer().iterate(cn))
+
+                for lazy_value in ordered:
+                    dct = {for_stmt.children[1].value: lazy_value.infer()}
+                    with context.predefine_names(for_stmt, dct):
+                        t = context.infer_node(rhs)
+                        left_values = _infer_comparison(context, left_values, operator, t)
+                value_set = left_values
+            else:
+                value_set = _infer_comparison(context, left_values, operator, value_set)
+    debug.dbg('infer_expr_stmt result %s', value_set)
+    return value_set
+
+
+def infer_or_test(context, or_test):
+    iterator = iter(or_test.children)
+    types = context.infer_node(next(iterator))
+    for operator in iterator:
+        right = next(iterator)
+        if operator.type == 'comp_op':  # not in / is not
+            operator = ' '.join(c.value for c in operator.children)
+
+        # handle type inference of and/or here.
+        if operator in ('and', 'or'):
+            left_bools = set(left.py__bool__() for left in types)
+            if left_bools == {True}:
+                if operator == 'and':
+                    types = context.infer_node(right)
+            elif left_bools == {False}:
+                if operator != 'and':
+                    types = context.infer_node(right)
+            # Otherwise continue, because of uncertainty.
+        else:
+            types = _infer_comparison(context, types, operator,
+                                      context.infer_node(right))
+    debug.dbg('infer_or_test types %s', types)
+    return types
+
+
+@iterator_to_value_set
+def infer_factor(value_set, operator):
+    """
+    Calculates `+`, `-`, `~` and `not` prefixes.
+    """
+    for value in value_set:
+        if operator == '-':
+            if is_number(value):
+                yield value.negate()
+        elif operator == 'not':
+            b = value.py__bool__()
+            if b is None:  # Uncertainty.
+                return
+            yield compiled.create_simple_object(value.inference_state, not b)
+        else:
+            yield value
+
+
+def _literals_to_types(inference_state, result):
+    # Changes literals ('a', 1, 1.0, etc) to its type instances (str(),
+    # int(), float(), etc).
+    new_result = NO_VALUES
+    for typ in result:
+        if is_literal(typ):
+            # Literals are only valid as long as the operations are
+            # correct. Otherwise add a value-free instance.
+            cls = compiled.builtin_from_name(inference_state, typ.name.string_name)
+            new_result |= cls.execute_with_values()
+        else:
+            new_result |= ValueSet([typ])
+    return new_result
+
+
+def _infer_comparison(context, left_values, operator, right_values):
+    state = context.inference_state
+    if not left_values or not right_values:
+        # illegal slices e.g. cause left/right_result to be None
+        result = (left_values or NO_VALUES) | (right_values or NO_VALUES)
+        return _literals_to_types(state, result)
+    else:
+        # I don't think there's a reasonable chance that a string
+        # operation is still correct, once we pass something like six
+        # objects.
+        if len(left_values) * len(right_values) > 6:
+            return _literals_to_types(state, left_values | right_values)
+        else:
+            return ValueSet.from_sets(
+                _infer_comparison_part(state, context, left, operator, right)
+                for left in left_values
+                for right in right_values
+            )
+
+
+def _is_annotation_name(name):
+    ancestor = tree.search_ancestor(name, 'param', 'funcdef', 'expr_stmt')
+    if ancestor is None:
+        return False
+
+    if ancestor.type in ('param', 'funcdef'):
+        ann = ancestor.annotation
+        if ann is not None:
+            return ann.start_pos <= name.start_pos < ann.end_pos
+    elif ancestor.type == 'expr_stmt':
+        c = ancestor.children
+        if len(c) > 1 and c[1].type == 'annassign':
+            return c[1].start_pos <= name.start_pos < c[1].end_pos
+    return False
+
+
+def _is_list(value):
+    return value.array_type == 'list'
+
+
+def _is_tuple(value):
+    return value.array_type == 'tuple'
+
+
+def _bool_to_value(inference_state, bool_):
+    return compiled.builtin_from_name(inference_state, force_unicode(str(bool_)))
+
+
+def _get_tuple_ints(value):
+    if not isinstance(value, iterable.SequenceLiteralValue):
+        return None
+    numbers = []
+    for lazy_value in value.py__iter__():
+        if not isinstance(lazy_value, LazyTreeValue):
+            return None
+        node = lazy_value.data
+        if node.type != 'number':
+            return None
+        try:
+            numbers.append(int(node.value))
+        except ValueError:
+            return None
+    return numbers
+
+
+def _infer_comparison_part(inference_state, context, left, operator, right):
+    l_is_num = is_number(left)
+    r_is_num = is_number(right)
+    if isinstance(operator, unicode):
+        str_operator = operator
+    else:
+        str_operator = force_unicode(str(operator.value))
+
+    if str_operator == '*':
+        # for iterables, ignore * operations
+        if isinstance(left, iterable.Sequence) or is_string(left):
+            return ValueSet([left])
+        elif isinstance(right, iterable.Sequence) or is_string(right):
+            return ValueSet([right])
+    elif str_operator == '+':
+        if l_is_num and r_is_num or is_string(left) and is_string(right):
+            return left.execute_operation(right, str_operator)
+        elif _is_list(left) and _is_list(right) or _is_tuple(left) and _is_tuple(right):
+            return ValueSet([iterable.MergedArray(inference_state, (left, right))])
+    elif str_operator == '-':
+        if l_is_num and r_is_num:
+            return left.execute_operation(right, str_operator)
+    elif str_operator == '%':
+        # With strings and numbers the left type typically remains. Except for
+        # `int() % float()`.
+        return ValueSet([left])
+    elif str_operator in COMPARISON_OPERATORS:
+        if left.is_compiled() and right.is_compiled():
+            # Possible, because the return is not an option. Just compare.
+            result = left.execute_operation(right, str_operator)
+            if result:
+                return result
+        else:
+            if str_operator in ('is', '!=', '==', 'is not'):
+                operation = COMPARISON_OPERATORS[str_operator]
+                bool_ = operation(left, right)
+                # Only if == returns True or != returns False, we can continue.
+                # There's no guarantee that they are not equal. This can help
+                # in some cases, but does not cover everything.
+                if (str_operator in ('is', '==')) == bool_:
+                    return ValueSet([_bool_to_value(inference_state, bool_)])
+
+            if isinstance(left, VersionInfo):
+                version_info = _get_tuple_ints(right)
+                if version_info is not None:
+                    bool_result = compiled.access.COMPARISON_OPERATORS[operator](
+                        inference_state.environment.version_info,
+                        tuple(version_info)
+                    )
+                    return ValueSet([_bool_to_value(inference_state, bool_result)])
+
+        return ValueSet([
+            _bool_to_value(inference_state, True),
+            _bool_to_value(inference_state, False)
+        ])
+    elif str_operator in ('in', 'not in'):
+        return NO_VALUES
+
+    def check(obj):
+        """Checks if a Jedi object is either a float or an int."""
+        return isinstance(obj, TreeInstance) and \
+            obj.name.string_name in ('int', 'float')
+
+    # Static analysis, one is a number, the other one is not.
+    if str_operator in ('+', '-') and l_is_num != r_is_num \
+            and not (check(left) or check(right)):
+        message = "TypeError: unsupported operand type(s) for +: %s and %s"
+        analysis.add(context, 'type-error-operation', operator,
+                     message % (left, right))
+
+    if left.is_class() or right.is_class():
+        return NO_VALUES
+
+    method_name = operator_to_magic_method[str_operator]
+    magic_methods = left.py__getattribute__(method_name)
+    if magic_methods:
+        result = magic_methods.execute_with_values(right)
+        if result:
+            return result
+
+    if not magic_methods:
+        reverse_method_name = reverse_operator_to_magic_method[str_operator]
+        magic_methods = right.py__getattribute__(reverse_method_name)
+
+        result = magic_methods.execute_with_values(left)
+        if result:
+            return result
+
+    result = ValueSet([left, right])
+    debug.dbg('Used operator %s resulting in %s', operator, result)
+    return result
+
+
+@plugin_manager.decorate()
+def tree_name_to_values(inference_state, context, tree_name):
+    value_set = NO_VALUES
+    module_node = context.get_root_context().tree_node
+    # First check for annotations, like: `foo: int = 3`
+    if module_node is not None:
+        names = module_node.get_used_names().get(tree_name.value, [])
+        found_annotation = False
+        for name in names:
+            expr_stmt = name.parent
+
+            if expr_stmt.type == "expr_stmt" and expr_stmt.children[1].type == "annassign":
+                correct_scope = parser_utils.get_parent_scope(name) == context.tree_node
+                if correct_scope:
+                    found_annotation = True
+                    value_set |= annotation.infer_annotation(
+                        context, expr_stmt.children[1].children[1]
+                    ).execute_annotation()
+        if found_annotation:
+            return value_set
+
+    types = []
+    node = tree_name.get_definition(import_name_always=True, include_setitem=True)
+    if node is None:
+        node = tree_name.parent
+        if node.type == 'global_stmt':
+            c = context.create_context(tree_name)
+            if c.is_module():
+                # In case we are already part of the module, there is no point
+                # in looking up the global statement anymore, because it's not
+                # valid at that point anyway.
+                return NO_VALUES
+            # For global_stmt lookups, we only need the first possible scope,
+            # which means the function itself.
+            filter = next(c.get_filters())
+            names = filter.get(tree_name.value)
+            return ValueSet.from_sets(name.infer() for name in names)
+        elif node.type not in ('import_from', 'import_name'):
+            c = context.create_context(tree_name)
+            return infer_atom(c, tree_name)
+
+    typ = node.type
+    if typ == 'for_stmt':
+        types = annotation.find_type_from_comment_hint_for(context, node, tree_name)
+        if types:
+            return types
+    if typ == 'with_stmt':
+        types = annotation.find_type_from_comment_hint_with(context, node, tree_name)
+        if types:
+            return types
+
+    if typ in ('for_stmt', 'comp_for', 'sync_comp_for'):
+        try:
+            types = context.predefined_names[node][tree_name.value]
+        except KeyError:
+            cn = ContextualizedNode(context, node.children[3])
+            for_types = iterate_values(
+                cn.infer(),
+                contextualized_node=cn,
+                is_async=node.parent.type == 'async_stmt',
+            )
+            n = TreeNameDefinition(context, tree_name)
+            types = check_tuple_assignments(n, for_types)
+    elif typ == 'expr_stmt':
+        types = infer_expr_stmt(context, node, tree_name)
+    elif typ == 'with_stmt':
+        value_managers = context.infer_node(node.get_test_node_from_name(tree_name))
+        enter_methods = value_managers.py__getattribute__(u'__enter__')
+        return enter_methods.execute_with_values()
+    elif typ in ('import_from', 'import_name'):
+        types = imports.infer_import(context, tree_name)
+    elif typ in ('funcdef', 'classdef'):
+        types = _apply_decorators(context, node)
+    elif typ == 'try_stmt':
+        # TODO an exception can also be a tuple. Check for those.
+        # TODO check for types that are not classes and add it to
+        # the static analysis report.
+        exceptions = context.infer_node(tree_name.get_previous_sibling().get_previous_sibling())
+        types = exceptions.execute_with_values()
+    elif typ == 'param':
+        types = NO_VALUES
+    elif typ == 'del_stmt':
+        types = NO_VALUES
+    else:
+        raise ValueError("Should not happen. type: %s" % typ)
+    return types
+
+
+# We don't want to have functions/classes that are created by the same
+# tree_node.
+@inference_state_method_cache()
+def _apply_decorators(context, node):
+    """
+    Returns the function, that should to be executed in the end.
+    This is also the places where the decorators are processed.
+    """
+    if node.type == 'classdef':
+        decoratee_value = ClassValue(
+            context.inference_state,
+            parent_context=context,
+            tree_node=node
+        )
+    else:
+        decoratee_value = FunctionValue.from_context(context, node)
+    initial = values = ValueSet([decoratee_value])
+
+    if is_big_annoying_library(context):
+        return values
+
+    for dec in reversed(node.get_decorators()):
+        debug.dbg('decorator: %s %s', dec, values, color="MAGENTA")
+        with debug.increase_indent_cm():
+            dec_values = context.infer_node(dec.children[1])
+            trailer_nodes = dec.children[2:-1]
+            if trailer_nodes:
+                # Create a trailer and infer it.
+                trailer = tree.PythonNode('trailer', trailer_nodes)
+                trailer.parent = dec
+                dec_values = infer_trailer(context, dec_values, trailer)
+
+            if not len(dec_values):
+                code = dec.get_code(include_prefix=False)
+                # For the short future, we don't want to hear about the runtime
+                # decorator in typing that was intentionally omitted. This is not
+                # "correct", but helps with debugging.
+                if code != '@runtime\n':
+                    debug.warning('decorator not found: %s on %s', dec, node)
+                return initial
+
+            values = dec_values.execute(arguments.ValuesArguments([values]))
+            if not len(values):
+                debug.warning('not possible to resolve wrappers found %s', node)
+                return initial
+
+        debug.dbg('decorator end %s', values, color="MAGENTA")
+    if values != initial:
+        return ValueSet([Decoratee(c, decoratee_value) for c in values])
+    return values
+
+
+def check_tuple_assignments(name, value_set):
+    """
+    Checks if tuples are assigned.
+    """
+    lazy_value = None
+    for index, node in name.assignment_indexes():
+        cn = ContextualizedNode(name.parent_context, node)
+        iterated = value_set.iterate(cn)
+        if isinstance(index, slice):
+            # For no star unpacking is not possible.
+            return NO_VALUES
+        i = 0
+        while i <= index:
+            try:
+                lazy_value = next(iterated)
+            except StopIteration:
+                # We could do this with the default param in next. But this
+                # would allow this loop to run for a very long time if the
+                # index number is high. Therefore break if the loop is
+                # finished.
+                return NO_VALUES
+            else:
+                i += lazy_value.max
+        value_set = lazy_value.infer()
+    return value_set
+
+
+class ContextualizedSubscriptListNode(ContextualizedNode):
+    def infer(self):
+        return _infer_subscript_list(self.context, self.node)
+
+
+def _infer_subscript_list(context, index):
+    """
+    Handles slices in subscript nodes.
+    """
+    if index == ':':
+        # Like array[:]
+        return ValueSet([iterable.Slice(context, None, None, None)])
+
+    elif index.type == 'subscript' and not index.children[0] == '.':
+        # subscript basically implies a slice operation, except for Python 2's
+        # Ellipsis.
+        # e.g. array[:3]
+        result = []
+        for el in index.children:
+            if el == ':':
+                if not result:
+                    result.append(None)
+            elif el.type == 'sliceop':
+                if len(el.children) == 2:
+                    result.append(el.children[1])
+            else:
+                result.append(el)
+        result += [None] * (3 - len(result))
+
+        return ValueSet([iterable.Slice(context, *result)])
+    elif index.type == 'subscriptlist':
+        return ValueSet([iterable.SequenceLiteralValue(context.inference_state, context, index)])
+
+    # No slices
+    return context.infer_node(index)

venv/Lib/site-packages/jedi/inference/sys_path.py

@@ -0,0 +1,271 @@
+import os
+import re
+
+from jedi._compatibility import unicode, force_unicode, all_suffixes
+from jedi.inference.cache import inference_state_method_cache
+from jedi.inference.base_value import ContextualizedNode
+from jedi.inference.helpers import is_string, get_str_or_none
+from jedi.common import traverse_parents
+from jedi.parser_utils import get_cached_code_lines
+from jedi.file_io import FileIO
+from jedi import settings
+from jedi import debug
+
+_BUILDOUT_PATH_INSERTION_LIMIT = 10
+
+
+def _abs_path(module_context, path):
+    if os.path.isabs(path):
+        return path
+
+    module_path = module_context.py__file__()
+    if module_path is None:
+        # In this case we have no idea where we actually are in the file
+        # system.
+        return None
+
+    base_dir = os.path.dirname(module_path)
+    path = force_unicode(path)
+    return os.path.abspath(os.path.join(base_dir, path))
+
+
+def _paths_from_assignment(module_context, expr_stmt):
+    """
+    Extracts the assigned strings from an assignment that looks as follows::
+
+        sys.path[0:0] = ['module/path', 'another/module/path']
+
+    This function is in general pretty tolerant (and therefore 'buggy').
+    However, it's not a big issue usually to add more paths to Jedi's sys_path,
+    because it will only affect Jedi in very random situations and by adding
+    more paths than necessary, it usually benefits the general user.
+    """
+    for assignee, operator in zip(expr_stmt.children[::2], expr_stmt.children[1::2]):
+        try:
+            assert operator in ['=', '+=']
+            assert assignee.type in ('power', 'atom_expr') and \
+                len(assignee.children) > 1
+            c = assignee.children
+            assert c[0].type == 'name' and c[0].value == 'sys'
+            trailer = c[1]
+            assert trailer.children[0] == '.' and trailer.children[1].value == 'path'
+            # TODO Essentially we're not checking details on sys.path
+            # manipulation. Both assigment of the sys.path and changing/adding
+            # parts of the sys.path are the same: They get added to the end of
+            # the current sys.path.
+            """
+            execution = c[2]
+            assert execution.children[0] == '['
+            subscript = execution.children[1]
+            assert subscript.type == 'subscript'
+            assert ':' in subscript.children
+            """
+        except AssertionError:
+            continue
+
+        cn = ContextualizedNode(module_context.create_context(expr_stmt), expr_stmt)
+        for lazy_value in cn.infer().iterate(cn):
+            for value in lazy_value.infer():
+                if is_string(value):
+                    abs_path = _abs_path(module_context, value.get_safe_value())
+                    if abs_path is not None:
+                        yield abs_path
+
+
+def _paths_from_list_modifications(module_context, trailer1, trailer2):
+    """ extract the path from either "sys.path.append" or "sys.path.insert" """
+    # Guarantee that both are trailers, the first one a name and the second one
+    # a function execution with at least one param.
+    if not (trailer1.type == 'trailer' and trailer1.children[0] == '.'
+            and trailer2.type == 'trailer' and trailer2.children[0] == '('
+            and len(trailer2.children) == 3):
+        return
+
+    name = trailer1.children[1].value
+    if name not in ['insert', 'append']:
+        return
+    arg = trailer2.children[1]
+    if name == 'insert' and len(arg.children) in (3, 4):  # Possible trailing comma.
+        arg = arg.children[2]
+
+    for value in module_context.create_context(arg).infer_node(arg):
+        p = get_str_or_none(value)
+        if p is None:
+            continue
+        abs_path = _abs_path(module_context, p)
+        if abs_path is not None:
+            yield abs_path
+
+
+@inference_state_method_cache(default=[])
+def check_sys_path_modifications(module_context):
+    """
+    Detect sys.path modifications within module.
+    """
+    def get_sys_path_powers(names):
+        for name in names:
+            power = name.parent.parent
+            if power is not None and power.type in ('power', 'atom_expr'):
+                c = power.children
+                if c[0].type == 'name' and c[0].value == 'sys' \
+                        and c[1].type == 'trailer':
+                    n = c[1].children[1]
+                    if n.type == 'name' and n.value == 'path':
+                        yield name, power
+
+    if module_context.tree_node is None:
+        return []
+
+    added = []
+    try:
+        possible_names = module_context.tree_node.get_used_names()['path']
+    except KeyError:
+        pass
+    else:
+        for name, power in get_sys_path_powers(possible_names):
+            expr_stmt = power.parent
+            if len(power.children) >= 4:
+                added.extend(
+                    _paths_from_list_modifications(
+                        module_context, *power.children[2:4]
+                    )
+                )
+            elif expr_stmt is not None and expr_stmt.type == 'expr_stmt':
+                added.extend(_paths_from_assignment(module_context, expr_stmt))
+    return added
+
+
+def discover_buildout_paths(inference_state, script_path):
+    buildout_script_paths = set()
+
+    for buildout_script_path in _get_buildout_script_paths(script_path):
+        for path in _get_paths_from_buildout_script(inference_state, buildout_script_path):
+            buildout_script_paths.add(path)
+            if len(buildout_script_paths) >= _BUILDOUT_PATH_INSERTION_LIMIT:
+                break
+
+    return buildout_script_paths
+
+
+def _get_paths_from_buildout_script(inference_state, buildout_script_path):
+    file_io = FileIO(buildout_script_path)
+    try:
+        module_node = inference_state.parse(
+            file_io=file_io,
+            cache=True,
+            cache_path=settings.cache_directory
+        )
+    except IOError:
+        debug.warning('Error trying to read buildout_script: %s', buildout_script_path)
+        return
+
+    from jedi.inference.value import ModuleValue
+    module_context = ModuleValue(
+        inference_state, module_node,
+        file_io=file_io,
+        string_names=None,
+        code_lines=get_cached_code_lines(inference_state.grammar, buildout_script_path),
+    ).as_context()
+    for path in check_sys_path_modifications(module_context):
+        yield path
+
+
+def _get_parent_dir_with_file(path, filename):
+    for parent in traverse_parents(path):
+        if os.path.isfile(os.path.join(parent, filename)):
+            return parent
+    return None
+
+
+def _get_buildout_script_paths(search_path):
+    """
+    if there is a 'buildout.cfg' file in one of the parent directories of the
+    given module it will return a list of all files in the buildout bin
+    directory that look like python files.
+
+    :param search_path: absolute path to the module.
+    :type search_path: str
+    """
+    project_root = _get_parent_dir_with_file(search_path, 'buildout.cfg')
+    if not project_root:
+        return
+    bin_path = os.path.join(project_root, 'bin')
+    if not os.path.exists(bin_path):
+        return
+
+    for filename in os.listdir(bin_path):
+        try:
+            filepath = os.path.join(bin_path, filename)
+            with open(filepath, 'r') as f:
+                firstline = f.readline()
+                if firstline.startswith('#!') and 'python' in firstline:
+                    yield filepath
+        except (UnicodeDecodeError, IOError) as e:
+            # Probably a binary file; permission error or race cond. because
+            # file got deleted. Ignore it.
+            debug.warning(unicode(e))
+            continue
+
+
+def remove_python_path_suffix(path):
+    for suffix in all_suffixes() + ['.pyi']:
+        if path.endswith(suffix):
+            path = path[:-len(suffix)]
+            break
+    return path
+
+
+def transform_path_to_dotted(sys_path, module_path):
+    """
+    Returns the dotted path inside a sys.path as a list of names. e.g.
+
+    >>> from os.path import abspath
+    >>> transform_path_to_dotted([abspath("/foo")], abspath('/foo/bar/baz.py'))
+    (('bar', 'baz'), False)
+
+    Returns (None, False) if the path doesn't really resolve to anything.
+    The second return part is if it is a package.
+    """
+    # First remove the suffix.
+    module_path = remove_python_path_suffix(module_path)
+
+    # Once the suffix was removed we are using the files as we know them. This
+    # means that if someone uses an ending like .vim for a Python file, .vim
+    # will be part of the returned dotted part.
+
+    is_package = module_path.endswith(os.path.sep + '__init__')
+    if is_package:
+        # -1 to remove the separator
+        module_path = module_path[:-len('__init__') - 1]
+
+    def iter_potential_solutions():
+        for p in sys_path:
+            if module_path.startswith(p):
+                # Strip the trailing slash/backslash
+                rest = module_path[len(p):]
+                # On Windows a path can also use a slash.
+                if rest.startswith(os.path.sep) or rest.startswith('/'):
+                    # Remove a slash in cases it's still there.
+                    rest = rest[1:]
+
+                if rest:
+                    split = rest.split(os.path.sep)
+                    if not all(split):
+                        # This means that part of the file path was empty, this
+                        # is very strange and is probably a file that is called
+                        # `.py`.
+                        return
+                    # Stub folders for foo can end with foo-stubs. Just remove
+                    # it.
+                    yield tuple(re.sub(r'-stubs$', '', s) for s in split)
+
+    potential_solutions = tuple(iter_potential_solutions())
+    if not potential_solutions:
+        return None, False
+    # Try to find the shortest path, this makes more sense usually, because the
+    # user usually has venvs somewhere. This means that a path like
+    # .tox/py37/lib/python3.7/os.py can be normal for a file. However in that
+    # case we definitely want to return ['os'] as a path and not a crazy
+    # ['.tox', 'py37', 'lib', 'python3.7', 'os']. Keep in mind that this is a
+    # heuristic and there's now ay to "always" do it right.
+    return sorted(potential_solutions, key=lambda p: len(p))[0], is_package

venv/Lib/site-packages/jedi/inference/utils.py

@@ -0,0 +1,115 @@
+""" A universal module with functions / classes without dependencies. """
+import sys
+import contextlib
+import functools
+import re
+import os
+
+from jedi._compatibility import reraise
+
+
+_sep = os.path.sep
+if os.path.altsep is not None:
+    _sep += os.path.altsep
+_path_re = re.compile(r'(?:\.[^{0}]+|[{0}]__init__\.py)$'.format(re.escape(_sep)))
+del _sep
+
+
+def to_list(func):
+    def wrapper(*args, **kwargs):
+        return list(func(*args, **kwargs))
+    return wrapper
+
+
+def to_tuple(func):
+    def wrapper(*args, **kwargs):
+        return tuple(func(*args, **kwargs))
+    return wrapper
+
+
+def unite(iterable):
+    """Turns a two dimensional array into a one dimensional."""
+    return set(typ for types in iterable for typ in types)
+
+
+class UncaughtAttributeError(Exception):
+    """
+    Important, because `__getattr__` and `hasattr` catch AttributeErrors
+    implicitly. This is really evil (mainly because of `__getattr__`).
+    `hasattr` in Python 2 is even more evil, because it catches ALL exceptions.
+    Therefore this class originally had to be derived from `BaseException`
+    instead of `Exception`.  But because I removed relevant `hasattr` from
+    the code base, we can now switch back to `Exception`.
+
+    :param base: return values of sys.exc_info().
+    """
+
+
+def safe_property(func):
+    return property(reraise_uncaught(func))
+
+
+def reraise_uncaught(func):
+    """
+    Re-throw uncaught `AttributeError`.
+
+    Usage:  Put ``@rethrow_uncaught`` in front of the function
+    which does **not** suppose to raise `AttributeError`.
+
+    AttributeError is easily get caught by `hasattr` and another
+    ``except AttributeError`` clause.  This becomes problem when you use
+    a lot of "dynamic" attributes (e.g., using ``@property``) because you
+    can't distinguish if the property does not exist for real or some code
+    inside of the "dynamic" attribute through that error.  In a well
+    written code, such error should not exist but getting there is very
+    difficult.  This decorator is to help us getting there by changing
+    `AttributeError` to `UncaughtAttributeError` to avoid unexpected catch.
+    This helps us noticing bugs earlier and facilitates debugging.
+
+    .. note:: Treating StopIteration here is easy.
+              Add that feature when needed.
+    """
+    @functools.wraps(func)
+    def wrapper(*args, **kwds):
+        try:
+            return func(*args, **kwds)
+        except AttributeError:
+            exc_info = sys.exc_info()
+            reraise(UncaughtAttributeError(exc_info[1]), exc_info[2])
+    return wrapper
+
+
+class PushBackIterator(object):
+    def __init__(self, iterator):
+        self.pushes = []
+        self.iterator = iterator
+        self.current = None
+
+    def push_back(self, value):
+        self.pushes.append(value)
+
+    def __iter__(self):
+        return self
+
+    def next(self):
+        """ Python 2 Compatibility """
+        return self.__next__()
+
+    def __next__(self):
+        if self.pushes:
+            self.current = self.pushes.pop()
+        else:
+            self.current = next(self.iterator)
+        return self.current
+
+
+@contextlib.contextmanager
+def ignored(*exceptions):
+    """
+    Value manager that ignores all of the specified exceptions. This will
+    be in the standard library starting with Python 3.5.
+    """
+    try:
+        yield
+    except exceptions:
+        pass

venv/Lib/site-packages/jedi/inference/value/__init__.py

@@ -0,0 +1,6 @@
+from jedi.inference.value.module import ModuleValue
+from jedi.inference.value.klass import ClassValue
+from jedi.inference.value.function import FunctionValue, \
+    MethodValue
+from jedi.inference.value.instance import AnonymousInstance, BoundMethod, \
+    CompiledInstance, AbstractInstanceValue, TreeInstance

venv/Lib/site-packages/jedi/inference/value/decorator.py

@@ -0,0 +1,21 @@
+'''
+Decorators are not really values, however we need some wrappers to improve
+docstrings and other things around decorators.
+'''
+
+from jedi.inference.base_value import ValueWrapper, ValueSet
+
+
+class Decoratee(ValueWrapper):
+    def __init__(self, wrapped_value, original_value):
+        super(Decoratee, self).__init__(wrapped_value)
+        self._original_value = original_value
+
+    def py__doc__(self):
+        return self._original_value.py__doc__()
+
+    def py__get__(self, instance, class_value):
+        return ValueSet(
+            Decoratee(v, self._original_value)
+            for v in self._wrapped_value.py__get__(instance, class_value)
+        )

venv/Lib/site-packages/jedi/inference/value/dynamic_arrays.py

@@ -0,0 +1,204 @@
+"""
+A module to deal with stuff like `list.append` and `set.add`.
+
+Array modifications
+*******************
+
+If the content of an array (``set``/``list``) is requested somewhere, the
+current module will be checked for appearances of ``arr.append``,
+``arr.insert``, etc.  If the ``arr`` name points to an actual array, the
+content will be added
+
+This can be really cpu intensive, as you can imagine. Because |jedi| has to
+follow **every** ``append`` and check whether it's the right array. However this
+works pretty good, because in *slow* cases, the recursion detector and other
+settings will stop this process.
+
+It is important to note that:
+
+1. Array modfications work only in the current module.
+2. Jedi only checks Array additions; ``list.pop``, etc are ignored.
+"""
+from jedi import debug
+from jedi import settings
+from jedi.inference import recursion
+from jedi.inference.base_value import ValueSet, NO_VALUES, HelperValueMixin, \
+    ValueWrapper
+from jedi.inference.lazy_value import LazyKnownValues
+from jedi.inference.helpers import infer_call_of_leaf
+from jedi.inference.cache import inference_state_method_cache
+
+_sentinel = object()
+
+
+def check_array_additions(context, sequence):
+    """ Just a mapper function for the internal _internal_check_array_additions """
+    if sequence.array_type not in ('list', 'set'):
+        # TODO also check for dict updates
+        return NO_VALUES
+
+    return _internal_check_array_additions(context, sequence)
+
+
+@inference_state_method_cache(default=NO_VALUES)
+@debug.increase_indent
+def _internal_check_array_additions(context, sequence):
+    """
+    Checks if a `Array` has "add" (append, insert, extend) statements:
+
+    >>> a = [""]
+    >>> a.append(1)
+    """
+    from jedi.inference import arguments
+
+    debug.dbg('Dynamic array search for %s' % sequence, color='MAGENTA')
+    module_context = context.get_root_context()
+    if not settings.dynamic_array_additions or module_context.is_compiled():
+        debug.dbg('Dynamic array search aborted.', color='MAGENTA')
+        return NO_VALUES
+
+    def find_additions(context, arglist, add_name):
+        params = list(arguments.TreeArguments(context.inference_state, context, arglist).unpack())
+        result = set()
+        if add_name in ['insert']:
+            params = params[1:]
+        if add_name in ['append', 'add', 'insert']:
+            for key, lazy_value in params:
+                result.add(lazy_value)
+        elif add_name in ['extend', 'update']:
+            for key, lazy_value in params:
+                result |= set(lazy_value.infer().iterate())
+        return result
+
+    temp_param_add, settings.dynamic_params_for_other_modules = \
+        settings.dynamic_params_for_other_modules, False
+
+    is_list = sequence.name.string_name == 'list'
+    search_names = (['append', 'extend', 'insert'] if is_list else ['add', 'update'])
+
+    added_types = set()
+    for add_name in search_names:
+        try:
+            possible_names = module_context.tree_node.get_used_names()[add_name]
+        except KeyError:
+            continue
+        else:
+            for name in possible_names:
+                value_node = context.tree_node
+                if not (value_node.start_pos < name.start_pos < value_node.end_pos):
+                    continue
+                trailer = name.parent
+                power = trailer.parent
+                trailer_pos = power.children.index(trailer)
+                try:
+                    execution_trailer = power.children[trailer_pos + 1]
+                except IndexError:
+                    continue
+                else:
+                    if execution_trailer.type != 'trailer' \
+                            or execution_trailer.children[0] != '(' \
+                            or execution_trailer.children[1] == ')':
+                        continue
+
+                random_context = context.create_context(name)
+
+                with recursion.execution_allowed(context.inference_state, power) as allowed:
+                    if allowed:
+                        found = infer_call_of_leaf(
+                            random_context,
+                            name,
+                            cut_own_trailer=True
+                        )
+                        if sequence in found:
+                            # The arrays match. Now add the results
+                            added_types |= find_additions(
+                                random_context,
+                                execution_trailer.children[1],
+                                add_name
+                            )
+
+    # reset settings
+    settings.dynamic_params_for_other_modules = temp_param_add
+    debug.dbg('Dynamic array result %s', added_types, color='MAGENTA')
+    return added_types
+
+
+def get_dynamic_array_instance(instance, arguments):
+    """Used for set() and list() instances."""
+    ai = _DynamicArrayAdditions(instance, arguments)
+    from jedi.inference import arguments
+    return arguments.ValuesArguments([ValueSet([ai])])
+
+
+class _DynamicArrayAdditions(HelperValueMixin):
+    """
+    Used for the usage of set() and list().
+    This is definitely a hack, but a good one :-)
+    It makes it possible to use set/list conversions.
+
+    This is not a proper context, because it doesn't have to be. It's not used
+    in the wild, it's just used within typeshed as an argument to `__init__`
+    for set/list and never used in any other place.
+    """
+    def __init__(self, instance, arguments):
+        self._instance = instance
+        self._arguments = arguments
+
+    def py__class__(self):
+        tuple_, = self._instance.inference_state.builtins_module.py__getattribute__('tuple')
+        return tuple_
+
+    def py__iter__(self, contextualized_node=None):
+        arguments = self._arguments
+        try:
+            _, lazy_value = next(arguments.unpack())
+        except StopIteration:
+            pass
+        else:
+            for lazy in lazy_value.infer().iterate():
+                yield lazy
+
+        from jedi.inference.arguments import TreeArguments
+        if isinstance(arguments, TreeArguments):
+            additions = _internal_check_array_additions(arguments.context, self._instance)
+            for addition in additions:
+                yield addition
+
+    def iterate(self, contextualized_node=None, is_async=False):
+        return self.py__iter__(contextualized_node)
+
+
+class _Modification(ValueWrapper):
+    def __init__(self, wrapped_value, assigned_values, contextualized_key):
+        super(_Modification, self).__init__(wrapped_value)
+        self._assigned_values = assigned_values
+        self._contextualized_key = contextualized_key
+
+    def py__getitem__(self, *args, **kwargs):
+        return self._wrapped_value.py__getitem__(*args, **kwargs) | self._assigned_values
+
+    def py__simple_getitem__(self, index):
+        actual = [
+            v.get_safe_value(_sentinel)
+            for v in self._contextualized_key.infer()
+        ]
+        if index in actual:
+            return self._assigned_values
+        return self._wrapped_value.py__simple_getitem__(index)
+
+
+class DictModification(_Modification):
+    def py__iter__(self, contextualized_node=None):
+        for lazy_context in self._wrapped_value.py__iter__(contextualized_node):
+            yield lazy_context
+        yield self._contextualized_key
+
+    def get_key_values(self):
+        return self._wrapped_value.get_key_values() | self._contextualized_key.infer()
+
+
+class ListModification(_Modification):
+    def py__iter__(self, contextualized_node=None):
+        for lazy_context in self._wrapped_value.py__iter__(contextualized_node):
+            yield lazy_context
+        yield LazyKnownValues(self._assigned_values)

venv/Lib/site-packages/jedi/inference/value/function.py

@@ -0,0 +1,470 @@
+from parso.python import tree
+
+from jedi._compatibility import use_metaclass
+from jedi import debug
+from jedi.inference.cache import inference_state_method_cache, CachedMetaClass
+from jedi.inference import compiled
+from jedi.inference import recursion
+from jedi.inference import docstrings
+from jedi.inference import flow_analysis
+from jedi.inference.signature import TreeSignature
+from jedi.inference.filters import ParserTreeFilter, FunctionExecutionFilter, \
+    AnonymousFunctionExecutionFilter
+from jedi.inference.names import ValueName, AbstractNameDefinition, \
+    AnonymousParamName, ParamName, NameWrapper
+from jedi.inference.base_value import ContextualizedNode, NO_VALUES, \
+    ValueSet, TreeValue, ValueWrapper
+from jedi.inference.lazy_value import LazyKnownValues, LazyKnownValue, \
+    LazyTreeValue
+from jedi.inference.context import ValueContext, TreeContextMixin
+from jedi.inference.value import iterable
+from jedi import parser_utils
+from jedi.inference.parser_cache import get_yield_exprs
+from jedi.inference.helpers import values_from_qualified_names
+from jedi.inference.gradual.generics import TupleGenericManager
+
+
+class LambdaName(AbstractNameDefinition):
+    string_name = '<lambda>'
+    api_type = u'function'
+
+    def __init__(self, lambda_value):
+        self._lambda_value = lambda_value
+        self.parent_context = lambda_value.parent_context
+
+    @property
+    def start_pos(self):
+        return self._lambda_value.tree_node.start_pos
+
+    def infer(self):
+        return ValueSet([self._lambda_value])
+
+
+class FunctionAndClassBase(TreeValue):
+    def get_qualified_names(self):
+        if self.parent_context.is_class():
+            n = self.parent_context.get_qualified_names()
+            if n is None:
+                # This means that the parent class lives within a function.
+                return None
+            return n + (self.py__name__(),)
+        elif self.parent_context.is_module():
+            return (self.py__name__(),)
+        else:
+            return None
+
+
+class FunctionMixin(object):
+    api_type = u'function'
+
+    def get_filters(self, origin_scope=None):
+        cls = self.py__class__()
+        for instance in cls.execute_with_values():
+            for filter in instance.get_filters(origin_scope=origin_scope):
+                yield filter
+
+    def py__get__(self, instance, class_value):
+        from jedi.inference.value.instance import BoundMethod
+        if instance is None:
+            # Calling the Foo.bar results in the original bar function.
+            return ValueSet([self])
+        return ValueSet([BoundMethod(instance, class_value.as_context(), self)])
+
+    def get_param_names(self):
+        return [AnonymousParamName(self, param.name)
+                for param in self.tree_node.get_params()]
+
+    @property
+    def name(self):
+        if self.tree_node.type == 'lambdef':
+            return LambdaName(self)
+        return ValueName(self, self.tree_node.name)
+
+    def is_function(self):
+        return True
+
+    def py__name__(self):
+        return self.name.string_name
+
+    def get_type_hint(self, add_class_info=True):
+        return_annotation = self.tree_node.annotation
+        if return_annotation is None:
+            def param_name_to_str(n):
+                s = n.string_name
+                annotation = n.infer().get_type_hint()
+                if annotation is not None:
+                    s += ': ' + annotation
+                if n.default_node is not None:
+                    s += '=' + n.default_node.get_code(include_prefix=False)
+                return s
+
+            function_execution = self.as_context()
+            result = function_execution.infer()
+            return_hint = result.get_type_hint()
+            body = self.py__name__() + '(%s)' % ', '.join([
+                param_name_to_str(n)
+                for n in function_execution.get_param_names()
+            ])
+            if return_hint is None:
+                return body
+        else:
+            return_hint = return_annotation.get_code(include_prefix=False)
+            body = self.py__name__() + self.tree_node.children[2].get_code(include_prefix=False)
+
+        return body + ' -> ' + return_hint
+
+    def py__call__(self, arguments):
+        function_execution = self.as_context(arguments)
+        return function_execution.infer()
+
+    def _as_context(self, arguments=None):
+        if arguments is None:
+            return AnonymousFunctionExecution(self)
+        return FunctionExecutionContext(self, arguments)
+
+    def get_signatures(self):
+        return [TreeSignature(f) for f in self.get_signature_functions()]
+
+
+class FunctionValue(use_metaclass(CachedMetaClass, FunctionMixin, FunctionAndClassBase)):
+    @classmethod
+    def from_context(cls, context, tree_node):
+        def create(tree_node):
+            if context.is_class():
+                return MethodValue(
+                    context.inference_state,
+                    context,
+                    parent_context=parent_context,
+                    tree_node=tree_node
+                )
+            else:
+                return cls(
+                    context.inference_state,
+                    parent_context=parent_context,
+                    tree_node=tree_node
+                )
+
+        overloaded_funcs = list(_find_overload_functions(context, tree_node))
+
+        parent_context = context
+        while parent_context.is_class() or parent_context.is_instance():
+            parent_context = parent_context.parent_context
+
+        function = create(tree_node)
+
+        if overloaded_funcs:
+            return OverloadedFunctionValue(
+                function,
+                # Get them into the correct order: lower line first.
+                list(reversed([create(f) for f in overloaded_funcs]))
+            )
+        return function
+
+    def py__class__(self):
+        c, = values_from_qualified_names(self.inference_state, u'types', u'FunctionType')
+        return c
+
+    def get_default_param_context(self):
+        return self.parent_context
+
+    def get_signature_functions(self):
+        return [self]
+
+
+class FunctionNameInClass(NameWrapper):
+    def __init__(self, class_context, name):
+        super(FunctionNameInClass, self).__init__(name)
+        self._class_context = class_context
+
+    def get_defining_qualified_value(self):
+        return self._class_context.get_value()  # Might be None.
+
+
+class MethodValue(FunctionValue):
+    def __init__(self, inference_state, class_context, *args, **kwargs):
+        super(MethodValue, self).__init__(inference_state, *args, **kwargs)
+        self.class_context = class_context
+
+    def get_default_param_context(self):
+        return self.class_context
+
+    def get_qualified_names(self):
+        # Need to implement this, because the parent value of a method
+        # value is not the class value but the module.
+        names = self.class_context.get_qualified_names()
+        if names is None:
+            return None
+        return names + (self.py__name__(),)
+
+    @property
+    def name(self):
+        return FunctionNameInClass(self.class_context, super(MethodValue, self).name)
+
+
+class BaseFunctionExecutionContext(ValueContext, TreeContextMixin):
+    def infer_annotations(self):
+        raise NotImplementedError
+
+    @inference_state_method_cache(default=NO_VALUES)
+    @recursion.execution_recursion_decorator()
+    def get_return_values(self, check_yields=False):
+        funcdef = self.tree_node
+        if funcdef.type == 'lambdef':
+            return self.infer_node(funcdef.children[-1])
+
+        if check_yields:
+            value_set = NO_VALUES
+            returns = get_yield_exprs(self.inference_state, funcdef)
+        else:
+            value_set = self.infer_annotations()
+            if value_set:
+                # If there are annotations, prefer them over anything else.
+                # This will make it faster.
+                return value_set
+            value_set |= docstrings.infer_return_types(self._value)
+            returns = funcdef.iter_return_stmts()
+
+        for r in returns:
+            if check_yields:
+                value_set |= ValueSet.from_sets(
+                    lazy_value.infer()
+                    for lazy_value in self._get_yield_lazy_value(r)
+                )
+            else:
+                check = flow_analysis.reachability_check(self, funcdef, r)
+                if check is flow_analysis.UNREACHABLE:
+                    debug.dbg('Return unreachable: %s', r)
+                else:
+                    try:
+                        children = r.children
+                    except AttributeError:
+                        ctx = compiled.builtin_from_name(self.inference_state, u'None')
+                        value_set |= ValueSet([ctx])
+                    else:
+                        value_set |= self.infer_node(children[1])
+                if check is flow_analysis.REACHABLE:
+                    debug.dbg('Return reachable: %s', r)
+                    break
+        return value_set
+
+    def _get_yield_lazy_value(self, yield_expr):
+        if yield_expr.type == 'keyword':
+            # `yield` just yields None.
+            ctx = compiled.builtin_from_name(self.inference_state, u'None')
+            yield LazyKnownValue(ctx)
+            return
+
+        node = yield_expr.children[1]
+        if node.type == 'yield_arg':  # It must be a yield from.
+            cn = ContextualizedNode(self, node.children[1])
+            for lazy_value in cn.infer().iterate(cn):
+                yield lazy_value
+        else:
+            yield LazyTreeValue(self, node)
+
+    @recursion.execution_recursion_decorator(default=iter([]))
+    def get_yield_lazy_values(self, is_async=False):
+        # TODO: if is_async, wrap yield statements in Awaitable/async_generator_asend
+        for_parents = [(y, tree.search_ancestor(y, 'for_stmt', 'funcdef',
+                                                'while_stmt', 'if_stmt'))
+                       for y in get_yield_exprs(self.inference_state, self.tree_node)]
+
+        # Calculate if the yields are placed within the same for loop.
+        yields_order = []
+        last_for_stmt = None
+        for yield_, for_stmt in for_parents:
+            # For really simple for loops we can predict the order. Otherwise
+            # we just ignore it.
+            parent = for_stmt.parent
+            if parent.type == 'suite':
+                parent = parent.parent
+            if for_stmt.type == 'for_stmt' and parent == self.tree_node \
+                    and parser_utils.for_stmt_defines_one_name(for_stmt):  # Simplicity for now.
+                if for_stmt == last_for_stmt:
+                    yields_order[-1][1].append(yield_)
+                else:
+                    yields_order.append((for_stmt, [yield_]))
+            elif for_stmt == self.tree_node:
+                yields_order.append((None, [yield_]))
+            else:
+                types = self.get_return_values(check_yields=True)
+                if types:
+                    yield LazyKnownValues(types, min=0, max=float('inf'))
+                return
+            last_for_stmt = for_stmt
+
+        for for_stmt, yields in yields_order:
+            if for_stmt is None:
+                # No for_stmt, just normal yields.
+                for yield_ in yields:
+                    for result in self._get_yield_lazy_value(yield_):
+                        yield result
+            else:
+                input_node = for_stmt.get_testlist()
+                cn = ContextualizedNode(self, input_node)
+                ordered = cn.infer().iterate(cn)
+                ordered = list(ordered)
+                for lazy_value in ordered:
+                    dct = {str(for_stmt.children[1].value): lazy_value.infer()}
+                    with self.predefine_names(for_stmt, dct):
+                        for yield_in_same_for_stmt in yields:
+                            for result in self._get_yield_lazy_value(yield_in_same_for_stmt):
+                                yield result
+
+    def merge_yield_values(self, is_async=False):
+        return ValueSet.from_sets(
+            lazy_value.infer()
+            for lazy_value in self.get_yield_lazy_values()
+        )
+
+    def is_generator(self):
+        return bool(get_yield_exprs(self.inference_state, self.tree_node))
+
+    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():
+                if inference_state.environment.version_info < (3, 6):
+                    return NO_VALUES
+                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(
+                    # In Python 3.6 AsyncGenerator is still a class.
+                    GenericClass(c, TupleGenericManager(generics))
+                    for c in async_generator_classes
+                ).execute_annotation()
+            else:
+                if inference_state.environment.version_info < (3, 5):
+                    return NO_VALUES
+                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()
+
+
+class FunctionExecutionContext(BaseFunctionExecutionContext):
+    def __init__(self, function_value, arguments):
+        super(FunctionExecutionContext, self).__init__(function_value)
+        self._arguments = arguments
+
+    def get_filters(self, until_position=None, origin_scope=None):
+        yield FunctionExecutionFilter(
+            self, self._value,
+            until_position=until_position,
+            origin_scope=origin_scope,
+            arguments=self._arguments
+        )
+
+    def infer_annotations(self):
+        from jedi.inference.gradual.annotation import infer_return_types
+        return infer_return_types(self._value, self._arguments)
+
+    def get_param_names(self):
+        return [
+            ParamName(self._value, param.name, self._arguments)
+            for param in self._value.tree_node.get_params()
+        ]
+
+
+class AnonymousFunctionExecution(BaseFunctionExecutionContext):
+    def infer_annotations(self):
+        # I don't think inferring anonymous executions is a big thing.
+        # Anonymous contexts are mostly there for the user to work in. ~ dave
+        return NO_VALUES
+
+    def get_filters(self, until_position=None, origin_scope=None):
+        yield AnonymousFunctionExecutionFilter(
+            self, self._value,
+            until_position=until_position,
+            origin_scope=origin_scope,
+        )
+
+    def get_param_names(self):
+        return self._value.get_param_names()
+
+
+class OverloadedFunctionValue(FunctionMixin, ValueWrapper):
+    def __init__(self, function, overloaded_functions):
+        super(OverloadedFunctionValue, self).__init__(function)
+        self._overloaded_functions = overloaded_functions
+
+    def py__call__(self, arguments):
+        debug.dbg("Execute overloaded function %s", self._wrapped_value, color='BLUE')
+        function_executions = []
+        for signature in self.get_signatures():
+            function_execution = signature.value.as_context(arguments)
+            function_executions.append(function_execution)
+            if signature.matches_signature(arguments):
+                return function_execution.infer()
+
+        if self.inference_state.is_analysis:
+            # In this case we want precision.
+            return NO_VALUES
+        return ValueSet.from_sets(fe.infer() for fe in function_executions)
+
+    def get_signature_functions(self):
+        return self._overloaded_functions
+
+    def get_type_hint(self, add_class_info=True):
+        return 'Union[%s]' % ', '.join(f.get_type_hint() for f in self._overloaded_functions)
+
+
+def _find_overload_functions(context, tree_node):
+    def _is_overload_decorated(funcdef):
+        if funcdef.parent.type == 'decorated':
+            decorators = funcdef.parent.children[0]
+            if decorators.type == 'decorator':
+                decorators = [decorators]
+            else:
+                decorators = decorators.children
+            for decorator in decorators:
+                dotted_name = decorator.children[1]
+                if dotted_name.type == 'name' and dotted_name.value == 'overload':
+                    # TODO check with values if it's the right overload
+                    return True
+        return False
+
+    if tree_node.type == 'lambdef':
+        return
+
+    if _is_overload_decorated(tree_node):
+        yield tree_node
+
+    while True:
+        filter = ParserTreeFilter(
+            context,
+            until_position=tree_node.start_pos
+        )
+        names = filter.get(tree_node.name.value)
+        assert isinstance(names, list)
+        if not names:
+            break
+
+        found = False
+        for name in names:
+            funcdef = name.tree_name.parent
+            if funcdef.type == 'funcdef' and _is_overload_decorated(funcdef):
+                tree_node = funcdef
+                found = True
+                yield funcdef
+
+        if not found:
+            break

venv/Lib/site-packages/jedi/inference/value/instance.py

@@ -0,0 +1,625 @@
+from abc import abstractproperty
+
+from parso.python.tree import search_ancestor
+
+from jedi import debug
+from jedi import settings
+from jedi.inference import compiled
+from jedi.inference.compiled.value import CompiledValueFilter
+from jedi.inference.helpers import values_from_qualified_names, is_big_annoying_library
+from jedi.inference.filters import AbstractFilter, AnonymousFunctionExecutionFilter
+from jedi.inference.names import ValueName, TreeNameDefinition, ParamName, \
+    NameWrapper
+from jedi.inference.base_value import Value, NO_VALUES, ValueSet, \
+    iterator_to_value_set, ValueWrapper
+from jedi.inference.lazy_value import LazyKnownValue, LazyKnownValues
+from jedi.inference.cache import inference_state_method_cache
+from jedi.inference.arguments import ValuesArguments, TreeArgumentsWrapper
+from jedi.inference.value.function import \
+    FunctionValue, FunctionMixin, OverloadedFunctionValue, \
+    BaseFunctionExecutionContext, FunctionExecutionContext, FunctionNameInClass
+from jedi.inference.value.klass import ClassFilter
+from jedi.inference.value.dynamic_arrays import get_dynamic_array_instance
+from jedi.parser_utils import function_is_staticmethod, function_is_classmethod
+
+
+class InstanceExecutedParamName(ParamName):
+    def __init__(self, instance, function_value, tree_name):
+        super(InstanceExecutedParamName, self).__init__(
+            function_value, tree_name, arguments=None)
+        self._instance = instance
+
+    def infer(self):
+        return ValueSet([self._instance])
+
+    def matches_signature(self):
+        return True
+
+
+class AnonymousMethodExecutionFilter(AnonymousFunctionExecutionFilter):
+    def __init__(self, instance, *args, **kwargs):
+        super(AnonymousMethodExecutionFilter, self).__init__(*args, **kwargs)
+        self._instance = instance
+
+    def _convert_param(self, param, name):
+        if param.position_index == 0:
+            if function_is_classmethod(self._function_value.tree_node):
+                return InstanceExecutedParamName(
+                    self._instance.py__class__(),
+                    self._function_value,
+                    name
+                )
+            elif not function_is_staticmethod(self._function_value.tree_node):
+                return InstanceExecutedParamName(
+                    self._instance,
+                    self._function_value,
+                    name
+                )
+        return super(AnonymousMethodExecutionFilter, self)._convert_param(param, name)
+
+
+class AnonymousMethodExecutionContext(BaseFunctionExecutionContext):
+    def __init__(self, instance, value):
+        super(AnonymousMethodExecutionContext, self).__init__(value)
+        self.instance = instance
+
+    def get_filters(self, until_position=None, origin_scope=None):
+        yield AnonymousMethodExecutionFilter(
+            self.instance, self, self._value,
+            until_position=until_position,
+            origin_scope=origin_scope,
+        )
+
+    def get_param_names(self):
+        param_names = list(self._value.get_param_names())
+        # set the self name
+        param_names[0] = InstanceExecutedParamName(
+            self.instance,
+            self._value,
+            param_names[0].tree_name
+        )
+        return param_names
+
+
+class MethodExecutionContext(FunctionExecutionContext):
+    def __init__(self, instance, *args, **kwargs):
+        super(MethodExecutionContext, self).__init__(*args, **kwargs)
+        self.instance = instance
+
+
+class AbstractInstanceValue(Value):
+    api_type = u'instance'
+
+    def __init__(self, inference_state, parent_context, class_value):
+        super(AbstractInstanceValue, self).__init__(inference_state, parent_context)
+        # Generated instances are classes that are just generated by self
+        # (No arguments) used.
+        self.class_value = class_value
+
+    def is_instance(self):
+        return True
+
+    def get_qualified_names(self):
+        return self.class_value.get_qualified_names()
+
+    def get_annotated_class_object(self):
+        return self.class_value  # This is the default.
+
+    def py__class__(self):
+        return self.class_value
+
+    def py__bool__(self):
+        # Signalize that we don't know about the bool type.
+        return None
+
+    @abstractproperty
+    def name(self):
+        raise NotImplementedError
+
+    def get_signatures(self):
+        call_funcs = self.py__getattribute__('__call__').py__get__(self, self.class_value)
+        return [s.bind(self) for s in call_funcs.get_signatures()]
+
+    def get_function_slot_names(self, name):
+        # Searches for Python functions in classes.
+        return []
+
+    def execute_function_slots(self, names, *inferred_args):
+        return ValueSet.from_sets(
+            name.infer().execute_with_values(*inferred_args)
+            for name in names
+        )
+
+    def get_type_hint(self, add_class_info=True):
+        return self.py__name__()
+
+    def __repr__(self):
+        return "<%s of %s>" % (self.__class__.__name__, self.class_value)
+
+
+class CompiledInstance(AbstractInstanceValue):
+    # This is not really a compiled class, it's just an instance from a
+    # compiled class.
+    def __init__(self, inference_state, parent_context, class_value, arguments):
+        super(CompiledInstance, self).__init__(inference_state, parent_context,
+                                               class_value)
+        self._arguments = arguments
+
+    def get_filters(self, origin_scope=None, include_self_names=True):
+        class_value = self.get_annotated_class_object()
+        class_filters = class_value.get_filters(
+            origin_scope=origin_scope,
+            is_instance=True,
+        )
+        for f in class_filters:
+            yield CompiledInstanceClassFilter(self, f)
+
+    @property
+    def name(self):
+        return compiled.CompiledValueName(self, self.class_value.name.string_name)
+
+    def is_stub(self):
+        return False
+
+
+class _BaseTreeInstance(AbstractInstanceValue):
+    @property
+    def array_type(self):
+        name = self.class_value.py__name__()
+        if name in ['list', 'set', 'dict'] \
+                and self.parent_context.get_root_context().is_builtins_module():
+            return name
+        return None
+
+    @property
+    def name(self):
+        return ValueName(self, self.class_value.name.tree_name)
+
+    def get_filters(self, origin_scope=None, include_self_names=True):
+        class_value = self.get_annotated_class_object()
+        if include_self_names:
+            for cls in class_value.py__mro__():
+                if not cls.is_compiled():
+                    # In this case we're excluding compiled objects that are
+                    # not fake objects. It doesn't make sense for normal
+                    # compiled objects to search for self variables.
+                    yield SelfAttributeFilter(self, class_value, cls.as_context(), origin_scope)
+
+        class_filters = class_value.get_filters(
+            origin_scope=origin_scope,
+            is_instance=True,
+        )
+        for f in class_filters:
+            if isinstance(f, ClassFilter):
+                yield InstanceClassFilter(self, f)
+            elif isinstance(f, CompiledValueFilter):
+                yield CompiledInstanceClassFilter(self, f)
+            else:
+                # Propably from the metaclass.
+                yield f
+
+    @inference_state_method_cache()
+    def create_instance_context(self, class_context, node):
+        new = node
+        while True:
+            func_node = new
+            new = search_ancestor(new, 'funcdef', 'classdef')
+            if class_context.tree_node is new:
+                func = FunctionValue.from_context(class_context, func_node)
+                bound_method = BoundMethod(self, class_context, func)
+                if func_node.name.value == '__init__':
+                    context = bound_method.as_context(self._arguments)
+                else:
+                    context = bound_method.as_context()
+                break
+        return context.create_context(node)
+
+    def py__getattribute__alternatives(self, string_name):
+        '''
+        Since nothing was inferred, now check the __getattr__ and
+        __getattribute__ methods. Stubs don't need to be checked, because
+        they don't contain any logic.
+        '''
+        if self.is_stub():
+            return NO_VALUES
+
+        name = compiled.create_simple_object(self.inference_state, string_name)
+
+        # This is a little bit special. `__getattribute__` is in Python
+        # executed before `__getattr__`. But: I know no use case, where
+        # this could be practical and where Jedi would return wrong types.
+        # If you ever find something, let me know!
+        # We are inversing this, because a hand-crafted `__getattribute__`
+        # could still call another hand-crafted `__getattr__`, but not the
+        # other way around.
+        if is_big_annoying_library(self.parent_context):
+            return NO_VALUES
+        names = (self.get_function_slot_names(u'__getattr__')
+                 or self.get_function_slot_names(u'__getattribute__'))
+        return self.execute_function_slots(names, name)
+
+    def py__getitem__(self, index_value_set, contextualized_node):
+        names = self.get_function_slot_names(u'__getitem__')
+        if not names:
+            return super(_BaseTreeInstance, self).py__getitem__(
+                index_value_set,
+                contextualized_node,
+            )
+
+        args = ValuesArguments([index_value_set])
+        return ValueSet.from_sets(name.infer().execute(args) for name in names)
+
+    def py__iter__(self, contextualized_node=None):
+        iter_slot_names = self.get_function_slot_names(u'__iter__')
+        if not iter_slot_names:
+            return super(_BaseTreeInstance, self).py__iter__(contextualized_node)
+
+        def iterate():
+            for generator in self.execute_function_slots(iter_slot_names):
+                for lazy_value in generator.py__next__(contextualized_node):
+                    yield lazy_value
+        return iterate()
+
+    def py__next__(self, contextualized_node=None):
+        # `__next__` logic.
+        if self.inference_state.environment.version_info.major == 2:
+            name = u'next'
+        else:
+            name = u'__next__'
+        next_slot_names = self.get_function_slot_names(name)
+        if next_slot_names:
+            yield LazyKnownValues(
+                self.execute_function_slots(next_slot_names)
+            )
+        else:
+            debug.warning('Instance has no __next__ function in %s.', self)
+
+    def py__call__(self, arguments):
+        names = self.get_function_slot_names(u'__call__')
+        if not names:
+            # Means the Instance is not callable.
+            return super(_BaseTreeInstance, self).py__call__(arguments)
+
+        return ValueSet.from_sets(name.infer().execute(arguments) for name in names)
+
+    def py__get__(self, instance, class_value):
+        """
+        obj may be None.
+        """
+        # Arguments in __get__ descriptors are obj, class.
+        # `method` is the new parent of the array, don't know if that's good.
+        for cls in self.class_value.py__mro__():
+            result = cls.py__get__on_class(self, instance, class_value)
+            if result is not NotImplemented:
+                return result
+
+        names = self.get_function_slot_names(u'__get__')
+        if names:
+            if instance is None:
+                instance = compiled.builtin_from_name(self.inference_state, u'None')
+            return self.execute_function_slots(names, instance, class_value)
+        else:
+            return ValueSet([self])
+
+    def get_function_slot_names(self, name):
+        # Python classes don't look at the dictionary of the instance when
+        # looking up `__call__`. This is something that has to do with Python's
+        # internal slot system (note: not __slots__, but C slots).
+        for filter in self.get_filters(include_self_names=False):
+            names = filter.get(name)
+            if names:
+                return names
+        return []
+
+
+class TreeInstance(_BaseTreeInstance):
+    def __init__(self, inference_state, parent_context, class_value, arguments):
+        # I don't think that dynamic append lookups should happen here. That
+        # sounds more like something that should go to py__iter__.
+        if class_value.py__name__() in ['list', 'set'] \
+                and parent_context.get_root_context().is_builtins_module():
+            # compare the module path with the builtin name.
+            if settings.dynamic_array_additions:
+                arguments = get_dynamic_array_instance(self, arguments)
+
+        super(TreeInstance, self).__init__(inference_state, parent_context, class_value)
+        self._arguments = arguments
+        self.tree_node = class_value.tree_node
+
+    # This can recurse, if the initialization of the class includes a reference
+    # to itself.
+    @inference_state_method_cache(default=None)
+    def _get_annotated_class_object(self):
+        from jedi.inference.gradual.annotation import py__annotations__, \
+            infer_type_vars_for_execution
+
+        args = InstanceArguments(self, self._arguments)
+        for signature in self.class_value.py__getattribute__('__init__').get_signatures():
+            # Just take the first result, it should always be one, because we
+            # control the typeshed code.
+            funcdef = signature.value.tree_node
+            if funcdef is None or funcdef.type != 'funcdef' \
+                    or not signature.matches_signature(args):
+                # First check if the signature even matches, if not we don't
+                # need to infer anything.
+                continue
+            bound_method = BoundMethod(self, self.class_value.as_context(), signature.value)
+            all_annotations = py__annotations__(funcdef)
+            type_var_dict = infer_type_vars_for_execution(bound_method, args, all_annotations)
+            if type_var_dict:
+                defined, = self.class_value.define_generics(
+                    infer_type_vars_for_execution(signature.value, args, all_annotations),
+                )
+                debug.dbg('Inferred instance value as %s', defined, color='BLUE')
+                return defined
+        return None
+
+    def get_annotated_class_object(self):
+        return self._get_annotated_class_object() or self.class_value
+
+    def get_key_values(self):
+        values = NO_VALUES
+        if self.array_type == 'dict':
+            for i, (key, instance) in enumerate(self._arguments.unpack()):
+                if key is None and i == 0:
+                    values |= ValueSet.from_sets(
+                        v.get_key_values()
+                        for v in instance.infer()
+                        if v.array_type == 'dict'
+                    )
+                if key:
+                    values |= ValueSet([compiled.create_simple_object(
+                        self.inference_state,
+                        key,
+                    )])
+
+        return values
+
+    def py__simple_getitem__(self, index):
+        if self.array_type == 'dict':
+            # Logic for dict({'foo': bar}) and dict(foo=bar)
+            # reversed, because:
+            # >>> dict({'a': 1}, a=3)
+            # {'a': 3}
+            # TODO tuple initializations
+            # >>> dict([('a', 4)])
+            # {'a': 4}
+            for key, lazy_context in reversed(list(self._arguments.unpack())):
+                if key is None:
+                    values = ValueSet.from_sets(
+                        dct_value.py__simple_getitem__(index)
+                        for dct_value in lazy_context.infer()
+                        if dct_value.array_type == 'dict'
+                    )
+                    if values:
+                        return values
+                else:
+                    if key == index:
+                        return lazy_context.infer()
+        return super(TreeInstance, self).py__simple_getitem__(index)
+
+    def __repr__(self):
+        return "<%s of %s(%s)>" % (self.__class__.__name__, self.class_value,
+                                   self._arguments)
+
+
+class AnonymousInstance(_BaseTreeInstance):
+    _arguments = None
+
+
+class CompiledInstanceName(compiled.CompiledName):
+    def __init__(self, inference_state, instance, klass, name):
+        parent_value = klass.parent_context.get_value()
+        assert parent_value is not None, "How? Please reproduce and report"
+        super(CompiledInstanceName, self).__init__(
+            inference_state,
+            parent_value,
+            name.string_name
+        )
+        self._instance = instance
+        self._class_member_name = name
+
+    @iterator_to_value_set
+    def infer(self):
+        for result_value in self._class_member_name.infer():
+            if result_value.api_type == 'function':
+                yield CompiledBoundMethod(result_value)
+            else:
+                yield result_value
+
+
+class CompiledInstanceClassFilter(AbstractFilter):
+    def __init__(self, instance, f):
+        self._instance = instance
+        self._class_filter = f
+
+    def get(self, name):
+        return self._convert(self._class_filter.get(name))
+
+    def values(self):
+        return self._convert(self._class_filter.values())
+
+    def _convert(self, names):
+        klass = self._class_filter.compiled_value
+        return [
+            CompiledInstanceName(self._instance.inference_state, self._instance, klass, n)
+            for n in names
+        ]
+
+
+class BoundMethod(FunctionMixin, ValueWrapper):
+    def __init__(self, instance, class_context, function):
+        super(BoundMethod, self).__init__(function)
+        self.instance = instance
+        self._class_context = class_context
+
+    def is_bound_method(self):
+        return True
+
+    @property
+    def name(self):
+        return FunctionNameInClass(
+            self._class_context,
+            super(BoundMethod, self).name
+        )
+
+    def py__class__(self):
+        c, = values_from_qualified_names(self.inference_state, u'types', u'MethodType')
+        return c
+
+    def _get_arguments(self, arguments):
+        assert arguments is not None
+        return InstanceArguments(self.instance, arguments)
+
+    def _as_context(self, arguments=None):
+        if arguments is None:
+            return AnonymousMethodExecutionContext(self.instance, self)
+
+        arguments = self._get_arguments(arguments)
+        return MethodExecutionContext(self.instance, self, arguments)
+
+    def py__call__(self, arguments):
+        if isinstance(self._wrapped_value, OverloadedFunctionValue):
+            return self._wrapped_value.py__call__(self._get_arguments(arguments))
+
+        function_execution = self.as_context(arguments)
+        return function_execution.infer()
+
+    def get_signature_functions(self):
+        return [
+            BoundMethod(self.instance, self._class_context, f)
+            for f in self._wrapped_value.get_signature_functions()
+        ]
+
+    def get_signatures(self):
+        return [sig.bind(self) for sig in super(BoundMethod, self).get_signatures()]
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self._wrapped_value)
+
+
+class CompiledBoundMethod(ValueWrapper):
+    def is_bound_method(self):
+        return True
+
+    def get_signatures(self):
+        return [sig.bind(self) for sig in self._wrapped_value.get_signatures()]
+
+
+class SelfName(TreeNameDefinition):
+    """
+    This name calculates the parent_context lazily.
+    """
+    def __init__(self, instance, class_context, tree_name):
+        self._instance = instance
+        self.class_context = class_context
+        self.tree_name = tree_name
+
+    @property
+    def parent_context(self):
+        return self._instance.create_instance_context(self.class_context, self.tree_name)
+
+    def get_defining_qualified_value(self):
+        return self._instance
+
+
+class LazyInstanceClassName(NameWrapper):
+    def __init__(self, instance, class_member_name):
+        super(LazyInstanceClassName, self).__init__(class_member_name)
+        self._instance = instance
+
+    @iterator_to_value_set
+    def infer(self):
+        for result_value in self._wrapped_name.infer():
+            for c in result_value.py__get__(self._instance, self._instance.py__class__()):
+                yield c
+
+    def get_signatures(self):
+        return self.infer().get_signatures()
+
+    def get_defining_qualified_value(self):
+        return self._instance
+
+
+class InstanceClassFilter(AbstractFilter):
+    """
+    This filter is special in that it uses the class filter and wraps the
+    resulting names in LazyInstanceClassName. The idea is that the class name
+    filtering can be very flexible and always be reflected in instances.
+    """
+    def __init__(self, instance, class_filter):
+        self._instance = instance
+        self._class_filter = class_filter
+
+    def get(self, name):
+        return self._convert(self._class_filter.get(name))
+
+    def values(self):
+        return self._convert(self._class_filter.values())
+
+    def _convert(self, names):
+        return [
+            LazyInstanceClassName(self._instance, n)
+            for n in names
+        ]
+
+    def __repr__(self):
+        return '<%s for %s>' % (self.__class__.__name__, self._class_filter)
+
+
+class SelfAttributeFilter(ClassFilter):
+    """
+    This class basically filters all the use cases where `self.*` was assigned.
+    """
+    def __init__(self, instance, instance_class, node_context, origin_scope):
+        super(SelfAttributeFilter, self).__init__(
+            class_value=instance_class,
+            node_context=node_context,
+            origin_scope=origin_scope,
+            is_instance=True,
+        )
+        self._instance = instance
+
+    def _filter(self, names):
+        start, end = self._parser_scope.start_pos, self._parser_scope.end_pos
+        names = [n for n in names if start < n.start_pos < end]
+        return self._filter_self_names(names)
+
+    def _filter_self_names(self, names):
+        for name in names:
+            trailer = name.parent
+            if trailer.type == 'trailer' \
+                    and len(trailer.parent.children) == 2 \
+                    and trailer.children[0] == '.':
+                if name.is_definition() and self._access_possible(name):
+                    # TODO filter non-self assignments instead of this bad
+                    #      filter.
+                    if self._is_in_right_scope(trailer.parent.children[0], name):
+                        yield name
+
+    def _is_in_right_scope(self, self_name, name):
+        self_context = self._node_context.create_context(self_name)
+        names = self_context.goto(self_name, position=self_name.start_pos)
+        return any(
+            n.api_type == 'param'
+            and n.tree_name.get_definition().position_index == 0
+            and n.parent_context.tree_node is self._parser_scope
+            for n in names
+        )
+
+    def _convert_names(self, names):
+        return [SelfName(self._instance, self._node_context, name) for name in names]
+
+    def _check_flows(self, names):
+        return names
+
+
+class InstanceArguments(TreeArgumentsWrapper):
+    def __init__(self, instance, arguments):
+        super(InstanceArguments, self).__init__(arguments)
+        self.instance = instance
+
+    def unpack(self, func=None):
+        yield None, LazyKnownValue(self.instance)
+        for values in self._wrapped_arguments.unpack(func):
+            yield values

venv/Lib/site-packages/jedi/inference/value/iterable.py

@@ -0,0 +1,673 @@
+"""
+Contains all classes and functions to deal with lists, dicts, generators and
+iterators in general.
+"""
+import sys
+
+from jedi._compatibility import force_unicode, is_py3
+from jedi.inference import compiled
+from jedi.inference import analysis
+from jedi.inference.lazy_value import LazyKnownValue, LazyKnownValues, \
+    LazyTreeValue
+from jedi.inference.helpers import get_int_or_none, is_string, \
+    reraise_getitem_errors, SimpleGetItemNotFound
+from jedi.inference.utils import safe_property, to_list
+from jedi.inference.cache import inference_state_method_cache
+from jedi.inference.filters import LazyAttributeOverwrite, publish_method
+from jedi.inference.base_value import ValueSet, Value, NO_VALUES, \
+    ContextualizedNode, iterate_values, sentinel, \
+    LazyValueWrapper
+from jedi.parser_utils import get_sync_comp_fors
+from jedi.inference.context import CompForContext
+from jedi.inference.value.dynamic_arrays import check_array_additions
+
+
+class IterableMixin(object):
+    def py__next__(self, contextualized_node=None):
+        return self.py__iter__(contextualized_node)
+
+    def py__stop_iteration_returns(self):
+        return ValueSet([compiled.builtin_from_name(self.inference_state, u'None')])
+
+    # At the moment, safe values are simple values like "foo", 1 and not
+    # lists/dicts. Therefore as a small speed optimization we can just do the
+    # default instead of resolving the lazy wrapped values, that are just
+    # doing this in the end as well.
+    # This mostly speeds up patterns like `sys.version_info >= (3, 0)` in
+    # typeshed.
+    if sys.version_info[0] == 2:
+        # Python 2...........
+        def get_safe_value(self, default=sentinel):
+            if default is sentinel:
+                raise ValueError("There exists no safe value for value %s" % self)
+            return default
+    else:
+        get_safe_value = Value.get_safe_value
+
+
+class GeneratorBase(LazyAttributeOverwrite, IterableMixin):
+    array_type = None
+
+    def _get_wrapped_value(self):
+        instance, = self._get_cls().execute_annotation()
+        return instance
+
+    def _get_cls(self):
+        generator, = self.inference_state.typing_module.py__getattribute__('Generator')
+        return generator
+
+    def py__bool__(self):
+        return True
+
+    @publish_method('__iter__')
+    def _iter(self, arguments):
+        return ValueSet([self])
+
+    @publish_method('send')
+    @publish_method('next', python_version_match=2)
+    @publish_method('__next__', python_version_match=3)
+    def _next(self, arguments):
+        return ValueSet.from_sets(lazy_value.infer() for lazy_value in self.py__iter__())
+
+    def py__stop_iteration_returns(self):
+        return ValueSet([compiled.builtin_from_name(self.inference_state, u'None')])
+
+    @property
+    def name(self):
+        return compiled.CompiledValueName(self, 'Generator')
+
+    def get_annotated_class_object(self):
+        from jedi.inference.gradual.generics import TupleGenericManager
+        gen_values = self.merge_types_of_iterate().py__class__()
+        gm = TupleGenericManager((gen_values, NO_VALUES, NO_VALUES))
+        return self._get_cls().with_generics(gm)
+
+
+class Generator(GeneratorBase):
+    """Handling of `yield` functions."""
+    def __init__(self, inference_state, func_execution_context):
+        super(Generator, self).__init__(inference_state)
+        self._func_execution_context = func_execution_context
+
+    def py__iter__(self, contextualized_node=None):
+        iterators = self._func_execution_context.infer_annotations()
+        if iterators:
+            return iterators.iterate(contextualized_node)
+        return self._func_execution_context.get_yield_lazy_values()
+
+    def py__stop_iteration_returns(self):
+        return self._func_execution_context.get_return_values()
+
+    def __repr__(self):
+        return "<%s of %s>" % (type(self).__name__, self._func_execution_context)
+
+
+def comprehension_from_atom(inference_state, value, atom):
+    bracket = atom.children[0]
+    test_list_comp = atom.children[1]
+
+    if bracket == '{':
+        if atom.children[1].children[1] == ':':
+            sync_comp_for = test_list_comp.children[3]
+            if sync_comp_for.type == 'comp_for':
+                sync_comp_for = sync_comp_for.children[1]
+
+            return DictComprehension(
+                inference_state,
+                value,
+                sync_comp_for_node=sync_comp_for,
+                key_node=test_list_comp.children[0],
+                value_node=test_list_comp.children[2],
+            )
+        else:
+            cls = SetComprehension
+    elif bracket == '(':
+        cls = GeneratorComprehension
+    elif bracket == '[':
+        cls = ListComprehension
+
+    sync_comp_for = test_list_comp.children[1]
+    if sync_comp_for.type == 'comp_for':
+        sync_comp_for = sync_comp_for.children[1]
+
+    return cls(
+        inference_state,
+        defining_context=value,
+        sync_comp_for_node=sync_comp_for,
+        entry_node=test_list_comp.children[0],
+    )
+
+
+class ComprehensionMixin(object):
+    @inference_state_method_cache()
+    def _get_comp_for_context(self, parent_context, comp_for):
+        return CompForContext(parent_context, comp_for)
+
+    def _nested(self, comp_fors, parent_context=None):
+        comp_for = comp_fors[0]
+
+        is_async = comp_for.parent.type == 'comp_for'
+
+        input_node = comp_for.children[3]
+        parent_context = parent_context or self._defining_context
+        input_types = parent_context.infer_node(input_node)
+
+        cn = ContextualizedNode(parent_context, input_node)
+        iterated = input_types.iterate(cn, is_async=is_async)
+        exprlist = comp_for.children[1]
+        for i, lazy_value in enumerate(iterated):
+            types = lazy_value.infer()
+            dct = unpack_tuple_to_dict(parent_context, types, exprlist)
+            context = self._get_comp_for_context(
+                parent_context,
+                comp_for,
+            )
+            with context.predefine_names(comp_for, dct):
+                try:
+                    for result in self._nested(comp_fors[1:], context):
+                        yield result
+                except IndexError:
+                    iterated = context.infer_node(self._entry_node)
+                    if self.array_type == 'dict':
+                        yield iterated, context.infer_node(self._value_node)
+                    else:
+                        yield iterated
+
+    @inference_state_method_cache(default=[])
+    @to_list
+    def _iterate(self):
+        comp_fors = tuple(get_sync_comp_fors(self._sync_comp_for_node))
+        for result in self._nested(comp_fors):
+            yield result
+
+    def py__iter__(self, contextualized_node=None):
+        for set_ in self._iterate():
+            yield LazyKnownValues(set_)
+
+    def __repr__(self):
+        return "<%s of %s>" % (type(self).__name__, self._sync_comp_for_node)
+
+
+class _DictMixin(object):
+    def _get_generics(self):
+        return tuple(c_set.py__class__() for c_set in self.get_mapping_item_values())
+
+
+class Sequence(LazyAttributeOverwrite, IterableMixin):
+    api_type = u'instance'
+
+    @property
+    def name(self):
+        return compiled.CompiledValueName(self, self.array_type)
+
+    def _get_generics(self):
+        return (self.merge_types_of_iterate().py__class__(),)
+
+    @inference_state_method_cache(default=())
+    def _cached_generics(self):
+        return self._get_generics()
+
+    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 py__bool__(self):
+        return None  # We don't know the length, because of appends.
+
+    @safe_property
+    def parent(self):
+        return self.inference_state.builtins_module
+
+    def py__getitem__(self, index_value_set, contextualized_node):
+        if self.array_type == 'dict':
+            return self._dict_values()
+        return iterate_values(ValueSet([self]))
+
+
+class _BaseComprehension(ComprehensionMixin):
+    def __init__(self, inference_state, defining_context, sync_comp_for_node, entry_node):
+        assert sync_comp_for_node.type == 'sync_comp_for'
+        super(_BaseComprehension, self).__init__(inference_state)
+        self._defining_context = defining_context
+        self._sync_comp_for_node = sync_comp_for_node
+        self._entry_node = entry_node
+
+
+class ListComprehension(_BaseComprehension, Sequence):
+    array_type = u'list'
+
+    def py__simple_getitem__(self, index):
+        if isinstance(index, slice):
+            return ValueSet([self])
+
+        all_types = list(self.py__iter__())
+        with reraise_getitem_errors(IndexError, TypeError):
+            lazy_value = all_types[index]
+        return lazy_value.infer()
+
+
+class SetComprehension(_BaseComprehension, Sequence):
+    array_type = u'set'
+
+
+class GeneratorComprehension(_BaseComprehension, GeneratorBase):
+    pass
+
+
+class _DictKeyMixin(object):
+    # TODO merge with _DictMixin?
+    def get_mapping_item_values(self):
+        return self._dict_keys(), self._dict_values()
+
+    def get_key_values(self):
+        # TODO merge with _dict_keys?
+        return self._dict_keys()
+
+
+class DictComprehension(ComprehensionMixin, Sequence, _DictKeyMixin):
+    array_type = u'dict'
+
+    def __init__(self, inference_state, defining_context, sync_comp_for_node, key_node, value_node):
+        assert sync_comp_for_node.type == 'sync_comp_for'
+        super(DictComprehension, self).__init__(inference_state)
+        self._defining_context = defining_context
+        self._sync_comp_for_node = sync_comp_for_node
+        self._entry_node = key_node
+        self._value_node = value_node
+
+    def py__iter__(self, contextualized_node=None):
+        for keys, values in self._iterate():
+            yield LazyKnownValues(keys)
+
+    def py__simple_getitem__(self, index):
+        for keys, values in self._iterate():
+            for k in keys:
+                # Be careful in the future if refactoring, index could be a
+                # slice object.
+                if k.get_safe_value(default=object()) == index:
+                    return values
+        raise SimpleGetItemNotFound()
+
+    def _dict_keys(self):
+        return ValueSet.from_sets(keys for keys, values in self._iterate())
+
+    def _dict_values(self):
+        return ValueSet.from_sets(values for keys, values in self._iterate())
+
+    @publish_method('values')
+    def _imitate_values(self, arguments):
+        lazy_value = LazyKnownValues(self._dict_values())
+        return ValueSet([FakeList(self.inference_state, [lazy_value])])
+
+    @publish_method('items')
+    def _imitate_items(self, arguments):
+        lazy_values = [
+            LazyKnownValue(
+                FakeTuple(
+                    self.inference_state,
+                    [LazyKnownValues(key),
+                     LazyKnownValues(value)]
+                )
+            )
+            for key, value in self._iterate()
+        ]
+
+        return ValueSet([FakeList(self.inference_state, lazy_values)])
+
+    def exact_key_items(self):
+        # NOTE: A smarter thing can probably done here to achieve better
+        # completions, but at least like this jedi doesn't crash
+        return []
+
+
+class SequenceLiteralValue(Sequence):
+    _TUPLE_LIKE = 'testlist_star_expr', 'testlist', 'subscriptlist'
+    mapping = {'(': u'tuple',
+               '[': u'list',
+               '{': u'set'}
+
+    def __init__(self, inference_state, defining_context, atom):
+        super(SequenceLiteralValue, self).__init__(inference_state)
+        self.atom = atom
+        self._defining_context = defining_context
+
+        if self.atom.type in self._TUPLE_LIKE:
+            self.array_type = u'tuple'
+        else:
+            self.array_type = SequenceLiteralValue.mapping[atom.children[0]]
+            """The builtin name of the array (list, set, tuple or dict)."""
+
+    def _get_generics(self):
+        if self.array_type == u'tuple':
+            return tuple(x.infer().py__class__() for x in self.py__iter__())
+        return super(SequenceLiteralValue, self)._get_generics()
+
+    def py__simple_getitem__(self, index):
+        """Here the index is an int/str. Raises IndexError/KeyError."""
+        if isinstance(index, slice):
+            return ValueSet([self])
+        else:
+            with reraise_getitem_errors(TypeError, KeyError, IndexError):
+                node = self.get_tree_entries()[index]
+            return self._defining_context.infer_node(node)
+
+    def py__iter__(self, contextualized_node=None):
+        """
+        While values returns the possible values for any array field, this
+        function returns the value for a certain index.
+        """
+        for node in self.get_tree_entries():
+            if node == ':' or node.type == 'subscript':
+                # TODO this should probably use at least part of the code
+                #      of infer_subscript_list.
+                yield LazyKnownValue(Slice(self._defining_context, None, None, None))
+            else:
+                yield LazyTreeValue(self._defining_context, node)
+        for addition in check_array_additions(self._defining_context, self):
+            yield addition
+
+    def py__len__(self):
+        # This function is not really used often. It's more of a try.
+        return len(self.get_tree_entries())
+
+    def get_tree_entries(self):
+        c = self.atom.children
+
+        if self.atom.type in self._TUPLE_LIKE:
+            return c[::2]
+
+        array_node = c[1]
+        if array_node in (']', '}', ')'):
+            return []  # Direct closing bracket, doesn't contain items.
+
+        if array_node.type == 'testlist_comp':
+            # filter out (for now) pep 448 single-star unpacking
+            return [value for value in array_node.children[::2]
+                    if value.type != "star_expr"]
+        elif array_node.type == 'dictorsetmaker':
+            kv = []
+            iterator = iter(array_node.children)
+            for key in iterator:
+                if key == "**":
+                    # dict with pep 448 double-star unpacking
+                    # for now ignoring the values imported by **
+                    next(iterator)
+                    next(iterator, None)  # Possible comma.
+                else:
+                    op = next(iterator, None)
+                    if op is None or op == ',':
+                        if key.type == "star_expr":
+                            # pep 448 single-star unpacking
+                            # for now ignoring values imported by *
+                            pass
+                        else:
+                            kv.append(key)  # A set.
+                    else:
+                        assert op == ':'  # A dict.
+                        kv.append((key, next(iterator)))
+                        next(iterator, None)  # Possible comma.
+            return kv
+        else:
+            if array_node.type == "star_expr":
+                # pep 448 single-star unpacking
+                # for now ignoring values imported by *
+                return []
+            else:
+                return [array_node]
+
+    def exact_key_items(self):
+        """
+        Returns a generator of tuples like dict.items(), where the key is
+        resolved (as a string) and the values are still lazy values.
+        """
+        for key_node, value in self.get_tree_entries():
+            for key in self._defining_context.infer_node(key_node):
+                if is_string(key):
+                    yield key.get_safe_value(), LazyTreeValue(self._defining_context, value)
+
+    def __repr__(self):
+        return "<%s of %s>" % (self.__class__.__name__, self.atom)
+
+
+class DictLiteralValue(_DictMixin, SequenceLiteralValue, _DictKeyMixin):
+    array_type = u'dict'
+
+    def __init__(self, inference_state, defining_context, atom):
+        super(SequenceLiteralValue, self).__init__(inference_state)
+        self._defining_context = defining_context
+        self.atom = atom
+
+    def py__simple_getitem__(self, index):
+        """Here the index is an int/str. Raises IndexError/KeyError."""
+        compiled_value_index = compiled.create_simple_object(self.inference_state, index)
+        for key, value in self.get_tree_entries():
+            for k in self._defining_context.infer_node(key):
+                for key_v in k.execute_operation(compiled_value_index, u'=='):
+                    if key_v.get_safe_value():
+                        return self._defining_context.infer_node(value)
+        raise SimpleGetItemNotFound('No key found in dictionary %s.' % self)
+
+    def py__iter__(self, contextualized_node=None):
+        """
+        While values returns the possible values for any array field, this
+        function returns the value for a certain index.
+        """
+        # Get keys.
+        types = NO_VALUES
+        for k, _ in self.get_tree_entries():
+            types |= self._defining_context.infer_node(k)
+        # We don't know which dict index comes first, therefore always
+        # yield all the types.
+        for _ in types:
+            yield LazyKnownValues(types)
+
+    @publish_method('values')
+    def _imitate_values(self, arguments):
+        lazy_value = LazyKnownValues(self._dict_values())
+        return ValueSet([FakeList(self.inference_state, [lazy_value])])
+
+    @publish_method('items')
+    def _imitate_items(self, arguments):
+        lazy_values = [
+            LazyKnownValue(FakeTuple(
+                self.inference_state,
+                (LazyTreeValue(self._defining_context, key_node),
+                 LazyTreeValue(self._defining_context, value_node))
+            )) for key_node, value_node in self.get_tree_entries()
+        ]
+
+        return ValueSet([FakeList(self.inference_state, lazy_values)])
+
+    def _dict_values(self):
+        return ValueSet.from_sets(
+            self._defining_context.infer_node(v)
+            for k, v in self.get_tree_entries()
+        )
+
+    def _dict_keys(self):
+        return ValueSet.from_sets(
+            self._defining_context.infer_node(k)
+            for k, v in self.get_tree_entries()
+        )
+
+
+class _FakeSequence(Sequence):
+    def __init__(self, inference_state, lazy_value_list):
+        """
+        type should be one of "tuple", "list"
+        """
+        super(_FakeSequence, self).__init__(inference_state)
+        self._lazy_value_list = lazy_value_list
+
+    def py__simple_getitem__(self, index):
+        if isinstance(index, slice):
+            return ValueSet([self])
+
+        with reraise_getitem_errors(IndexError, TypeError):
+            lazy_value = self._lazy_value_list[index]
+        return lazy_value.infer()
+
+    def py__iter__(self, contextualized_node=None):
+        return self._lazy_value_list
+
+    def py__bool__(self):
+        return bool(len(self._lazy_value_list))
+
+    def __repr__(self):
+        return "<%s of %s>" % (type(self).__name__, self._lazy_value_list)
+
+
+class FakeTuple(_FakeSequence):
+    array_type = u'tuple'
+
+
+class FakeList(_FakeSequence):
+    array_type = u'tuple'
+
+
+class FakeDict(_DictMixin, Sequence, _DictKeyMixin):
+    array_type = u'dict'
+
+    def __init__(self, inference_state, dct):
+        super(FakeDict, self).__init__(inference_state)
+        self._dct = dct
+
+    def py__iter__(self, contextualized_node=None):
+        for key in self._dct:
+            yield LazyKnownValue(compiled.create_simple_object(self.inference_state, key))
+
+    def py__simple_getitem__(self, index):
+        if is_py3 and self.inference_state.environment.version_info.major == 2:
+            # In Python 2 bytes and unicode compare.
+            if isinstance(index, bytes):
+                index_unicode = force_unicode(index)
+                try:
+                    return self._dct[index_unicode].infer()
+                except KeyError:
+                    pass
+            elif isinstance(index, str):
+                index_bytes = index.encode('utf-8')
+                try:
+                    return self._dct[index_bytes].infer()
+                except KeyError:
+                    pass
+
+        with reraise_getitem_errors(KeyError, TypeError):
+            lazy_value = self._dct[index]
+        return lazy_value.infer()
+
+    @publish_method('values')
+    def _values(self, arguments):
+        return ValueSet([FakeTuple(
+            self.inference_state,
+            [LazyKnownValues(self._dict_values())]
+        )])
+
+    def _dict_values(self):
+        return ValueSet.from_sets(lazy_value.infer() for lazy_value in self._dct.values())
+
+    def _dict_keys(self):
+        return ValueSet.from_sets(lazy_value.infer() for lazy_value in self.py__iter__())
+
+    def exact_key_items(self):
+        return self._dct.items()
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self._dct)
+
+
+class MergedArray(Sequence):
+    def __init__(self, inference_state, arrays):
+        super(MergedArray, self).__init__(inference_state)
+        self.array_type = arrays[-1].array_type
+        self._arrays = arrays
+
+    def py__iter__(self, contextualized_node=None):
+        for array in self._arrays:
+            for lazy_value in array.py__iter__():
+                yield lazy_value
+
+    def py__simple_getitem__(self, index):
+        return ValueSet.from_sets(lazy_value.infer() for lazy_value in self.py__iter__())
+
+
+def unpack_tuple_to_dict(context, types, exprlist):
+    """
+    Unpacking tuple assignments in for statements and expr_stmts.
+    """
+    if exprlist.type == 'name':
+        return {exprlist.value: types}
+    elif exprlist.type == 'atom' and exprlist.children[0] in ('(', '['):
+        return unpack_tuple_to_dict(context, types, exprlist.children[1])
+    elif exprlist.type in ('testlist', 'testlist_comp', 'exprlist',
+                           'testlist_star_expr'):
+        dct = {}
+        parts = iter(exprlist.children[::2])
+        n = 0
+        for lazy_value in types.iterate(ContextualizedNode(context, exprlist)):
+            n += 1
+            try:
+                part = next(parts)
+            except StopIteration:
+                analysis.add(context, 'value-error-too-many-values', part,
+                             message="ValueError: too many values to unpack (expected %s)" % n)
+            else:
+                dct.update(unpack_tuple_to_dict(context, lazy_value.infer(), part))
+        has_parts = next(parts, None)
+        if types and has_parts is not None:
+            analysis.add(context, 'value-error-too-few-values', has_parts,
+                         message="ValueError: need more than %s values to unpack" % n)
+        return dct
+    elif exprlist.type == 'power' or exprlist.type == 'atom_expr':
+        # Something like ``arr[x], var = ...``.
+        # This is something that is not yet supported, would also be difficult
+        # to write into a dict.
+        return {}
+    elif exprlist.type == 'star_expr':  # `a, *b, c = x` type unpackings
+        # Currently we're not supporting them.
+        return {}
+    raise NotImplementedError
+
+
+class Slice(LazyValueWrapper):
+    def __init__(self, python_context, start, stop, step):
+        self.inference_state = python_context.inference_state
+        self._context = python_context
+        # All of them are either a Precedence or None.
+        self._start = start
+        self._stop = stop
+        self._step = step
+
+    def _get_wrapped_value(self):
+        value = compiled.builtin_from_name(self._context.inference_state, 'slice')
+        slice_value, = value.execute_with_values()
+        return slice_value
+
+    def get_safe_value(self, default=sentinel):
+        """
+        Imitate CompiledValue.obj behavior and return a ``builtin.slice()``
+        object.
+        """
+        def get(element):
+            if element is None:
+                return None
+
+            result = self._context.infer_node(element)
+            if len(result) != 1:
+                # For simplicity, we want slices to be clear defined with just
+                # one type.  Otherwise we will return an empty slice object.
+                raise IndexError
+
+            value, = result
+            return get_int_or_none(value)
+
+        try:
+            return slice(get(self._start), get(self._stop), get(self._step))
+        except IndexError:
+            return slice(None, None, None)

venv/Lib/site-packages/jedi/inference/value/klass.py

@@ -0,0 +1,392 @@
+"""
+Like described in the :mod:`parso.python.tree` module,
+there's a need for an ast like module to represent the states of parsed
+modules.
+
+But now there are also structures in Python that need a little bit more than
+that. An ``Instance`` for example is only a ``Class`` before it is
+instantiated. This class represents these cases.
+
+So, why is there also a ``Class`` class here? Well, there are decorators and
+they change classes in Python 3.
+
+Representation modules also define "magic methods". Those methods look like
+``py__foo__`` and are typically mappable to the Python equivalents ``__call__``
+and others. Here's a list:
+
+====================================== ========================================
+**Method**                             **Description**
+-------------------------------------- ----------------------------------------
+py__call__(arguments: Array)           On callable objects, returns types.
+py__bool__()                           Returns True/False/None; None means that
+                                       there's no certainty.
+py__bases__()                          Returns a list of base classes.
+py__iter__()                           Returns a generator of a set of types.
+py__class__()                          Returns the class of an instance.
+py__simple_getitem__(index: int/str)   Returns a a set of types of the index.
+                                       Can raise an IndexError/KeyError.
+py__getitem__(indexes: ValueSet)       Returns a a set of types of the index.
+py__file__()                           Only on modules. Returns None if does
+                                       not exist.
+py__package__() -> List[str]           Only on modules. For the import system.
+py__path__()                           Only on modules. For the import system.
+py__get__(call_object)                 Only on instances. Simulates
+                                       descriptors.
+py__doc__()                            Returns the docstring for a value.
+====================================== ========================================
+
+"""
+from jedi import debug
+from jedi._compatibility import use_metaclass
+from jedi.parser_utils import get_cached_parent_scope, expr_is_dotted
+from jedi.inference.cache import inference_state_method_cache, CachedMetaClass, \
+    inference_state_method_generator_cache
+from jedi.inference import compiled
+from jedi.inference.lazy_value import LazyKnownValues, LazyTreeValue
+from jedi.inference.filters import ParserTreeFilter
+from jedi.inference.names import TreeNameDefinition, ValueName
+from jedi.inference.arguments import unpack_arglist, ValuesArguments
+from jedi.inference.base_value import ValueSet, iterator_to_value_set, \
+    NO_VALUES
+from jedi.inference.context import ClassContext
+from jedi.inference.value.function import FunctionAndClassBase
+from jedi.inference.gradual.generics import LazyGenericManager, TupleGenericManager
+from jedi.plugins import plugin_manager
+
+
+class ClassName(TreeNameDefinition):
+    def __init__(self, class_value, tree_name, name_context, apply_decorators):
+        super(ClassName, self).__init__(name_context, tree_name)
+        self._apply_decorators = apply_decorators
+        self._class_value = class_value
+
+    @iterator_to_value_set
+    def infer(self):
+        # We're using a different value to infer, so we cannot call super().
+        from jedi.inference.syntax_tree import tree_name_to_values
+        inferred = tree_name_to_values(
+            self.parent_context.inference_state, self.parent_context, self.tree_name)
+
+        for result_value in inferred:
+            if self._apply_decorators:
+                for c in result_value.py__get__(instance=None, class_value=self._class_value):
+                    yield c
+            else:
+                yield result_value
+
+
+class ClassFilter(ParserTreeFilter):
+    def __init__(self, class_value, node_context=None, until_position=None,
+                 origin_scope=None, is_instance=False):
+        super(ClassFilter, self).__init__(
+            class_value.as_context(), node_context,
+            until_position=until_position,
+            origin_scope=origin_scope,
+        )
+        self._class_value = class_value
+        self._is_instance = is_instance
+
+    def _convert_names(self, names):
+        return [
+            ClassName(
+                class_value=self._class_value,
+                tree_name=name,
+                name_context=self._node_context,
+                apply_decorators=not self._is_instance,
+            ) for name in names
+        ]
+
+    def _equals_origin_scope(self):
+        node = self._origin_scope
+        while node is not None:
+            if node == self._parser_scope or node == self.parent_context:
+                return True
+            node = get_cached_parent_scope(self._used_names, node)
+        return False
+
+    def _access_possible(self, name):
+        # Filter for ClassVar variables
+        # TODO this is not properly done, yet. It just checks for the string
+        # ClassVar in the annotation, which can be quite imprecise. If we
+        # wanted to do this correct, we would have to infer the ClassVar.
+        if not self._is_instance:
+            expr_stmt = name.get_definition()
+            if expr_stmt is not None and expr_stmt.type == 'expr_stmt':
+                annassign = expr_stmt.children[1]
+                if annassign.type == 'annassign':
+                    # If there is an =, the variable is obviously also
+                    # defined on the class.
+                    if 'ClassVar' not in annassign.children[1].get_code() \
+                            and '=' not in annassign.children:
+                        return False
+
+        # Filter for name mangling of private variables like __foo
+        return not name.value.startswith('__') or name.value.endswith('__') \
+            or self._equals_origin_scope()
+
+    def _filter(self, names):
+        names = super(ClassFilter, self)._filter(names)
+        return [name for name in names if self._access_possible(name)]
+
+
+class ClassMixin(object):
+    def is_class(self):
+        return True
+
+    def is_class_mixin(self):
+        return True
+
+    def py__call__(self, arguments):
+        from jedi.inference.value import TreeInstance
+
+        from jedi.inference.gradual.typing import TypedDict
+        if self.is_typeddict():
+            return ValueSet([TypedDict(self)])
+        return ValueSet([TreeInstance(self.inference_state, self.parent_context, self, arguments)])
+
+    def py__class__(self):
+        return compiled.builtin_from_name(self.inference_state, u'type')
+
+    @property
+    def name(self):
+        return ValueName(self, self.tree_node.name)
+
+    def py__name__(self):
+        return self.name.string_name
+
+    @inference_state_method_generator_cache()
+    def py__mro__(self):
+        mro = [self]
+        yield self
+        # TODO Do a proper mro resolution. Currently we are just listing
+        # classes. However, it's a complicated algorithm.
+        for lazy_cls in self.py__bases__():
+            # TODO there's multiple different mro paths possible if this yields
+            # multiple possibilities. Could be changed to be more correct.
+            for cls in lazy_cls.infer():
+                # TODO detect for TypeError: duplicate base class str,
+                # e.g.  `class X(str, str): pass`
+                try:
+                    mro_method = cls.py__mro__
+                except AttributeError:
+                    # TODO add a TypeError like:
+                    """
+                    >>> class Y(lambda: test): pass
+                    Traceback (most recent call last):
+                      File "<stdin>", line 1, in <module>
+                    TypeError: function() argument 1 must be code, not str
+                    >>> class Y(1): pass
+                    Traceback (most recent call last):
+                      File "<stdin>", line 1, in <module>
+                    TypeError: int() takes at most 2 arguments (3 given)
+                    """
+                    debug.warning('Super class of %s is not a class: %s', self, cls)
+                else:
+                    for cls_new in mro_method():
+                        if cls_new not in mro:
+                            mro.append(cls_new)
+                            yield cls_new
+
+    def get_filters(self, origin_scope=None, is_instance=False,
+                    include_metaclasses=True, include_type_when_class=True):
+        if include_metaclasses:
+            metaclasses = self.get_metaclasses()
+            if metaclasses:
+                for f in self.get_metaclass_filters(metaclasses, is_instance):
+                    yield f  # Python 2..
+
+        for cls in self.py__mro__():
+            if cls.is_compiled():
+                for filter in cls.get_filters(is_instance=is_instance):
+                    yield filter
+            else:
+                yield ClassFilter(
+                    self, node_context=cls.as_context(),
+                    origin_scope=origin_scope,
+                    is_instance=is_instance
+                )
+        if not is_instance and include_type_when_class:
+            from jedi.inference.compiled import builtin_from_name
+            type_ = builtin_from_name(self.inference_state, u'type')
+            assert isinstance(type_, ClassValue)
+            if type_ != self:
+                # We are not using execute_with_values here, because the
+                # plugin function for type would get executed instead of an
+                # instance creation.
+                args = ValuesArguments([])
+                for instance in type_.py__call__(args):
+                    instance_filters = instance.get_filters()
+                    # Filter out self filters
+                    next(instance_filters, None)
+                    next(instance_filters, None)
+                    x = next(instance_filters, None)
+                    assert x is not None
+                    yield x
+
+    def get_signatures(self):
+        # Since calling staticmethod without a function is illegal, the Jedi
+        # plugin doesn't return anything. Therefore call directly and get what
+        # we want: An instance of staticmethod.
+        metaclasses = self.get_metaclasses()
+        if metaclasses:
+            sigs = self.get_metaclass_signatures(metaclasses)
+            if sigs:
+                return sigs
+        args = ValuesArguments([])
+        init_funcs = self.py__call__(args).py__getattribute__('__init__')
+        return [sig.bind(self) for sig in init_funcs.get_signatures()]
+
+    def _as_context(self):
+        return ClassContext(self)
+
+    def get_type_hint(self, add_class_info=True):
+        if add_class_info:
+            return 'Type[%s]' % self.py__name__()
+        return self.py__name__()
+
+    @inference_state_method_cache(default=False)
+    def is_typeddict(self):
+        # TODO Do a proper mro resolution. Currently we are just listing
+        # classes. However, it's a complicated algorithm.
+        from jedi.inference.gradual.typing import TypedDictClass
+        for lazy_cls in self.py__bases__():
+            if not isinstance(lazy_cls, LazyTreeValue):
+                return False
+            tree_node = lazy_cls.data
+            # Only resolve simple classes, stuff like Iterable[str] are more
+            # intensive to resolve and if generics are involved, we know it's
+            # not a TypedDict.
+            if not expr_is_dotted(tree_node):
+                return False
+
+            for cls in lazy_cls.infer():
+                if isinstance(cls, TypedDictClass):
+                    return True
+                try:
+                    method = cls.is_typeddict
+                except AttributeError:
+                    # We're only dealing with simple classes, so just returning
+                    # here should be fine. This only happens with e.g. compiled
+                    # classes.
+                    return False
+                else:
+                    if method():
+                        return True
+        return False
+
+    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 with_generics(self, generics_tuple):
+        from jedi.inference.gradual.base import GenericClass
+        return GenericClass(
+            self,
+            TupleGenericManager(generics_tuple)
+        )
+
+    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})
+
+
+class ClassValue(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBase)):
+    api_type = u'class'
+
+    @inference_state_method_cache()
+    def list_type_vars(self):
+        found = []
+        arglist = self.tree_node.get_super_arglist()
+        if arglist is None:
+            return []
+
+        for stars, node in unpack_arglist(arglist):
+            if stars:
+                continue  # These are not relevant for this search.
+
+            from jedi.inference.gradual.annotation import find_unknown_type_vars
+            for type_var in find_unknown_type_vars(self.parent_context, node):
+                if type_var not in found:
+                    # The order matters and it's therefore a list.
+                    found.append(type_var)
+        return found
+
+    def _get_bases_arguments(self):
+        arglist = self.tree_node.get_super_arglist()
+        if arglist:
+            from jedi.inference import arguments
+            return arguments.TreeArguments(self.inference_state, self.parent_context, arglist)
+        return None
+
+    @inference_state_method_cache(default=())
+    def py__bases__(self):
+        args = self._get_bases_arguments()
+        if args is not None:
+            lst = [value for key, value in args.unpack() if key is None]
+            if lst:
+                return lst
+
+        if self.py__name__() == 'object' \
+                and self.parent_context.is_builtins_module():
+            return []
+        return [LazyKnownValues(
+            self.inference_state.builtins_module.py__getattribute__('object')
+        )]
+
+    @plugin_manager.decorate()
+    def get_metaclass_filters(self, metaclasses, is_instance):
+        debug.warning('Unprocessed metaclass %s', metaclasses)
+        return []
+
+    @inference_state_method_cache(default=NO_VALUES)
+    def get_metaclasses(self):
+        args = self._get_bases_arguments()
+        if args is not None:
+            m = [value for key, value in args.unpack() if key == 'metaclass']
+            metaclasses = ValueSet.from_sets(lazy_value.infer() for lazy_value in m)
+            metaclasses = ValueSet(m for m in metaclasses if m.is_class())
+            if metaclasses:
+                return metaclasses
+
+        for lazy_base in self.py__bases__():
+            for value in lazy_base.infer():
+                if value.is_class():
+                    values = value.get_metaclasses()
+                    if values:
+                        return values
+        return NO_VALUES
+
+    @plugin_manager.decorate()
+    def get_metaclass_signatures(self, metaclasses):
+        return []