def main(args): assert len(args) == 2, args host = args[0] if args[1] != "": global script_env script_env = create_environment(args[1], safe=False) service_factory(app, host, 0, "anaconda_mode port {port}")
def bf_initialize( self, params: types.InitializeParams) -> types.InitializeResult: result = super().bf_initialize(params) global jediEnvironment global jediProject global completionFunction global documentSymbolFunction global hoverMarkup global hoverFunction if params.initialization_options: venv = params.initialization_options.get('venv', None) else: venv = None if venv: jediEnvironment = create_environment(venv, safe=False) else: jediEnvironment = get_default_environment() jediProject = get_default_project(getattr(params, 'rootPath', None)) logging.info(f'Jedi environment python: {jediEnvironment.executable}') logging.info('Jedi environment sys_path:') for p in jediEnvironment.get_sys_path(): logging.info(f' {p}') logging.info(f'Jedi project path: {jediProject._path}') def get_attr(o, *attrs): try: for attr in attrs: o = getattr(o, attr) return o except AttributeError: return None caps = getattr(params.capabilities, 'text_document', None) if get_attr(caps, 'completion', 'completion_item', 'snippet_support'): completionFunction = _completions_snippets else: completionFunction = _completions if get_attr(caps, 'document_symbol', 'hierarchical_document_symbol_support'): documentSymbolFunction = _document_symbol_hierarchy else: documentSymbolFunction = _document_symbol_plain hover = get_attr(caps, 'hover', 'content_format') if hover: hoverMarkup = hover[0] if hoverMarkup == types.MarkupKind.Markdown: hoverFunction = _docstring_markdown else: hoverFunction = _docstring # pygls does not currently support serverInfo of LSP v3.15 result.server_info = types.ServerInfo( name='anakinls', version=get_version(), ) return result
def __init__(self, project_root, environment_binaries_path): self.project_root = project_root self.environment = None if environment_binaries_path is not None: self.environment = jedi.create_environment( environment_binaries_path, safe=False) self.completions = {} sys.path.append(project_root)
def create_env(env_path): try: env = jedi.create_environment(env_path) msg(repr(env).replace('Environment:', 'Python')) return env except jedi.InvalidPythonEnvironment: msg('Incorrect environment! Python interpreter is not activated') return
def jedi_create_environment(venv, safe=True): """Cache jedi environments to avoid startup cost.""" try: return _cached_jedi_environments[venv] except KeyError: jedienv = jedi.create_environment(venv, safe=safe) _cached_jedi_environments[venv] = jedienv return jedienv
def __init__(self, vim): Ncm2Source.__init__(self, vim) env = vim.vars['ncm2_jedi#environment'] if not env: osenv = os.environ if 'VIRTUAL_ENV' not in osenv and 'CONDA_PREFIX' in osenv: # if conda is active self._env = jedi.create_environment(osenv['CONDA_PREFIX']) else: # get_default_environment handles VIRTUAL_ENV self._env = jedi.get_default_environment() else: self._env = jedi.create_environment(env) rc_settings = vim.vars['ncm2_jedi#settings'] for name in rc_settings: setattr(settings, name, rc_settings[name])
def run(module, venv_path=None): source = textwrap.dedent(f""" import {module} {module}.no """).strip() env = None if venv_path is not None: env = jedi.create_environment(venv_path) script = jedi.Script(source, 2, len(module + ".no") - 1, environment=env) print(script.completions())
def bf_initialize( self, params: types.InitializeParams) -> types.InitializeResult: result = super().bf_initialize(params) global jediEnvironment global jediProject global completionFunction global documentSymbolFunction venv = getattr(params.initializationOptions, 'venv', None) if venv: jediEnvironment = create_environment(venv, False) else: jediEnvironment = get_default_environment() jediProject = get_default_project(getattr(params, 'rootPath', None)) logging.info(f'Jedi environment python: {jediEnvironment.executable}') logging.info('Jedi environment sys_path:') for p in jediEnvironment.get_sys_path(): logging.info(f' {p}') logging.info(f'Jedi project path: {jediProject._path}') def get_attr(o, *attrs): try: for attr in attrs: o = getattr(o, attr) return o except AttributeError: return None caps = getattr(params.capabilities, 'textDocument', None) if get_attr(caps, 'completion', 'completionItem', 'snippetSupport'): completionFunction = _completions_snippets else: completionFunction = _completions if get_attr(caps, 'documentSymbol', 'hierarchicalDocumentSymbolSupport'): documentSymbolFunction = _document_symbol_hierarchy else: documentSymbolFunction = _document_symbol_plain result.capabilities.textDocumentSync = types.TextDocumentSyncOptions( open_close=True, change=types.TextDocumentSyncKind.INCREMENTAL, save=types.SaveOptions()) result.capabilities.codeActionProvider = types.CodeActionOptions([ types.CodeActionKind.RefactorInline, types.CodeActionKind.RefactorExtract ]) # pygls does not currently support serverInfo of LSP v3.15 result.serverInfo = { 'name': 'anakinls', 'version': get_version(), } return result
def jedi_create_environment(venv, safe=False): """Cache jedi environments to avoid startup cost.""" try: return _cached_jedi_environments[venv] except KeyError: logger.info('Creating jedi environment: %s', venv) if venv is None: jedienv = jedi.api.environment.get_default_environment() else: jedienv = jedi.create_environment(venv, safe=safe) _cached_jedi_environments[venv] = jedienv return jedienv
def __init__(self, vim): Ncm2Source.__init__(self, vim) env = vim.vars['ncm2_jedi#environment'] if not env: self._env = jedi.get_default_environment() else: self._env = jedi.create_environment(env) rc_settings = vim.vars['ncm2_jedi#settings'] for name in rc_settings: setattr(settings, name, rc_settings[name])
def __init__(self, project_root, environment_binaries_path): self.project_root = project_root self.environment = None if environment_binaries_path is not None: self.environment = jedi.create_environment( environment_binaries_path, safe=False) self.completions = {} sys.path.append(project_root) # Backward compatibility to jedi<17 if not JEDISUP17: # pragma: no cover self.rpc_get_completions = self.rpc_get_completions_jedi16 self.rpc_get_docstring = self.rpc_get_docstring_jedi16 self.rpc_get_definition = self.rpc_get_definition_jedi16 self.rpc_get_assignment = self.rpc_get_assignment_jedi16 self.rpc_get_calltip = self.rpc_get_calltip_jedi16 self.rpc_get_oneline_docstring = self.rpc_get_oneline_docstring_jedi16 self.rpc_get_usages = self.rpc_get_usages_jedi16 self.rpc_get_names = self.rpc_get_names_jedi16
def _EnvironmentForInterpreterPath( self, interpreter_path ): if interpreter_path: resolved_interpreter_path = FindExecutable( ExpandVariablesInPath( interpreter_path ) ) if not resolved_interpreter_path: raise RuntimeError( 'Cannot find Python interpreter path {}.'.format( interpreter_path ) ) interpreter_path = os.path.normpath( resolved_interpreter_path ) try: return self._environment_for_interpreter_path[ interpreter_path ] except KeyError: pass # Assume paths specified by the user are safe. environment = ( jedi.get_default_environment() if not interpreter_path else jedi.create_environment( interpreter_path, safe = False ) ) self._environment_for_interpreter_path[ interpreter_path ] = environment return environment
import service_factory except ImportError: missing_dependencies.append('>='.join(service_factory_dep)) # Try one more time in case if anaconda installation gets broken somehow if missing_dependencies: install_deps() import jedi import service_factory # Setup server. assert LooseVersion(jedi.__version__) >= LooseVersion(jedi_dep[1]), 'Jedi version should be >= %s, current version: %s' % (jedi_dep[1], jedi.__version__) if virtual_environment: virtual_environment = jedi.create_environment(virtual_environment, safe=False) else: virtual_environment = None # Define JSON-RPC application. import functools import threading def script_method(f): @functools.wraps(f) def wrapper(source, line, column, path): timer = threading.Timer(30.0, sys.exit) timer.start() result = f(jedi.Script(source, path=path, environment=virtual_environment), line, column) timer.cancel()
import jedi import os.path from dictknife.loading import dumps if __name__ == "__main__": import argparse parser = argparse.ArgumentParser() parser.add_argument("--venv", default=None) args = parser.parse_args() environment = None if args.venv is not None: venv_path = os.path.expanduser(args.venv) environment = jedi.create_environment(venv_path) defs = jedi.Script( """import marshmallow""", 1, 7, ".", environment=environment ).goto_definitions() print(dumps({d.name: d.module_path for d in defs}, format="json"))
import jedi import os.path from dictknife.loading import dumps if __name__ == "__main__": import argparse parser = argparse.ArgumentParser() parser.add_argument("--venv", default=None) args = parser.parse_args() environment = None if args.venv is not None: venv_path = os.path.expanduser(args.venv) environment = jedi.create_environment(venv_path) defs = jedi.Script("""import marshmallow""", 1, 7, ".", environment=environment).goto_definitions() print(dumps({d.name: d.module_path for d in defs}, format="json"))