lispython 0.4.7__tar.gz → 0.5.0__tar.gz

lispython-0.5.0/.githooks/post-checkout

@@ -0,0 +1,119 @@
+#!/bin/sh
+#
+# post-checkout — provision shared gitignored files into a fresh worktree.
+#
+# ⚠️ CANONICAL BODY — DO NOT EDIT BELOW THE CONFIG BLOCK.
+# This file is copied verbatim from
+#   ~/vault/Vault/Projects/dotagents/guidelines/templates/post-checkout
+# and the ONLY per-project variance is LINK_FILES / COPY_FILES. Nine hand-written
+# copies had already drifted by 17-29 lines of logic — including two that lost the
+# broken-symlink source check and the SQL escaping below — which is why the body
+# is now one artifact. Fix a bug in the template, then re-copy.
+#
+# `git worktree add` runs a checkout in the new worktree, which fires this hook
+# with the new worktree as cwd. That is what populates files git does not track,
+# so a worktree is ready to build and run without manual copying.
+#
+#   - env/secret files and agent docs are SYMLINKED back to the main checkout:
+#     they stay in sync, and symlinking a secret never reads its contents.
+#     ⚠️ NEVER copy an env file — a copy drifts and duplicates the secret.
+#   - the SQLite db is COPIED as an independent snapshot, so a schema migration
+#     run inside the worktree can never corrupt the main checkout's database.
+#
+# Idempotent: only provisions files that are missing, so it is safe to re-run
+# and safe to fire on ordinary `git checkout` / `git switch`.
+#
+# Tracked in .githooks/ and activated per-clone (this pointer is local, not
+# committed):
+#   git config core.hooksPath .githooks
+# Run `git worktree add` from a checkout root so the relative path resolves.
+
+# ==== PROJECT CONFIG — the only part that varies ==========================
+
+# SYMLINK: files that should track the main checkout. Agent docs are themselves
+# symlinks into the vault; linking the link is fine and keeps one source.
+#
+# ⚠️ Keep this list NARROW. Never link node_modules, build output or a whole data
+# dir — those confuse build tools, watchers and cleanup. A large READ-ONLY data
+# dir is the one defensible exception (vocadict links its dictionary shards);
+# document it in that project's AGENTS.md.
+LINK_FILES="
+AGENTS.md
+CLAUDE.md
+GEMINI.md
+"
+
+# COPY: anything the worktree may mutate irreversibly — the dev/staging db above
+# all, so a migration tried in a worktree cannot reach the database the main
+# checkout serves. Empty is valid (a Supabase-backed project has no local db).
+COPY_FILES="
+"
+
+# ==== CANONICAL BODY — do not edit per project ============================
+
+# $3 is the checkout flag: 1 = branch checkout (incl. worktree add), 0 = file.
+# Only act on branch checkouts.
+[ "$3" = "1" ] || exit 0
+
+# Resolve this worktree's gitdir and the shared common gitdir.
+wt_gitdir=$(git rev-parse --absolute-git-dir 2>/dev/null) || exit 0
+common_gitdir=$(cd "$(git rev-parse --git-common-dir 2>/dev/null)" 2>/dev/null && pwd) || exit 0
+
+# In the MAIN checkout these are equal — nothing to provision, bail out.
+[ "$wt_gitdir" = "$common_gitdir" ] && exit 0
+
+# Main checkout top-level is the parent of the common gitdir (<main>/.git).
+main_top=$(dirname "$common_gitdir")
+wt_top=$(git rev-parse --show-toplevel 2>/dev/null) || exit 0
+
+linked=""
+for rel in $LINK_FILES; do
+	src="$main_top/$rel"
+	dst="$wt_top/$rel"
+	# Skip if the source is missing or the destination already exists.
+	[ -e "$src" ] || [ -L "$src" ] || continue
+	{ [ -e "$dst" ] || [ -L "$dst" ]; } && continue
+	mkdir -p "$(dirname "$dst")"
+	ln -s "$src" "$dst" && linked="$linked $rel"
+done
+
+copied=""
+for rel in $COPY_FILES; do
+	src="$main_top/$rel"
+	dst="$wt_top/$rel"
+	[ -e "$src" ] || continue
+	{ [ -e "$dst" ] || [ -L "$dst" ]; } && continue
+	mkdir -p "$(dirname "$dst")"
+	case "$rel" in
+	*.db)
+		# WAL-mode dbs keep committed data in the -wal file until checkpoint,
+		# and a live `serve` process may be mid-write. VACUUM INTO writes a
+		# consistent standalone snapshot (WAL-committed data included) into a
+		# fresh file; fall back to cp if the sqlite3 CLI is unavailable. $dst is
+		# SQL-string-escaped so a worktree path with quotes/spaces stays safe.
+		# Safe because this branch only runs when $dst does not yet exist.
+		if command -v sqlite3 >/dev/null 2>&1; then
+			dst_sql=$(printf '%s' "$dst" | sed "s/'/''/g")
+			sqlite3 "$src" "VACUUM INTO '$dst_sql'" && copied="$copied $rel"
+		else
+			echo "post-checkout: sqlite3 missing; falling back to cp for $rel (may be inconsistent if db is being written)" >&2
+			cp -p "$src" "$dst" && copied="$copied $rel"
+		fi
+		;;
+	*)
+		cp -p "$src" "$dst" && copied="$copied $rel"
+		;;
+	esac
+done
+
+[ -n "$linked" ] && echo "post-checkout: linked shared files:$linked"
+[ -n "$copied" ] && echo "post-checkout: copied isolated files:$copied"
+
+# Optional per-project extension, so a genuine project-specific need never
+# becomes a reason to fork the body above. Runs with $wt_top / $main_top set and
+# provisioning already done — the place for a sanity check ON what was
+# provisioned (fridge warns when the copied db has zero rounds, which is
+# otherwise a silent empty-dev-db). Keep it to that; anything general belongs in
+# the template.
+[ -f "$wt_top/.githooks/post-checkout.project" ] && . "$wt_top/.githooks/post-checkout.project"
+exit 0

{lispython-0.4.7 → lispython-0.5.0}/.gitignore

@@ -328,6 +328,9 @@ AGENTS.md
 CLAUDE.md
 GEMINI.md
 
+# nREPL port file (written by `lpy --nrepl`)
+.nrepl-port
+
 # Git worktrees
 .worktrees/
 
@@ -335,3 +338,4 @@ GEMINI.md
 docs/superpowers/.stacks
 .agents
 .claude
+.agent

lispython-0.5.0/CHANGELOG.md

@@ -0,0 +1,83 @@
+# Changelog
+
+All notable changes to lispython are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project
+follows [Semantic Versioning](https://semver.org/).
+
+## [0.5.0]
+
+### Added
+
+- Python 3.11 through 3.15 support, with each newer AST form gated on the
+  running interpreter and a clear compile error on older ones. A `nox` matrix
+  (`uvx nox -s tests`) runs the suite on every supported version.
+- Type aliases: `(type NAME value)` compiles to a `type NAME = value`
+  statement (3.12+). The three-operand `(type name bases ns)` call is unchanged.
+- Generic definitions: `def`, `async def` and `class` names accept glued type
+  parameters such as `f[T]`, including `ParamSpec`, `TypeVarTuple` and
+  defaults (parameters 3.12+, defaults 3.13+).
+- t-strings compile to `TemplateStr` (3.14+).
+- `lazy-import` and `lazy-from` (3.15+).
+- Comprehension unpacking (3.15+), including `{**d for d dicts}`, which was
+  mistranslated as a dict display; unary plus is gated to 3.15+.
+- Errors the CPython compiler raises on `.lpy` modules, and lispython's own
+  compile errors, are reported with the file, line and caret instead of a
+  traceback by `lpy` (file, `-m`, `-c`), `l2py`, the REPL and nREPL eval.
+- LSP: `textDocument/signatureHelp` and `workspace/symbol`; `(type NAME ...)`
+  aliases are indexed as definitions.
+- nREPL: completion responses carry type kinds, and the server writes
+  `.nrepl-port` in the working directory for editor auto-discovery.
+
+### Changed
+
+- **The REPL and nREPL compile every statement of an input before running any
+  of it**, and `lpy -c` compiles its whole input first. A compile error,
+  lispython's or CPython's, now stops the input before any statement runs
+  (macro expansion still happens first); a `SyntaxError` the program raises
+  at run time keeps its own traceback.
+- **Stricter parsing** rejects input that used to be accepted silently: an
+  unclosed final form or mismatched closing bracket, an unterminated string,
+  an f-string field holding more than one form, a lone `}` in an f-string,
+  non-symbol macro names (`(defmacro m[T] ...)`), `(import "x")`,
+  `(lazy-import "numpy")`, `(return a b)`, and `name[...]` glued under a
+  prefix such as `^list[int]` in a parameter list. Malformed literals such as
+  `09` or `\x4` are reported at their token.
+- **Literal values**: `-1+2j` is now `(-1+2j)` rather than `-(1+2j)`; `\r\n`
+  and lone `\r` become `\n` in f-strings too; a multi-line raw string no
+  longer gains a literal `\n`; backslash-newline continues a string; a lone
+  `"` inside `"""..."""` no longer ends the token.
+- **F-strings follow Python's rules.** An uppercase `F` prefix (and `rf`,
+  `fR`, ...) is a real f-string rather than being evaluated at compile time,
+  `{x=}` echoes the expression text and defaults to `!r`, and format specs
+  may nest replacement fields (`{x:>{w}.{p}}`). Unquotes expand inside
+  f-string and t-string fields.
+- **`(require mod [])` registers no macros**, like an empty import list; only
+  an absent list (`(require mod)`) registers all of them. The LSP follows the
+  same rule in go-to-definition and hover.
+- `lpy -m` puts the current directory on `sys.path` like `python -m`,
+  honouring `PYTHONSAFEPATH`.
+- Requires `pygls` 2.0 or later.
+
+### Fixed
+
+- `(return [])` compiled to a bare `return` (yielding `None`); it now returns
+  the empty list.
+- `(case {})` accepts an empty mapping pattern.
+- Signed literal match patterns: `(case -1 ...)` compiled to `case _(1):`.
+- `(from . [a])` compiles; it raised `IndexError`.
+- Quasiquoted f/t-string fields keep their conversion, spec and `=` text
+  (`f"{x!r:>6}"` used to come back as `{x}`), and `f"{~x}"` with a literal
+  macro argument no longer crashes.
+- `l2py` emits valid Python for t-string interpolations.
+- A lone starred subscript slice compiles to a one-element `Tuple`, like
+  Python's `t[*s]`.
+- LSP: workspace symbols no longer include installed packages or function
+  locals, and report their real kinds; a buffer that is mid-edit keeps
+  working; signature help is not offered inside a quoted form.
+- nREPL: completion kinds treat scope bindings as shadowing builtins, never
+  run user code to classify attributes, and report callables as functions;
+  an unwritable `.nrepl-port` no longer stops the server.
+
+## [0.4.7]
+
+See the `v0.4.7` tag.

{lispython-0.4.7 → lispython-0.5.0}/PKG-INFO

@@ -1,15 +1,22 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: lispython
-Version: 0.4.7
+Version: 0.5.0
 Summary: Lisp-like Syntax for Python with Lisp-like Macros
 Project-URL: Homepage, https://jetack.github.io/lispython
 Project-URL: Repository, https://github.com/jetack/lispython
 Author-email: Jetack <jetack23@gmail.com>
 License: MIT
 License-File: LICENSE.md
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Requires-Python: >=3.11
 Requires-Dist: prompt-toolkit>=3.0.52
-Requires-Dist: pygls>=1.0.0
+Requires-Dist: pygls>=2.0
 Provides-Extra: dev
 Requires-Dist: pre-commit>=3.6.0; extra == 'dev'
 Requires-Dist: pytest>=8.0.0; extra == 'dev'
@@ -87,7 +94,8 @@ LisPython ships with a language server (`lpy-lsp`) that speaks LSP over stdio. I
 - Diagnostics (parse / compile errors)
 - Completions (special forms, builtins, file/workspace symbols)
 - Hover documentation for special forms and builtins
-- Document symbols
+- Signature help for special forms and builtins
+- Document symbols and workspace symbol search
 - Go-to-definition, including across `.lpy` files in the workspace
 
 ## nREPL Server
@@ -98,11 +106,13 @@ lpy --nrepl         # start on a random port
 lpy --nrepl 7888    # start on a specific port
 ```
 
+While running, the server writes its port to `.nrepl-port` in the working directory for editor auto-discovery.
+
 The server accepts newline-delimited JSON over TCP and supports:
 - `eval` — evaluate LisPython code, return value/stdout/error
 - `load-file` — load a `.lpy` file into the session
 - `macroexpand` — expand macros and return the result
-- `complete` — prefix and dot-completion from the live scope
+- `complete` — prefix and dot-completion from the live scope, with a `kinds` map (class/function/variable/macro/keyword)
 - `docs` — signature and docstring for a symbol
 - `annotate` — type tag (function/class/module/macro)
 
@@ -113,8 +123,3 @@ Install the [LisPython](https://marketplace.visualstudio.com/items?itemName=jeta
 
 #### Emacs
 Use [`lpy-mode`](https://github.com/jetack/lpy-mode). It provides nREPL integration (eval, completion, eldoc, macroexpand) and LSP via eglot.
-
-## Todo
-### Python AST
-- [ ] `type_comment` never considered. Later, it should be covered
-- [ ] Any missing AST nodes in the version 3.12+

{lispython-0.4.7 → lispython-0.5.0}/README.md

@@ -64,7 +64,8 @@ LisPython ships with a language server (`lpy-lsp`) that speaks LSP over stdio. I
 - Diagnostics (parse / compile errors)
 - Completions (special forms, builtins, file/workspace symbols)
 - Hover documentation for special forms and builtins
-- Document symbols
+- Signature help for special forms and builtins
+- Document symbols and workspace symbol search
 - Go-to-definition, including across `.lpy` files in the workspace
 
 ## nREPL Server
@@ -75,11 +76,13 @@ lpy --nrepl         # start on a random port
 lpy --nrepl 7888    # start on a specific port
 ```
 
+While running, the server writes its port to `.nrepl-port` in the working directory for editor auto-discovery.
+
 The server accepts newline-delimited JSON over TCP and supports:
 - `eval` — evaluate LisPython code, return value/stdout/error
 - `load-file` — load a `.lpy` file into the session
 - `macroexpand` — expand macros and return the result
-- `complete` — prefix and dot-completion from the live scope
+- `complete` — prefix and dot-completion from the live scope, with a `kinds` map (class/function/variable/macro/keyword)
 - `docs` — signature and docstring for a symbol
 - `annotate` — type tag (function/class/module/macro)
 
@@ -90,8 +93,3 @@ Install the [LisPython](https://marketplace.visualstudio.com/items?itemName=jeta
 
 #### Emacs
 Use [`lpy-mode`](https://github.com/jetack/lpy-mode). It provides nREPL integration (eval, completion, eldoc, macroexpand) and LSP via eglot.
-
-## Todo
-### Python AST
-- [ ] `type_comment` never considered. Later, it should be covered
-- [ ] Any missing AST nodes in the version 3.12+

{lispython-0.4.7 → lispython-0.5.0}/docs/syntax/expressions.md

@@ -151,6 +151,26 @@ Python version
 ```python
 (2 * x for x in range(10) if x % 2 == 0)
 ```
+### Comprehension Unpacking
+Python 3.15+ ([PEP 798](https://peps.python.org/pep-0798/)). On an older Python
+these forms are a compile error naming the version they need.
+
+LisPy version
+```python
+[*L for L in lists]
+(*L for L in lists)
+{, *s for s in sets}
+{**d for d in dicts}
+[*L async-for L in lists]
+```
+Python version
+```python
+[*L for L in lists]
+(*L for L in lists)
+{*s for s in sets}
+{**d for d in dicts}
+[*L async for L in lists]
+```
 
 ## `await`
 LisPy version
@@ -199,6 +219,34 @@ Python version
 name = "World"
 f"Hello, {2 * name}!"
 ```
+Replacement fields follow Python's rules: `{{`/`}}` are literal braces,
+`!r`/`!s`/`!a` conversions, format specs with nested fields, and `{x=}`.
+LisPy version
+```python
+f"{{literal}} {x!r:>{width}} {x=}"
+```
+Python version
+```python
+f"{{literal}} {x!r:>{width}} {x=}"
+```
+
+## Template String Literals
+Python 3.14+ ([PEP 750](https://peps.python.org/pep-0750/)). The `t` prefix
+combines with `r` like `f` does (`rt"..."`, `Tr"..."`) and builds a
+`string.templatelib.Template`. Each interpolation's `expression` is the LisPy
+text inside the braces. On an older Python a t-string is a compile error naming
+the version it needs.
+
+LisPy version
+```python
+(= name "World")
+t"Hello, {(* 2 name)!r:>12}!"
+```
+Python version
+```python
+name = "World"
+t"Hello, {2 * name!r:>12}!"  # interpolations[0].expression == "(* 2 name)"
+```
 
 ## Attribute
 LisPy version

{lispython-0.4.7 → lispython-0.5.0}/docs/syntax/statements.md

@@ -42,6 +42,62 @@ class class_name(base_class1, base_class2):
     body
 ```
 
+## Generic Functions and Classes
+Python 3.12+ ([PEP 695](https://peps.python.org/pep-0695/)); defaults need
+Python 3.13+ ([PEP 696](https://peps.python.org/pep-0696/)). Write the type
+parameters glued to the name, with no space: `f[T]` is a generic name, while
+`f [T]` is a name followed by a list. The bracket uses the argument markers of
+`def`: `^` for a bound (a tuple bound is a constraint list), `*` for a
+TypeVarTuple, `**` for a ParamSpec and `:` for a default. On an older Python
+these forms are a compile error naming the version they need.
+
+A glued name is only valid as the name of `def`, `async-def`, `class` and
+`type`; to subscript, use `(sub xs ...)`.
+
+LisPy version
+```python
+(def first[T] [xs ^(sub list T)] ^T
+  (return (sub xs 0)))
+
+(class Box[T ^(, int str) *Ts **P] [Base]
+  (pass))
+
+(def f[:T str :U ^int bool :*Ts *(sub tuple int) :**P [int str]] []  ; Python 3.13+
+  (pass))
+```
+Python version
+```python
+def first[T](xs: list[T]) -> T:
+    return xs[0]
+
+class Box[T: (int, str), *Ts, **P](Base):
+    pass
+
+def f[T = str, U: int = bool, *Ts = *tuple[int], **P = [int, str]]():  # Python 3.13+
+    pass
+```
+
+## Type Alias
+Python 3.12+ ([PEP 695](https://peps.python.org/pep-0695/)). As in Python,
+`type` is a soft keyword: `(type NAME value)` and `(type NAME[T ...] value)`
+are a type alias only as a statement with exactly two operands whose first is a
+plain name. Every other shape is a call to the builtin `type`, so
+`(= t (type x))` and `(type "N" (, object) {})` are unchanged. If you rebind
+`type` and need a bare two-argument call as a statement, write
+`(= _ (type a b))`. On an older Python the alias is a compile error naming the
+version it needs.
+
+LisPy version
+```python
+(type Number (| int float))
+(type Vec[T] (sub list T))
+```
+Python version
+```python
+type Number = int | float
+type Vec[T] = list[T]
+```
+
 ## `del`
 LisPy version
 ```python
@@ -277,6 +333,34 @@ match x:
     case [x] | y:
         ...
 ```
+### Signed Literal Patterns
+A negative number or a complex literal is a value pattern. A leading `+` needs
+Python 3.15+; on an older Python it is a compile error naming the version.
+
+LisPy version
+```python
+(match x
+  (case -1
+    ...)
+  (case -1-2j
+    ...)
+  (case {-1 _}
+    ...)
+  (case +1  ; Python 3.15+
+    ...))
+```
+Python version
+```python
+match x:
+    case -1:
+        ...
+    case -1 - 2j:
+        ...
+    case {-1: _}:
+        ...
+    case +1:  # Python 3.15+
+        ...
+```
 
 ## `raise`
 LisPy version
@@ -391,6 +475,26 @@ from module import name1
 from module import name2 as alias
 from module import name3
 ```
+### Lazy imports
+Python 3.15+ ([PEP 810](https://peps.python.org/pep-0810/)). `lazy-import` and
+`lazy-from` take the same arguments as `import` and `from`; the module is
+loaded when a name is first used. As in Python, `lazy-from` refuses `*` and
+`__future__`, and a lazy import is not allowed inside a function, a class or a
+`try` block. On an older Python these forms are a compile error naming the
+version they need.
+
+LisPy version
+```python
+(lazy-import json)
+(lazy-import numpy as np)
+(lazy-from json [dumps loads as load-json])
+```
+Python version
+```python
+lazy import json
+lazy import numpy as np
+lazy from json import dumps, loads as load_json
+```
 
 ## `global`
 LisPy version

lispython-0.5.0/noxfile.py

@@ -0,0 +1,13 @@
+"""Test matrix over every maintained CPython: ``uvx nox -s tests``."""
+
+import nox
+
+nox.options.default_venv_backend = "uv"
+
+PYTHONS = ["3.11", "3.12", "3.13", "3.14", "3.15"]
+
+
+@nox.session(python=PYTHONS)
+def tests(session):
+    session.install(".", "pytest")
+    session.run("pytest", *session.posargs)

{lispython-0.4.7 → lispython-0.5.0}/pyproject.toml

@@ -1,14 +1,23 @@
 [project]
 name = "lispython"
-version = "0.4.7"
+version = "0.5.0"
 description = "Lisp-like Syntax for Python with Lisp-like Macros"
 authors = [{ name = "Jetack", email = "jetack23@gmail.com" }]
 license = { text = "MIT" }
 readme = "README.md"
 requires-python = ">=3.11"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
+]
 dependencies = [
     "prompt-toolkit>=3.0.52",
-    "pygls>=1.0.0",
+    "pygls>=2.0",
 ]
 
 [project.urls]
@@ -44,6 +53,13 @@ packages = ["src/lispy"]
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 python_files = ["test_*.py"]
+# AST constructor misuse (unknown keywords, missing fields) warns on 3.13/3.14
+# and is a TypeError from 3.15: fail the suite on the warning.
+filterwarnings = [
+    "error::DeprecationWarning",
+    # pygls (third-party) calls asyncio.iscoroutinefunction, deprecated in 3.14.
+    "ignore:'asyncio.iscoroutinefunction' is deprecated:DeprecationWarning",
+]
 
 [tool.ruff]
 line-length = 88