def test_relative_imports_with_multiple_similar_directories(Script, path, empty_sys_path): dir = get_example_dir('issue1209') if empty_sys_path: project = Project(dir, sys_path=(), smart_sys_path=False) else: project = Project(dir) script = Script( "from . ", path=os.path.join(dir, path), _project=project, ) name, import_ = script.completions() assert import_.name == 'import' assert name.name == 'api_test1'
def test_flask_ext(Script, code, name): """flask.ext.foo is really imported from flaskext.foo or flask_foo. """ path = get_example_dir('flask-site-packages') completions = Script(code, project=Project('.', sys_path=[path])).complete() assert name in [c.name for c in completions]
def __init__(self, source, namespaces, **kwds): """ Parse `source` and mixin interpreted Python objects from `namespaces`. :type source: str :arg source: Code to parse. :type namespaces: list of dict :arg namespaces: a list of namespace dictionaries such as the one returned by :func:`locals`. Other optional arguments are same as the ones for :class:`Script`. If `line` and `column` are None, they are assumed be at the end of `source`. """ try: namespaces = [dict(n) for n in namespaces] except Exception: raise TypeError("namespaces must be a non-empty list of dicts.") environment = kwds.get('environment', None) if environment is None: environment = InterpreterEnvironment() else: if not isinstance(environment, InterpreterEnvironment): raise TypeError( "The environment needs to be an InterpreterEnvironment subclass." ) super(Interpreter, self).__init__(source, environment=environment, _project=Project(os.getcwd()), **kwds) self.namespaces = namespaces self._inference_state.allow_descriptor_getattr = self._allow_descriptor_getattr_default
def getJediProject(force=False): """Provides a jedi project""" global jediProject if force or jediProject is None: project = GlobalData().project if project.isLoaded(): jPath = project.getProjectDir() addedPaths = [] for path in project.getImportDirsAsAbsolutePaths(): if path not in addedPaths: addedPaths.append(path) projectDir = project.getProjectDir() if projectDir not in addedPaths: addedPaths.append(projectDir) else: jPath = os.path.realpath(QDir.homePath()) addedPaths = () jediProject = Project(jPath, sys_path=GlobalData().originalSysPath[:], added_sys_path=addedPaths) return jediProject
def __init__(self, code, namespaces, *, project=None, **kwds): try: namespaces = [dict(n) for n in namespaces] except Exception: raise TypeError("namespaces must be a non-empty list of dicts.") environment = kwds.get('environment', None) if environment is None: environment = InterpreterEnvironment() else: if not isinstance(environment, InterpreterEnvironment): raise TypeError( "The environment needs to be an InterpreterEnvironment subclass." ) if project is None: project = Project(Path.cwd()) super().__init__(code, environment=environment, project=project, **kwds) self.namespaces = namespaces self._inference_state.allow_descriptor_getattr = self._allow_descriptor_getattr_default
def test_infer_and_goto(Script, code, full_name, has_stub, has_python, way, kwargs, type_, options, environment): if environment.version_info < (3, 5): # We just don't care about much of the detailed Python 2 failures # anymore, because its end-of-life soon. (same for 3.4) pytest.skip() if type_ == 'infer' and full_name == 'typing.Sequence' and environment.version_info >= ( 3, 7): # In Python 3.7+ there's not really a sequence definition, there's just # a name that leads nowhere. has_python = False project = Project( os.path.join(root_dir, 'test', 'completion', 'stub_folder')) s = Script(code, _project=project) prefer_stubs = kwargs['prefer_stubs'] only_stubs = kwargs['only_stubs'] if type_ == 'goto': full_name = options.get('goto_full_name', full_name) has_python = options.get('goto_has_python', has_python) if way == 'direct': if type_ == 'goto': defs = s.goto_assignments(follow_imports=True, **kwargs) else: defs = s.goto_definitions(**kwargs) else: goto_defs = s.goto_assignments( # Prefering stubs when we want to go to python and vice versa prefer_stubs=not (prefer_stubs or only_stubs), follow_imports=True, ) if type_ == 'goto': defs = [ d for goto_def in goto_defs for d in goto_def.goto_assignments(**kwargs) ] else: defs = [ d for goto_def in goto_defs for d in goto_def.infer(**kwargs) ] if not has_stub and only_stubs: assert not defs else: assert defs for d in defs: if prefer_stubs and has_stub: assert d.is_stub() elif only_stubs: assert d.is_stub() else: assert has_python == (not d.is_stub()) assert d.full_name == full_name assert d.is_stub() == d.module_path.endswith('.pyi')
def test_cache_works_with_sys_path_param(Script, tmpdir): foo_path = tmpdir.join('foo') bar_path = tmpdir.join('bar') foo_path.join('module.py').write('foo = 123', ensure=True) bar_path.join('module.py').write('bar = 123', ensure=True) foo_completions = Script( 'import module; module.', project=Project('.', sys_path=[foo_path.strpath]), ).complete() bar_completions = Script( 'import module; module.', project=Project('.', sys_path=[bar_path.strpath]), ).complete() assert 'foo' in [c.name for c in foo_completions] assert 'bar' not in [c.name for c in foo_completions] assert 'bar' in [c.name for c in bar_completions] assert 'foo' not in [c.name for c in bar_completions]
def test_correct_zip_package_behavior(Script, inference_state, environment, code, file, package, path): sys_path = environment.get_sys_path() + [str(pkg_zip_path)] pkg, = Script(code, project=Project('.', sys_path=sys_path)).infer() value, = pkg._name.infer() assert value.py__file__() == pkg_zip_path.joinpath('pkg', file) assert '.'.join(value.py__package__()) == package assert value.is_package() is (path is not None) if path is not None: assert value.py__path__() == [str(pkg_zip_path.joinpath(path))]
def test_relative_imports_without_path(Script): project = Project('.', sys_path=[], smart_sys_path=False) script = Script("from . ", _project=project) assert [c.name for c in script.completions()] == ['api_test1', 'import'] script = Script("from .. ", _project=project) assert [c.name for c in script.completions()] == ['import', 'whatever'] script = Script("from ... ", _project=project) assert [c.name for c in script.completions()] == ['api', 'import', 'whatever']
def test_find_module_not_package_zipped(Script, inference_state, environment): path = get_example_dir('zipped_imports', 'not_pkg.zip') sys_path = environment.get_sys_path() + [path] script = Script('import not_pkg; not_pkg.val', project=Project('.', sys_path=sys_path)) assert len(script.complete()) == 1 file_io, is_package = inference_state.compiled_subprocess.get_module_info( sys_path=map(str, sys_path), string='not_pkg', full_name='not_pkg') assert file_io.path.parts[-2:] == ('not_pkg.zip', 'not_pkg.py') assert is_package is False
def test_relative_imports_without_path(Script): path = get_example_dir('issue1209', 'api', 'whatever') project = Project(path, sys_path=[], smart_sys_path=False) script = Script("from . ", project=project) assert [c.name for c in script.complete()] == ['api_test1', 'import'] script = Script("from .. ", project=project) assert [c.name for c in script.complete()] == ['import', 'whatever'] script = Script("from ... ", project=project) assert [c.name for c in script.complete()] == ['api', 'import', 'whatever']
def test_relative_imports_with_multiple_similar_directories(Script, path): dir = get_example_dir('issue1209') script = Script( "from .", path=os.path.join(dir, path) ) # TODO pass this project to the script as a param once that's possible. script._evaluator.project = Project(dir) name, import_ = script.completions() assert import_.name == 'import' assert name.name == 'api_test1'
def test_import_needed_modules_by_jedi(Script, environment, tmpdir, name): module_path = tmpdir.join(name + '.py') module_path.write('int = ...') script = Script( 'import ' + name, path=tmpdir.join('something.py').strpath, project=Project('.', sys_path=[tmpdir.strpath] + environment.get_sys_path()), ) module, = script.infer() assert str(module._inference_state.builtins_module.py__file__()) != module_path assert str(module._inference_state.typing_module.py__file__()) != module_path
def test_conversion_of_stub_only(Script): project = Project(os.path.join(root_dir, 'test', 'completion', 'stub_folder')) code = 'import stub_only; stub_only.in_stub_only' d1, = Script(code, project=project).goto() assert d1.is_stub() script = Script(path=d1.module_path, project=project) d2, = script.goto(line=d1.line, column=d1.column) assert d2.is_stub() assert d2.module_path == d1.module_path assert d2.line == d1.line assert d2.column == d1.column assert d2.name == 'in_stub_only'
def test_find_module_package_zipped(Script, inference_state, environment): sys_path = environment.get_sys_path() + [str(pkg_zip_path)] project = Project('.', sys_path=sys_path) script = Script('import pkg; pkg.mod', project=project) assert len(script.complete()) == 1 file_io, is_package = inference_state.compiled_subprocess.get_module_info( sys_path=sys_path, string='pkg', full_name='pkg') assert file_io is not None assert file_io.path.parts[-3:] == ('pkg.zip', 'pkg', '__init__.py') assert file_io._zip_path.name == 'pkg.zip' assert is_package is True
def test_goto_on_file(Script): project = Project(os.path.join(root_dir, 'test', 'completion', 'stub_folder')) script = Script('import stub_only; stub_only.Foo', project=project) d1, = script.goto() v, = d1._name.infer() foo, bar, obj = v.py__mro__() assert foo.py__name__() == 'Foo' assert bar.py__name__() == 'Bar' assert obj.py__name__() == 'object' # Make sure we go to Bar, because Foo is a bit before: `class Foo(Bar):` script = Script(path=d1.module_path, project=project) d2, = script.goto(line=d1.line, column=d1.column + 4) assert d2.name == 'Bar'
def test_get_modules_containing_name(inference_state, path, goal, is_package): inference_state.project = Project(test_dir) module = imports._load_python_module( inference_state, FileIO(path), import_names=('ok', 'lala', 'x'), is_package=is_package, ) assert module module_context = module.as_context() input_module, found_module = get_module_contexts_containing_name( inference_state, [module_context], 'string_that_only_exists_here') assert input_module is module_context assert found_module.string_names == goal
def test_relative_imports_with_outside_paths(Script): dir = get_example_dir('issue1209') project = Project(dir, sys_path=[], smart_sys_path=False) script = Script( "from ...", path=os.path.join(dir, 'api/whatever/test_this.py'), _project=project, ) assert [c.name for c in script.completions()] == ['api', 'import', 'whatever'] script = Script( "from " + '.' * 100, path=os.path.join(dir, 'api/whatever/test_this.py'), _project=project, ) assert [c.name for c in script.completions()] == ['import']
def test_infer_and_goto(Script, code, full_name, has_stub, has_python, way, kwargs, type_, options, environment): if type_ == 'infer' and full_name == 'typing.Sequence' and environment.version_info >= (3, 7): # In Python 3.7+ there's not really a sequence definition, there's just # a name that leads nowhere. has_python = False project = Project(os.path.join(root_dir, 'test', 'completion', 'stub_folder')) s = Script(code, project=project) prefer_stubs = kwargs['prefer_stubs'] only_stubs = kwargs['only_stubs'] if type_ == 'goto': full_name = options.get('goto_full_name', full_name) has_python = options.get('goto_has_python', has_python) if way == 'direct': if type_ == 'goto': defs = s.goto(follow_imports=True, **kwargs) else: defs = s.infer(**kwargs) else: goto_defs = s.goto( # Prefering stubs when we want to go to python and vice versa prefer_stubs=not (prefer_stubs or only_stubs), follow_imports=True, ) if type_ == 'goto': defs = [d for goto_def in goto_defs for d in goto_def.goto(**kwargs)] else: defs = [d for goto_def in goto_defs for d in goto_def.infer(**kwargs)] if not has_stub and only_stubs: assert not defs else: assert defs for d in defs: if prefer_stubs and has_stub: assert d.is_stub() elif only_stubs: assert d.is_stub() else: assert has_python == (not d.is_stub()) assert d.full_name == full_name assert d.is_stub() == (d.module_path.suffix == '.pyi')
def test_import_not_in_sys_path(Script, environment): """ non-direct imports (not in sys.path) This is in the end just a fallback. """ path = get_example_dir() module_path = os.path.join(path, 'not_in_sys_path', 'pkg', 'module.py') # This project tests the smart path option of Project. The sys_path is # explicitly given to make sure that the path is just dumb and only # includes non-folder dependencies. project = Project(path, sys_path=environment.get_sys_path()) a = Script(path=module_path, project=project).infer(line=5) assert a[0].name == 'int' a = Script(path=module_path, project=project).infer(line=6) assert a[0].name == 'str' a = Script(path=module_path, project=project).infer(line=7) assert a[0].name == 'str'
def test_references_scope(Script, code, places): if not code: code = '''import sys from collections import defaultdict print(sys.path) def foo(bar): baz = defaultdict(int) return baz def bar(foo): baz = defaultdict(int) return baz foo() ''' from jedi.api.project import Project project = Project('', sys_path=[], smart_sys_path=False) script = Script(code, project=project) for place in places: assert places == [(n.line, n.column) for n in script.get_references(scope='file', *place)]
def test_infer_and_goto(Script, code, full_name, has_stub, has_python, way, kwargs): project = Project( os.path.join(root_dir, 'test', 'completion', 'stub_folder')) s = Script(code, _project=project) if way == 'direct': defs = s.goto_definitions(**kwargs) else: goto_defs = s.goto_assignments() defs = [d for goto_def in goto_defs for d in goto_def.infer(**kwargs)] only_stubs = kwargs['only_stubs'] prefer_stubs = kwargs['prefer_stubs'] if not has_stub and only_stubs: assert not defs else: assert defs for d in defs: if prefer_stubs and has_stub: assert d.is_stub() if only_stubs: assert d.is_stub() assert d.full_name == full_name
def ScriptInStubFolder(Script): path = get_example_dir('stub_packages') project = Project(path, sys_path=[path], smart_sys_path=False) return partial(Script, _project=project)
def get(include): from jedi.api.project import Project script = Script(source, project=Project('', sys_path=[], smart_sys_path=False)) references = script.get_references(column=8, include_builtins=include) return [(d.line, d.column) for d in references]
def test_zip_package_import_complete(Script, environment, code, names): sys_path = environment.get_sys_path() + [str(pkg_zip_path)] completions = Script(code, project=Project('.', sys_path=sys_path)).complete() assert names == {c.name for c in completions}