Move the initial sys path generation into a new project class.

jedi/api/__init__.py

@@ -27,9 +27,10 @@ from jedi.api import helpers
 from jedi.api.completion import Completion
 from jedi.evaluate import Evaluator
 from jedi.evaluate import imports
+from jedi.evaluate.project import Project
 from jedi.evaluate.arguments import try_iter_content
 from jedi.evaluate.helpers import get_module_names, evaluate_call_of_leaf
-from jedi.evaluate.sys_path import get_venv_path, dotted_path_in_sys_path
+from jedi.evaluate.sys_path import dotted_path_in_sys_path
 from jedi.evaluate.filters import TreeNameDefinition
 from jedi.evaluate.syntax_tree import tree_name_to_contexts
 from jedi.evaluate.context import ModuleContext
@@ -110,11 +111,7 @@ class Script(object):
 
         # Load the Python grammar of the current interpreter.
         self._grammar = parso.load_grammar()
-        if sys_path is None:
-            venv = os.getenv('VIRTUAL_ENV')
-            if venv:
-                sys_path = list(get_venv_path(venv))
-        self._evaluator = Evaluator(self._grammar, sys_path=sys_path)
+        self._evaluator = Evaluator(self._grammar, Project(sys_path=sys_path))
         debug.speed('init')
 
     @cache.memoize_method
@@ -135,7 +132,7 @@ class Script(object):
             self.path
         )
         if self.path is not None:
-            name = dotted_path_in_sys_path(self._evaluator.sys_path, self.path)
+            name = dotted_path_in_sys_path(self._evaluator.project.sys_path, self.path)
             if name is not None:
                 imports.add_module(self._evaluator, name, module)
         return module

jedi/evaluate/__init__.py

@@ -87,7 +87,7 @@ from jedi.evaluate.syntax_tree import eval_trailer, eval_expr_stmt, \
 
 
 class Evaluator(object):
-    def __init__(self, grammar, sys_path=None):
+    def __init__(self, grammar, project):
         self.grammar = grammar
         self.latest_grammar = parso.load_grammar(version='3.6')
         self.memoize_cache = {}  # for memoize decorators
@@ -101,13 +101,7 @@ class Evaluator(object):
         self.is_analysis = False
         self.python_version = sys.version_info[:2]
 
-        if sys_path is None:
-            sys_path = sys.path
-        self.sys_path = copy.copy(sys_path)
-        try:
-            self.sys_path.remove('')
-        except ValueError:
-            pass
+        self.project = project
 
         self.reset_recursion_limitations()
 

jedi/evaluate/arguments.py

@@ -243,5 +243,3 @@ def _star_star_dict(context, array, input_node, funcdef):
                 % (funcdef.name.value, array)
             analysis.add(context, 'type-error-star-star', input_node, message=m)
         return {}
-
-

jedi/evaluate/compiled/__init__.py

@@ -444,7 +444,7 @@ def dotted_from_fs_path(fs_path, sys_path):
 
 
 def load_module(evaluator, path=None, name=None):
-    sys_path = evaluator.sys_path
+    sys_path = list(evaluator.project.sys_path)
     if path is not None:
         dotted_path = dotted_from_fs_path(path, sys_path=sys_path)
     else:

jedi/evaluate/context/module.py

@@ -135,7 +135,7 @@ class ModuleContext(use_metaclass(CachedMetaClass, TreeContext)):
             return self.py__name__()
 
     def _py__path__(self):
-        search_path = self.evaluator.sys_path
+        search_path = self.evaluator.project.sys_path
         init_path = self.py__file__()
         if os.path.basename(init_path) == '__init__.py':
             with open(init_path, 'rb') as f:

jedi/evaluate/imports.py

@@ -480,7 +480,7 @@ class Importer(object):
 
 def _load_module(evaluator, path=None, code=None, sys_path=None, parent_module=None):
     if sys_path is None:
-        sys_path = evaluator.sys_path
+        sys_path = evaluator.project.sys_path
 
     dotted_path = path and compiled.dotted_from_fs_path(path, sys_path)
     if path is not None and path.endswith(('.py', '.zip', '.egg')) \
@@ -530,7 +530,7 @@ def get_modules_containing_name(evaluator, modules, name):
             if name in code:
                 module = _load_module(evaluator, path, code)
 
-                module_name = sys_path.dotted_path_in_sys_path(evaluator.sys_path, path)
+                module_name = sys_path.dotted_path_in_sys_path(evaluator.project.sys_path, path)
                 if module_name is not None:
                     add_module(evaluator, module_name, module)
                 return module

jedi/evaluate/project.py

@@ -0,0 +1,24 @@
+import os
+import sys
+
+from jedi.evaluate.sys_path import get_venv_path
+
+
+class Project(object):
+    def __init__(self, sys_path=None):
+        if sys_path is None:
+            venv = os.getenv('VIRTUAL_ENV')
+            if venv:
+                sys_path = get_venv_path(venv)
+
+        if sys_path is None:
+            sys_path = sys.path
+
+        sys_path = list(sys_path)
+
+        try:
+            sys_path.remove('')
+        except ValueError:
+            pass
+
+        self.sys_path = sys_path

jedi/evaluate/sys_path.py

@@ -161,7 +161,7 @@ def _check_module(module_context):
                     if n.type == 'name' and n.value == 'path':
                         yield name, power
 
-    sys_path = list(module_context.evaluator.sys_path)  # copy
+    sys_path = list(module_context.evaluator.project.sys_path)  # copy
     if isinstance(module_context, CompiledObject):
         return sys_path
 
@@ -189,7 +189,7 @@ def sys_path_with_modifications(evaluator, module_context):
     if path is None:
         # Support for modules without a path is bad, therefore return the
         # normal path.
-        return list(evaluator.sys_path)
+        return evaluator.project.sys_path
 
     curdir = os.path.abspath(os.curdir)
     #TODO why do we need a chdir?