How to configure neovim to properly format python code?

Question

I have neovim 0.8.0 installed. I have neovim/nvim-lspconfig plugin installed. I have installed pyright language server on my system (pip install pyright) I have configured neovim to use the pyright language server.

So now when I open a python file I get some warnings produced by pyright. :LspInfo command confirms that "1 client(s) attached to this buffer" and this client is pyright.

So far so good. Now I start editing some code. For example I write the following function call:

x = get_value_of_x("aaaaaaaaaa", "bbbbbbb", "ccccccc",
        "dddddddd")

As you can see this code is not properly formatted. According to pep8 rules it should be formatted like this:

x = get_value_of_x("aaaaaaaaaa", "bbbbbbb", "ccccccc",
                   "dddddddd")

I expected that neovim integrated with language server will automatically indent the code, but somehow it does not happen.

I tried to trigger format explicitly by executing the following command:

:lua vim.lsp.buf.format()

but get following error message: [LSP] Format request failed, no matching language servers.

I tried to install different language server ("jedi-language-server") instead of "pyright" - and the result is approximately the same: both servers function properly (for example "go to definition" functionality works fine) but not auto-formatting is available.

No log messages generated during these formatting attempts in ~/.cache/nvim/lsp.log

How can I configure nvim / lsp servers to properly indent python code?

Answer 1

Here is an example of how to make this work with lspconfig

~/.config/nvim/init.lua

require("_plugins")

~/.config/nvim/lua/_plugins.lua

local fn = vim.fn
local install_path = fn.stdpath("data") .. "/site/pack/packer/start/packer.nvim"
if fn.empty(fn.glob(install_path)) > 0 then
  Packer_Bootstrap = fn.system({
    "git",
    "clone",
    "--depth",
    "1",
    "https://github.com/wbthomason/packer.nvim",
    install_path,
  })
end

local packer_ok, packer = pcall(require, "packer")
if not packer_ok then
  return
end

return packer.startup(function()
  use({
    "wbthomason/packer.nvim",
  })
  use({
    "neovim/nvim-lspconfig",
    requires = {
      "williamboman/mason.nvim",
      "williamboman/mason-lspconfig.nvim",
    },
    config = function()
      require("_lsp").setup()
    end,
  })
    use { "jose-elias-alvarez/null-ls.nvim",
    requires = { "nvim-lua/plenary.nvim" },
    config = function()
      require("_null-ls")
    end
  }
  if Packer_Bootstrap then
    require("packer").sync()
  end
end)

~/.config/nvim/lua/_lsp.lua

local lspconfig_ok, lspconfig = pcall(require, "lspconfig")
if not lspconfig_ok then
  return
end

local mason_ok, mason = pcall(require, "mason")
if not mason_ok then
  return
end

local mason_lspconfig_ok, mason_lspconfig = pcall(require, "mason-lspconfig")
if not mason_lspconfig_ok then
  return
end

local _lsp = {}
function _lsp.setup()
  mason.setup({})
  mason_lspconfig.setup({})

  mason_lspconfig.setup_handlers {
    function(server_name)
      require("lspconfig")[server_name].setup({})
    end
  }
end

return _lsp

~/.config/lua/_null-ls

local null_ls_ok, null_ls = pcall(require, "null-ls")
if not null_ls_ok then
  return
end

local sources = {
  -- python
  null_ls.builtins.formatting.black.with({
    extra_args = { "--line-length=120" }
  }),
  null_ls.builtins.formatting.isort,
}

null_ls.setup({ sources = sources })

Install plugins

:PackerSync

Install LSPs

• Install from the list, use i to install

:MasonInstall black
:MasonInstall pyright
:MasonInstall isort

verify

Open a python file and run

:LspInfo

This should report that the servers are setup and running.

Then however you choose to wire up the formatting command.

Answer 2

For range formatting you may have a look at black-macchiato.

Install black-macchiato by running the shell command:

pip install black-macchiato

To format a range of select lines run the vim command:

:'<,'>!python -m macchiato

Or install the pluging smbl64/vim-black-macchiato: vim-black-macchiato

Answer 3

It took some time to figure out what is happening.

Short answer: looks like LSP servers do not affect nvim's indentation when you press "Enter" button while editing text. I had to install and properly configure 'nvim-treesitter' plugin to make things work.

More detailed answer. To find out what happens when you proceed to next line (push "Enter" button in insert mode or "o" button in normal mode) check value of the indentexpr setting:

:set indentexpr?
  indentexpr=python#GetIndent(v:lnum)

In my case it was a vimscript method, I found it in /usr/local/share/nvim/runtime/autoload/python.vim. (To find the location of the function run the following command: verbose function python#GetIndent, if it compains that the function is not found do edit you file and try again). You can check what this function does to calculate the indent level. It was interesting for me to look into this function and play with it a little. Bottomline: it does not try to use lsp.

Installation of different language servers did not affect indentexpr.

It turned out that for a long time I used not standard indentation implemented in my .vimrc/indent/python.vim - I really do not remember where have I got this file from. It was created in 2004 by some guy David Bustos - thanks a lot to him. Autoindentation implemented in this file is much better than standard, but still with some glitches. Lots changed since 2004, so there should be a better way.

Looks like a better way is 'nvim-treesitter' plugin. Very good instructions on plugin configuration can be found in this short tutorial: https://www.youtube.com/watch?v=hkxPa5w3bZ0&list=PLhoH5vyxr6Qq41NFL4GvhFp-WLd5xzIzZ

Example of configuration (via lua script):

local treesitter_ok, treesitter = pcall(require, 'nvim-treesitter.configs')
if treesitter_ok then
  treesitter.setup{
    ensure_installed = { 'c', 'lua', 'vim', 'help', 'python', 'go' },
    sync_install = false,                                                                                                 
    auto_install = false,                                                                                                       
    highlight = {                                                                                                 
      enable = false,
    },
    indent = {
      enable = true,
    },
  }
end

Make sure to run :TSUpdate after or during installation (depends on plugin manager you use).

Make sure that treesitter is enabled for python: :TSInstallInfo

If everything is ok than treesitter is used for indentation:

:set indentexpr?
  indentexpr=nvim_treesitter#indent()

On-the-fly indentation is indeed better now.

UPDATE: Indentation is still not good. In some cases it's better, but still not good.

Answer 4

You need the efm language server, and the python black formatter. You also need to set up efm like this:

nvim_lsp.efm.setup {               
    on_attach = on_attach,    
    flags = {                                                                                                                                                                                 
      debounce_text_changes = 150,
    },
    init_options = {documentFormatting = true},
    filetypes = {"python"},
    settings = {
        rootMarkers = {".git/"},
        languages = {
            python = {
                {formatCommand = "black --quiet -", formatStdin = true}
            }
        }
    }
}

Efm is difficult to install. You need Go. I figured it out on my system using these commands:

GO111MODULE=on go get github.com/mattn/efm-langserver@latest    
echo 'export PATH=$PATH:~/go/bin' >> ~/.zshrc 

Answer 5

I would suggest trying null-ls, the configuration is relatively simple and you don't need to change your lspconfig settings at most of the time.

My conf is just a copy/paste from null-ls's wiki(formatting fires automatically when you save the buffer):

https://github.com/dreamerlzl/nvim-setup/blob/lua/lua/lsp/null.lua

local augroup = vim.api.nvim_create_augroup("LspFormatting", {})
local null_ls = require("null-ls")

null_ls.setup({
    on_attach = function(client, bufnr)
        if client.supports_method("textDocument/formatting") then
            vim.api.nvim_clear_autocmds({ group = augroup, buffer = bufnr })
            vim.api.nvim_create_autocmd("BufWritePre", {
                group = augroup,
                buffer = bufnr,
                callback = function()
                    -- on 0.8, you should use vim.lsp.buf.format({ bufnr = bufnr }) instead
                    vim.lsp.buf.format({ bufnr = bufnr })
                end,
            })
        end
    end,
    sources = {
        null_ls.builtins.formatting.stylua,
        null_ls.builtins.formatting.black,
    },
})

You could find the original wiki here on null-ls's wiki

The following link is only for demonstrating that I do nothing special about the pyright configuration:

https://github.com/dreamerlzl/nvim-setup/blob/lua/lua/lsp/lspconfig.lua#LL126C29-L126C36

Answer 6

There are many ways.

Here is one using Coc.Nvim (neoclide/coc.nvim)

Follow the instructions to install Coc.Nvim

Basically (if you are using Plug)

1. Add the following line to your .vimrc

Plug 'neoclide/coc.nvim' , {'branch': 'release'}

2. Resource your .vimrc using the vim command:

:so %

3. Run the vim command:

:PlugInstall

4. Restart Neovim

When installed install Pyright support by entering the vim command:

:CocInstall coc-pyright

Add the following line to your .vimrc file to add Format support:

  " Add `:Format` command to format current buffer.
  command! -nargs=0 Format :call CocAction('format')

  " Use CTRL-S for selections ranges.
  " Requires 'textDocument/selectionRange' support of language server.
  nmap <silent> <C-s> <Plug>(coc-range-select)
  xmap <silent> <C-s> <Plug>(coc-range-select)

The :Format command format the entire file.

For that to work you'll need to have Black installed. This can be achieved using the following shell command:

pip install black

If Coc.Nvim fails to find Black you can configure it explicitly by typing the vim command:

:CocConfig

The coc-settings.json file will open.

Make sure the following lines (On a Windows machine) are part of the config.

Remark: Coc.Nvim support also range formatting if the corresponding language server support it. It seems that PyRight is not supporting range formatting yet.

{
    "python.formatting.provider": "black",
    "python.formatting.blackPath": "C:\\Python36_x64\\Scripts\\black.exe",
}