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 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
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"))
