1
Neovim
2535 readers
1 users here now
founded 2 years ago
MODERATORS
2
3
4
5
6
7
8
9
10
Preview
What
So I really needed my pylsp to use a different pyenv install, and just want to share my basic solution in hopes it'll help someone else.
The basic gist of it is that I use vim.system() to get the version paths through pyenv:
pyenv root
pyenv versions --bare --skip-aliases
and create a telescope picker for selection.
Then I use vim.lsp.client.notify() with the workspace/didChangeConfiguration lsp method to change pylsp's settings (for which options can be found here).
Code
local pickers = require("telescope.pickers")
local finders = require("telescope.finders")
local conf = require("telescope.config").values
local actions = require("telescope.actions")
local action_state = require("telescope.actions.state")
local M = {}
M.get_pyenv_root = function()
if not vim.fn.executable('pyenv') then
vim.notify("pyenv executable not in path.", vim.log.levels.WARN)
return nil
end
local root_cmd = vim.system({
'pyenv',
'root',
}):wait()
if root_cmd.code ~= 0 then
vim.notify('"pyenv root" command returned non zero exit status.', vim.log.levels.WARN)
return nil
end
local pyenv_root = string.gsub(root_cmd.stdout, '%s+', '')
local pyenv_versions_path = vim.fs.joinpath(pyenv_root, '/versions')
if not vim.fn.isdirectory(pyenv_versions_path) then
vim.notify("Failed to find pyenv versions directory, '" .. pyenv_versions_path .. "'.", vim.log.levels.WARN)
return nil
end
return pyenv_versions_path
end
M.get_pyenv_version_paths = function()
if not vim.fn.executable('pyenv') then
vim.notify("pyenv executable not in path.", vim.log.levels.WARN)
return nil
end
local cmd = {
'pyenv',
'versions',
'--bare',
'--skip-aliases'
}
local versions_cmd = vim.system(cmd):wait()
if versions_cmd.code ~= 0 then
vim.notify('command "' .. vim.inspect(cmd) .. '" returned non zero exit status.', vim.log.levels.WARN)
return nil
end
local versions = vim.fn.split(versions_cmd.stdout, '\n')
return versions
end
M.get_pyenv_results = function()
local pyenv_versions_root = M.get_pyenv_root()
local results = {}
if pyenv_versions_root == nil then
return nil
end
local pyenv_versions = M.get_pyenv_version_paths()
if pyenv_versions == nil then
return nil
end
for _, version_path in ipairs(pyenv_versions) do
table.insert(results, {
version_path,
vim.fs.joinpath(pyenv_versions_root, version_path),
})
end
return results
end
M.set_pylsp_environment = function(python_env)
local pylsp_clients = vim.lsp.get_clients({ name = "pylsp" })
if pylsp_clients == nil or next(pylsp_clients) == nil then
vim.notify("No Pylsp clients found.", vim.log.levels.WARN)
return
end
local clients = 0
for _, client in ipairs(pylsp_clients) do
client.notify("workspace/didChangeConfiguration", {
settings = {
pylsp = {
plugins = {
jedi = {
environment = python_env
}
}
}
}
})
clients = clients + 1
end
vim.notify("Set python environment to '" .. python_env .. "' for " .. clients .. " pylsp clients.")
end
M.pyenvs = function(opts)
opts = opts or {}
local version_results = M.get_pyenv_results()
if version_results == nil then
return
end
pickers.new(opts, {
prompt_title = "pyenvs",
finder = finders.new_table({
results = version_results,
entry_maker = function(entry)
return {
value = entry,
display = entry[1],
ordinal = entry[1],
}
end,
}),
attach_mappings = function(prompt_bufnr, _)
actions.select_default:replace(function()
actions.close(prompt_bufnr)
local selection = action_state.get_selected_entry()
M.set_pylsp_environment(selection.value[2])
end)
return true
end,
sorter = conf.generic_sorter(opts)
}):find()
end
return M
And now you can easily open the picker with the M.pyenvs() function.
Also nice way to create the keymap for it is to wait for the LspAttach autocmd (which fires when an LSP is attached to a buffer) to fire and only create the keymap on the buffer that pylsp is attached to like so:
(don't forget to change the '<module_name>')
vim.api.nvim_create_autocmd("LspAttach", {
callback = function(args)
local client = vim.lsp.get_client_by_id(args.data.client_id)
if client and client.name == "pylsp" then
vim.keymap.set("n", "<leader>le", function()
local pylsp_picker = require("<module_name>")
pylsp_picker.pyenvs()
end, {
desc = "[e]nvironment (python)",
buffer = args.buf
})
end
end
})
11
12
13
14
15
16
17
18
19
20
21
22
23
I posted about this on Reddit a year ago, and I figured write about it again:
Like most companies, the one I work for will happilly pay for any employee's license to a proprietary IDE without batting an eye. Therefore, I argued that I should be able to spend that budget on a donation to an open source tool that I use daily instead. After a lot of back and forth I finally got them to donate an amount that would correspond to what they would pay for a yearly subscription to a proprietary tool to Neovim.
Do you use Neovim at work? If so, I urge you to do the same thing! That way the core team can continue to deliver awesome new features to the editor we all love. Here's a link to where you can donate.
I now got my work to pay a $400 yearly "Neovim subscription" for the second time.
To those wondering how I did it, I basically just argued that since employees at my work have an allocated budget for buying proprietary tools, it makes sense if we could spend an equivalent amount on a FOSS alternative. That way the money spent would benefit us all, and since we use the tool to make money we have a responsibility to give back to the FOSS project.
There was a bit of a back-and forth for technical reasons because (at least in Sweden where I live), payments and donations are handled and regulated differently, but they finally made it work.
If you also use Neovim for work, I encourage you to do the same thing! That way the core team can continue to deliver awesome new features to the editor we all love. Here's a link to where you can donate. There's also the official merch store if you would like to support the project that way: https://store.neovim.io/.
24
25
view more: next ›