vyper-language-server 0.2.2__tar.gz

vyper_language_server-0.2.2/.github/workflows/lint.yml

@@ -0,0 +1,20 @@
+name: Lint
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  pre-commit:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+      - name: Set up Python
+        run: uv python install
+      - name: Install dependencies
+        run: uv sync --all-extras --dev
+      - run: uv run pre-commit run --all-files

vyper_language_server-0.2.2/.github/workflows/release.yml

@@ -0,0 +1,23 @@
+name: Release to PyPI
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+      - name: Set up Python
+        run: uv python install
+      - name: Build
+        run: uv build
+      - name: Publish
+        run: uv publish

vyper_language_server-0.2.2/.github/workflows/test.yml

@@ -0,0 +1,30 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  pytest:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+      - name: Set up Python
+        run: uv python install
+      - name: Install dependencies
+        run: uv sync --all-extras --dev
+      - name: Run pytest with coverage
+        run: uv run coverage run -m pytest
+      - name: Report coverage
+        run: |
+          uv run coverage html
+          uv run coverage report --fail-under=75
+      - name: Upload coverage report
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-report
+          path: ./htmlcov

vyper_language_server-0.2.2/.gitignore

@@ -0,0 +1,7 @@
+.DS_Store
+.idea
+*.log
+tmp/
+__pycache__
+dist/
+.python-version

vyper_language_server-0.2.2/.pre-commit-config.yaml

@@ -0,0 +1,12 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: check-yaml
+      - id: end-of-file-fixer
+      - id: trailing-whitespace
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.8.3
+    hooks:
+      - id: ruff
+      - id: ruff-format

vyper_language_server-0.2.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Vyperlang team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vyper_language_server-0.2.2/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: vyper-language-server
+Version: 0.2.2
+Summary: Language server for Vyper, a pythonic smart contract language
+License-Expression: MIT
+License-File: LICENSE
+Keywords: language-server,lsp,vyper
+Requires-Python: >=3.12
+Requires-Dist: lark<2.0.0,>=1.1.7
+Requires-Dist: lsprotocol<2024.0.0,>=2023.0.1
+Requires-Dist: packaging>=23.1.0
+Requires-Dist: pygls<2.0.0,>=1.3.1
+Requires-Dist: vyper<0.5.0,>=0.4.1
+Description-Content-Type: text/markdown
+
+# Vyper Language Server
+
+A language server for [Vyper](https://github.com/vyperlang/vyper), a pythonic smart contract language for the EVM.
+
+Forked from [vyperlang/vyper-lsp](https://github.com/vyperlang/vyper-lsp).
+
+## Requirements
+
+- Python >= 3.12
+- Vyper >= 0.4.1
+
+The Vyper version installed in your virtual environment must be capable of compiling your contract for full support.
+
+## Installation
+
+This language server imports Vyper as a library, so it should be installed in the same environment as your project's Vyper.
+
+### As a project dev dependency (recommended)
+
+```toml
+# pyproject.toml
+[dependency-groups]
+dev = [
+    "vyper-language-server",
+]
+
+[tool.uv.sources]
+vyper-language-server = { git = "https://github.com/latticafi/vyper-language-server" }
+```
+
+Then `uv sync`.
+
+### Via pipx (global)
+
+```bash
+pipx install git+https://github.com/latticafi/vyper-language-server.git
+```
+
+Note: when installed globally, the server will use whatever Vyper version is in its own environment, which may not match your project.
+
+### Verify
+
+```bash
+which vyper-language-server
+```
+
+## Editor Setup
+
+### Neovim
+
+Add to `~/.config/nvim/init.lua`:
+
+```lua
+vim.api.nvim_create_autocmd({ "BufEnter" }, {
+  pattern = { "*.vy" },
+  callback = function()
+    vim.lsp.start({
+      name = "vyper-language-server",
+      cmd = { "vyper-language-server" },
+      root_dir = vim.fs.dirname(vim.fs.find({ ".git" }, { upward = true })[1])
+    })
+  end,
+})
+```
+
+If installed as a project dep, point to the venv binary:
+
+```lua
+vim.api.nvim_create_autocmd({ "BufEnter" }, {
+  pattern = { "*.vy" },
+  callback = function()
+    local venv = vim.fs.find({ ".venv" }, { upward = true })[1]
+    local cmd = venv and (venv .. "/bin/vyper-language-server") or "vyper-language-server"
+    vim.lsp.start({
+      name = "vyper-language-server",
+      cmd = { cmd },
+      root_dir = vim.fs.dirname(vim.fs.find({ ".git" }, { upward = true })[1])
+    })
+  end,
+})
+```
+
+### Emacs
+
+```emacs-lisp
+(define-derived-mode vyper-mode python-mode "Vyper" "Major mode for editing Vyper.")
+
+(add-to-list 'auto-mode-alist '("\\.vy\\'" . vyper-mode))
+
+(with-eval-after-load 'lsp-mode
+  (add-to-list 'lsp-language-id-configuration
+               '(vyper-mode . "vyper"))
+  (lsp-register-client
+   (make-lsp-client :new-connection
+                    (lsp-stdio-connection `(,(executable-find "vyper-language-server")))
+                    :activation-fn (lsp-activate-on "vyper")
+                    :server-id 'vyper-language-server)))
+```
+
+## Features
+
+- Diagnostics (compile errors and warnings)
+- Completions (state variables, functions, decorators, types, imports)
+- Hover information
+- Go to definition / declaration
+- Find references
+- Signature help
+
+## Development
+
+### Setup
+
+1. **Install uv** (Fast Python package installer and resolver)
+
+```bash
+   pip install uv
+   # Or on macOS with Homebrew
+   brew install uv
+```
+
+2. **Clone and install**
+
+```bash
+   git clone https://github.com/latticafi/vyper-language-server.git
+   cd vyper-language-server
+   uv sync
+```
+
+### Commands
+
+```bash
+uv run pytest                  # run tests
+uv run ruff check .            # lint
+uv run ruff format .           # format
+uv run coverage run -m pytest  # test with coverage
+uv run coverage report         # view coverage
+```
+
+## License
+
+MIT

vyper_language_server-0.2.2/README.md

@@ -0,0 +1,141 @@
+# Vyper Language Server
+
+A language server for [Vyper](https://github.com/vyperlang/vyper), a pythonic smart contract language for the EVM.
+
+Forked from [vyperlang/vyper-lsp](https://github.com/vyperlang/vyper-lsp).
+
+## Requirements
+
+- Python >= 3.12
+- Vyper >= 0.4.1
+
+The Vyper version installed in your virtual environment must be capable of compiling your contract for full support.
+
+## Installation
+
+This language server imports Vyper as a library, so it should be installed in the same environment as your project's Vyper.
+
+### As a project dev dependency (recommended)
+
+```toml
+# pyproject.toml
+[dependency-groups]
+dev = [
+    "vyper-language-server",
+]
+
+[tool.uv.sources]
+vyper-language-server = { git = "https://github.com/latticafi/vyper-language-server" }
+```
+
+Then `uv sync`.
+
+### Via pipx (global)
+
+```bash
+pipx install git+https://github.com/latticafi/vyper-language-server.git
+```
+
+Note: when installed globally, the server will use whatever Vyper version is in its own environment, which may not match your project.
+
+### Verify
+
+```bash
+which vyper-language-server
+```
+
+## Editor Setup
+
+### Neovim
+
+Add to `~/.config/nvim/init.lua`:
+
+```lua
+vim.api.nvim_create_autocmd({ "BufEnter" }, {
+  pattern = { "*.vy" },
+  callback = function()
+    vim.lsp.start({
+      name = "vyper-language-server",
+      cmd = { "vyper-language-server" },
+      root_dir = vim.fs.dirname(vim.fs.find({ ".git" }, { upward = true })[1])
+    })
+  end,
+})
+```
+
+If installed as a project dep, point to the venv binary:
+
+```lua
+vim.api.nvim_create_autocmd({ "BufEnter" }, {
+  pattern = { "*.vy" },
+  callback = function()
+    local venv = vim.fs.find({ ".venv" }, { upward = true })[1]
+    local cmd = venv and (venv .. "/bin/vyper-language-server") or "vyper-language-server"
+    vim.lsp.start({
+      name = "vyper-language-server",
+      cmd = { cmd },
+      root_dir = vim.fs.dirname(vim.fs.find({ ".git" }, { upward = true })[1])
+    })
+  end,
+})
+```
+
+### Emacs
+
+```emacs-lisp
+(define-derived-mode vyper-mode python-mode "Vyper" "Major mode for editing Vyper.")
+
+(add-to-list 'auto-mode-alist '("\\.vy\\'" . vyper-mode))
+
+(with-eval-after-load 'lsp-mode
+  (add-to-list 'lsp-language-id-configuration
+               '(vyper-mode . "vyper"))
+  (lsp-register-client
+   (make-lsp-client :new-connection
+                    (lsp-stdio-connection `(,(executable-find "vyper-language-server")))
+                    :activation-fn (lsp-activate-on "vyper")
+                    :server-id 'vyper-language-server)))
+```
+
+## Features
+
+- Diagnostics (compile errors and warnings)
+- Completions (state variables, functions, decorators, types, imports)
+- Hover information
+- Go to definition / declaration
+- Find references
+- Signature help
+
+## Development
+
+### Setup
+
+1. **Install uv** (Fast Python package installer and resolver)
+
+```bash
+   pip install uv
+   # Or on macOS with Homebrew
+   brew install uv
+```
+
+2. **Clone and install**
+
+```bash
+   git clone https://github.com/latticafi/vyper-language-server.git
+   cd vyper-language-server
+   uv sync
+```
+
+### Commands
+
+```bash
+uv run pytest                  # run tests
+uv run ruff check .            # lint
+uv run ruff format .           # format
+uv run coverage run -m pytest  # test with coverage
+uv run coverage report         # view coverage
+```
+
+## License
+
+MIT

vyper_language_server-0.2.2/architecture.md

@@ -0,0 +1,65 @@
+# Vyper LSP Architecture
+
+LSP stands for Language Server Protocol. It enables us to provide IDE-like features in an editor-agnostic way. LSP defines certain methods that a client and server can expect to use to communicate with each other, such that the server can be language-specific and the client can be editor-specific, and the user gets the best of both.
+
+Pygls is a very intuitive framework for building an LSP server. It follows an approach similar to FastAPI, letting us define and assign handlers for each "method" the LSP server should speak.
+
+We have separated concerns across a few different layers in order to best allow the LSP server to grow and extend over time.
+
+## Server Layer
+
+This is currently confined to `vyper_lsp/main.py`
+
+In this layer, we want to define handlers for each LSP method, and in those handlers invoke the appropriate module to compute a valid response.
+
+This means this layer should have minimal logic of its own. There should be no concept of ASTs, any source-code level features, syntax, etc. at this layer. Only what is required to start up the server itself, and hook up LSP methods to the appropriate sources of data.
+
+## Analyzer Layer
+
+This is currently made up of the modules under `vyper_lsp/analyzers/`. Here, we define a base class called `BaseAnalyzer` which defines the interface our server layer will use to communicate with the Analyzer layer.
+
+Currently there are two "analysis" functions we support
+
+- `hover_info`: returns information about a symbol being hovered over
+- `get_diagnostics`: returns a list of errors or warnings to be reported to the user
+- `get_completions`: returns a list of suggested completions for the current cursor position
+
+Analyzers classes expose functions which act on `Document` and `Params` arguments. `Document` represents the file being worked on. Through the `Document` class, `Analyzers` can easily access the entire source of the contract, as well as line-by-line information, filename, etc. `Params` will be specific to each method, and contain necessary information to answer queries for that method. For example, the params object when looking up information about a given symbol will include the current cursor position, which in combination with the line-by-line source code exposed by the `Document`, can be used to determine what symbol we're looking up.
+
+It is up to Analyzers to determine how they will return appropriate results given a query. They should abstract this away from the Server layer entirely.
+
+The two currently implemented `Analyzers` are the `ASTAnalyzer` and the `SourceAnalyzer`.
+
+### ASTAnalyzer
+
+This is where the most rich processing can happen, but where our tightest requirements around Vyper versions are.
+
+This analyzer attempts to compile the current contract via Vyper as a library. This means the version of Vyper we have installed must
+
+- Be capable of compiling this contract according to version requirements
+- Be >= 0.3.7 so we can use the internal APIs our analysis depends on
+
+This Analyzer is a good example of abstracting things away from the Server layer. It operates primarily on ASTs and nodes within it, but should not expose any implementation details about this to the Server layer.
+
+### SourceAnalyzer
+
+This analyzer should not be used unless the Vyper version of the contract being worked with is too old to run AST analysis on.
+
+This is a sort of "fallback" analyzer. This does not depend on Vyper as a library, in hopes of loosening Vyper version requirements. It does two stages of analysis.
+
+#### Syntax Analysis
+
+This leverages Vyper's `lark` grammar to check for syntax errors. This does not catch semantic errors. For example, with syntax analysis we can tell that `x + foo(7) = 24;` is wrong for many reasons (not valid syntax), but we can't tell that `x: uint256 = "hello"` is wrong (not valid semantics)
+
+#### Semantic Analysis
+
+This analyzer also tries to do some semantic analysis. It leverages `vvm` to compile contracts with version requirements incompatible with currently installed Vyper, and reports any errors encountered.
+
+This lets us work with a wider array of Vyper versions, but is significantly slower to use, due to overhead involved in going through the shell. There is also a big limit on what information we can gain other than compilation errors, because for successful compilation, we're limited to the cli outputs as defined in that Vyper version.
+
+
+## Navigation Layer
+
+This layer is made up of modules which expose classes that can handle navigation-related lookups. This is stuff like "find the declaration of this symbol". We currently have an AST navigator implemented in `vyper_lsp/navigation.py`
+
+There is potential to implement navigation support that does not require AST analysis by leveraging the Lark grammar to parse into an unchecked Lark AST. This will be lacking any Vyper information such as type, etc. but is nicer to work with than raw source.

vyper_language_server-0.2.2/examples/BondingCurve.vy

@@ -0,0 +1,58 @@
+# version ^0.4.0
+"""
+@title Bonding Curve Functions
+@custom:contract-name BondingCurve
+@license MIT License
+@author z80
+@notice These functions can be used to implement a basic bonding curve
+"""
+current_step: uint256
+EXPONENT: immutable(uint256)
+SCALING_FACTOR: immutable(uint256)
+TICK_SIZE: immutable(uint256)
+
+@deploy
+def __init__(start_step: uint256, exponent: uint256, scaling_factor: uint256, tick_size: uint256):
+    self.current_step = start_step
+    EXPONENT = exponent
+    SCALING_FACTOR = scaling_factor
+    TICK_SIZE = tick_size
+
+@view
+@internal
+def _get_current_price() -> uint256:
+    """
+    Returns the current price of the token
+    """
+    current_step_exp: uint256 = pow_mod256(self.current_step, EXPONENT)
+    return current_step_exp * SCALING_FACTOR // TICK_SIZE
+
+@view
+@internal
+def _get_price_at_step(step: uint256) -> uint256:
+    """
+    Returns the price of the token at a given step
+    """
+    step_exp: uint256 = pow_mod256(step, EXPONENT)
+    return step_exp * SCALING_FACTOR // TICK_SIZE
+
+@internal
+def _increment_step():
+    """
+    Increments the current step by 1
+    """
+    self.current_step += 1
+
+@internal
+def _decrement_step():
+    """
+    Decrements the current step by 1
+    """
+    self.current_step -= 1
+
+@internal
+def _set_step(step: uint256):
+    """
+    Sets the current step to a given value
+    """
+    self.current_step = step

vyper_language_server-0.2.2/examples/BondingCurveUser.vy

@@ -0,0 +1,27 @@
+#pragma version ^0.4.0
+
+import BondingCurve
+
+initializes: BondingCurve
+
+x: uint256
+
+s: constant(uint256) = 10**18
+
+event Transfer:
+    foo: address
+    bar: uint256
+
+flag Foo:
+    BAR
+    BAZ
+
+struct FooStruct:
+    foo: uint256
+    bar: uint256
+
+@deploy
+def __init__(shares_name: String[25], shares_symbol: String[5], shares_decimals: uint8):
+    foo: Foo = Foo.BAR
+    foo_s: FooStruct = FooStruct(foo=1, bar=2)
+    BondingCurve.__init__(0, 2, 10**18, 16000)

vyper_language_server-0.2.2/examples/Foo.vy

@@ -0,0 +1,64 @@
+#pragma version ^0.4.0
+
+event Foo:
+    arg1: uint256
+    arg2: address
+
+struct Bar:
+    x: uint256
+
+flag Roles:
+    ADMIN
+    USER
+
+m: Bar
+n: Roles
+
+FEE: constant(uint256) = 100
+
+@deploy
+def __init__():
+    y: uint256 = 100_000_100
+    x: uint256 = FEE
+    z: Bar = Bar(x=y)
+    m: Roles = Roles.ADMIN
+    log Foo(1, msg.sender)
+    n: Roles = Roles.USER
+    self.m = z
+    self.n = n
+    a: address = empty(address)
+    self.m.x = 1
+    log Foo(1, msg.sender)
+    log Foo(1, msg.sender)
+
+@external
+def foo() -> uint256:
+    return self.bar(10, 12)[0]
+
+x: uint256
+
+@internal
+def bar(x: uint256, y: uint256) -> uint256[2]:
+    return [self.x + x + y, x]
+
+@external
+def baz(a: uint256, b: uint256) -> Bar:
+    return self.m
+
+_owner: address
+
+interface Ownable:
+    # get address of owner
+    def owner() -> address: view
+
+implements: Ownable
+
+@view
+@external
+def owner() -> address:
+    return self._owner
+
+N_COINS: constant(uint256) = 2
+A_MULTIPLIER: constant(uint256) = 10000
+
+MIN_A: constant(uint256) = N_COINS**N_COINS * A_MULTIPLIER // 10