python-lsp-server

Fork of the python-language-server project, maintained by the Spyder IDE team and the community

1,865

194

1,865

121

View on GitHub

Top Related Projects

python-language-server

2,607

An implementation of the Language Server Protocol for Python

jedi

5,757

Awesome autocompletion, static analysis and refactoring library for python

Quick Overview

Python LSP Server (pylsp) is a Language Server Protocol implementation for Python. It provides language intelligence features such as auto-completion, go-to-definition, and real-time error checking for Python code in various integrated development environments (IDEs) and text editors that support the Language Server Protocol.

Pros

Supports a wide range of Python language features and tools
Compatible with multiple IDEs and text editors
Extensible through plugins
Active development and community support

Cons

May have slower performance compared to some language-specific implementations
Configuration can be complex for advanced use cases
Some features may require additional setup or dependencies
Occasional stability issues reported by users

Code Examples

Basic usage in a Python file:

# This example demonstrates auto-completion and error checking
import math

def calculate_circle_area(radius):
    return math.pi * radius ** 2

result = calculate_circle_area(5)
print(f"The area of the circle is: {result:.2f}")

Using type hints for better code intelligence:

from typing import List, Dict

def process_data(items: List[int]) -> Dict[str, int]:
    return {
        "sum": sum(items),
        "length": len(items),
        "average": sum(items) / len(items) if items else 0
    }

data = [1, 2, 3, 4, 5]
result = process_data(data)
print(result)

Demonstrating error detection:

# The LSP server will highlight the error in this code
def divide_numbers(a, b):
    return a / b

result = divide_numbers(10, 0)  # Division by zero error
print(result)

Getting Started

To use Python LSP Server in your development environment:

Install pylsp:
```
pip install python-lsp-server
```
Configure your IDE or text editor to use pylsp as the language server for Python files. This process varies depending on your editor, but typically involves specifying the path to the pylsp executable.
Open a Python file in your editor and start coding. You should now have access to features like auto-completion, go-to-definition, and real-time error checking.

For more advanced configuration and plugin setup, refer to the project's documentation on GitHub.

Competitor Comparisons

python-language-server

2,607

An implementation of the Language Server Protocol for Python

Pros of python-language-server

More mature project with a longer development history
Wider range of features and plugins available
Better performance for larger codebases

Cons of python-language-server

No longer actively maintained (last commit in 2021)
May have compatibility issues with newer Python versions
Lacks some modern LSP features

Code Comparison

python-language-server:

from pyls import hookimpl

@hookimpl
def pyls_completions(document, position):
    # Custom completion logic
    return []

python-lsp-server:

from pylsp import hookimpl

@hookimpl
def pylsp_completions(config, workspace, document, position):
    # Custom completion logic
    return []

The main difference is in the function signature and import statement. python-lsp-server provides more context (config and workspace) to the completion hook.

Both projects aim to provide Language Server Protocol (LSP) implementation for Python. python-language-server was the original project, but it's no longer maintained. python-lsp-server is a fork that continues active development, incorporating modern LSP features and maintaining compatibility with newer Python versions. While python-language-server may still work for some use cases, python-lsp-server is generally recommended for new projects due to its ongoing support and updates.

pyright

13,105

Static Type Checker for Python

Pros of Pyright

Faster performance, especially for large codebases
More accurate type checking and inference
Better support for modern Python features and type annotations

Cons of Pyright

Steeper learning curve for configuration and customization
Less extensive plugin ecosystem compared to Python LSP Server
May require more manual type annotations for optimal results

Code Comparison

Python LSP Server:

from pylsp import hookimpl

@hookimpl
def pylsp_completions(document, position):
    # Custom completion logic here
    return []

Pyright:

from pyright import LanguageServerProtocol

class CustomLanguageServer(LanguageServerProtocol):
    def provide_completions(self, params):
        # Custom completion logic here
        return []

Both projects aim to provide language server functionality for Python, but they differ in their approach and focus. Python LSP Server offers a more traditional, plugin-based architecture, while Pyright emphasizes static type checking and performance. The choice between the two depends on specific project requirements, team expertise, and the importance of type-related features in the development workflow.

jedi

5,757

Awesome autocompletion, static analysis and refactoring library for python

Pros of Jedi

Lightweight and focused solely on Python autocompletion and static analysis
Can be used as a standalone library, offering more flexibility for integration
Faster for simple autocompletion tasks due to its specialized nature

Cons of Jedi

Limited scope compared to Python-LSP-Server's broader feature set
Requires additional tools for full IDE-like functionality
Less frequent updates and smaller community compared to Python-LSP-Server

Code Comparison

Jedi usage:

import jedi

script = jedi.Script("import os\nos.")
completions = script.complete(1, 3)

Python-LSP-Server usage:

from pylsp import uris
from pylsp.workspace import Document
from pylsp.python_lsp import PythonLSPServer

server = PythonLSPServer()
doc = Document(uris.from_fs_path("/path/to/file.py"), "import os\nos.")
completions = server.completions(doc, {"line": 1, "character": 3})

While both libraries provide code completion, Jedi offers a simpler API for basic autocompletion tasks. Python-LSP-Server, being a full Language Server Protocol implementation, requires more setup but provides a wider range of features beyond just autocompletion.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Python LSP Server

A Python 3.8+ implementation of the Language Server Protocol. (Note: versions <1.4 should still work with Python 3.6)

Installation

The base language server requires Jedi to provide Completions, Definitions, Hover, References, Signature Help, and Symbols:

pip install python-lsp-server

This will expose the command pylsp on your PATH. Confirm that installation succeeded by running pylsp --help.

If the respective dependencies are found, the following optional providers will be enabled:

Rope for Completions and renaming
Pyflakes linter to detect various errors
McCabe linter for complexity checking
pycodestyle linter for style checking
pydocstyle linter for docstring style checking (disabled by default)
autopep8 for code formatting
YAPF for code formatting (preferred over autopep8)
flake8 for error checking (disabled by default)
pylint for code linting (disabled by default)

Optional providers can be installed using the extras syntax. To install YAPF formatting for example:

pip install "python-lsp-server[yapf]"

All optional providers can be installed using:

pip install "python-lsp-server[all]"

If you get an error similar to 'install_requires' must be a string or list of strings then please upgrade setuptools before trying again.

pip install -U setuptools

Windows and Linux installation

If you use Anaconda/Miniconda, you can install python-lsp-server using this conda command

conda install -c conda-forge python-lsp-server

Python-lsp-server is available in the repos of every major Linux distribution, and it is usually called python-lsp-server or python3-pylsp.

For example, here is how to install it in Debian and Debian-based distributions (E.g. Ubuntu, Pop!_OS, Linux Mint)

sudo apt-get install python3-pylsp

or Fedora Linux

sudo dnf install python3-lsp-server

or Arch Linux

sudo pacman -S python-lsp-server

Only on Alpine Linux the package is named differently. You can install it there by typing this command in your terminal:

apk add py3-lsp-server

3rd Party Plugins

Installing these plugins will add extra functionality to the language server:

pylsp-mypy: MyPy type checking for Python >=3.8.
python-lsp-isort: code formatting using isort (automatic import sorting).
python-lsp-black: code formatting using Black.
pyls-memestra: detecting the use of deprecated APIs.
pylsp-rope: Extended refactoring capabilities using Rope.
python-lsp-ruff: Extensive and fast linting using ruff.

Please see the above repositories for examples on how to write plugins for the Python LSP Server.

cookiecutter-pylsp-plugin is a cookiecutter template for setting up a basic plugin project for python-lsp-server. It documents all the essentials you need to know to kick start your own plugin project.

Please file an issue if you require assistance writing a plugin.

Configuration

Like all language servers, configuration can be passed from the client that talks to this server (i.e. your editor/IDE or other tool that has the same purpose). The details of how this is done depend on the editor or plugin that you are using to communicate with python-lsp-server. The configuration options available at that level are documented in CONFIGURATION.md.

python-lsp-server depends on other tools, like flake8 and pycodestyle. These tools can be configured via settings passed from the client (as above), or alternatively from other configuration sources. The following sources are available:

pycodestyle: discovered in ~/.config/pycodestyle, setup.cfg, tox.ini and pycodestyle.cfg.
flake8: discovered in .flake8, setup.cfg and tox.ini

The default configuration sources are pycodestyle and pyflakes. If you would like to use flake8, you will need to:

Disable pycodestyle, mccabe, and pyflakes, by setting their corresponding enabled configurations, e.g. pylsp.plugins.pycodestyle.enabled, to false. This will prevent duplicate linting messages as flake8 includes these tools.
Set pylsp.plugins.flake8.enabled to true.
Change the pylsp.configurationSources setting (in the value passed in from your client) to ['flake8'] in order to use the flake8 configuration instead.

The configuration options available in these config files (setup.cfg etc) are documented in the relevant tools:

Overall configuration is computed first from user configuration (in home directory), overridden by configuration passed in by the language client, and then overridden by configuration discovered in the workspace.

As an example, to change the list of errors that pycodestyle will ignore, assuming you are using the pycodestyle configuration source (the default), you can:

Add the following to your ~/.config/pycodestyle:
```
[pycodestyle]
ignore = E226,E302,E41
```
Set the pylsp.plugins.pycodestyle.ignore config value from your editor
Same as 1, but add to setup.cfg file in the root of the project.

Python LSP Server can communicate over WebSockets when configured as follows:

pylsp --ws --port [port]

The following libraries are required for Web Sockets support:

websockets for Python LSP Server Web sockets using websockets library. refer Websockets installation for more details

You can install this dependency with command below:

pip install 'python-lsp-server[websockets]'

LSP Server Features

Auto Completion
Autoimport
Code Linting
Code actions
Signature Help
Go to definition
Hover
Find References
Document Symbols
Document Formatting
Code folding
Multiple workspaces

Development

Dev install

# (optional) create conda env
conda create --name python-lsp-server python=3.11 -y
conda activate python-lsp-server

pip install -e ".[all,websockets,test]"

Run server with ws

pylsp --ws -v  # Info level logging
pylsp --ws -vv # Debug level logging

To run the test suite:

# requires: pip install ".[test]" (see above)
pytest

Running ruff as a linter and code formatter on the repo:

ruff check .  # linter
ruff check --fix .  # fix all auto-fixable lint issues
ruff format .  # format the document

After adding configuration options to schema.json, refresh the CONFIGURATION.md file with

python scripts/jsonschema2md.py pylsp/config/schema.json CONFIGURATION.md

License

This project is made available under the MIT License.

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot