livery-extensions-basedpyright 0.0.0__tar.gz

livery_extensions_basedpyright-0.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Willem Kokke
+
+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.

livery_extensions_basedpyright-0.0.0/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: livery-extensions-basedpyright
+Version: 0.0.0
+Summary: basedpyright as a check of the livery workshop: the type checker, and type completeness as its option.
+Author: Willem Kokke
+Author-email: Willem Kokke <mail@willem.net>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Typing :: Typed
+Requires-Dist: livery-toolroom>=0.10.0
+Requires-Dist: livery-workshop>=0.6.0
+Requires-Python: >=3.11
+Project-URL: Repository, https://github.com/willemkokke/livery
+Description-Content-Type: text/markdown
+
+<!-- Seeded from the package-python seeds at
+     birth; this file is the workspace's own. Edit it directly:
+     nothing rewrites it.
+-->
+# livery-extensions-basedpyright
+
+basedpyright as a check of the livery workshop. Listed as `basedpyright` in
+a workspace's `[workspace] extensions`, it registers `typecheck.basedpyright`
+and writes the root `pyrightconfig.json` the check and the editor read;
+listed as `basedpyright[typecomplete]`, it also registers
+`typecomplete.basedpyright`.

livery_extensions_basedpyright-0.0.0/README.md

@@ -0,0 +1,11 @@
+<!-- Seeded from the package-python seeds at
+     birth; this file is the workspace's own. Edit it directly:
+     nothing rewrites it.
+-->
+# livery-extensions-basedpyright
+
+basedpyright as a check of the livery workshop. Listed as `basedpyright` in
+a workspace's `[workspace] extensions`, it registers `typecheck.basedpyright`
+and writes the root `pyrightconfig.json` the check and the editor read;
+listed as `basedpyright[typecomplete]`, it also registers
+`typecomplete.basedpyright`.

livery_extensions_basedpyright-0.0.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["uv_build>=0.11,<0.13"]
+build-backend = "uv_build"
+
+[project]
+name = "livery-extensions-basedpyright"
+version = "0.0.0"
+description = "basedpyright as a check of the livery workshop: the type checker, and type completeness as its option."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Typing :: Typed",
+]
+dependencies = [
+    "livery-toolroom>=0.10.0",
+    "livery-workshop>=0.6.0",
+]
+
+[[project.authors]]
+name = "Willem Kokke"
+email = "mail@willem.net"
+
+[project.urls]
+Repository = "https://github.com/willemkokke/livery"
+
+[project.entry-points."workshop.extensions"]
+basedpyright = "livery.extensions.basedpyright"
+
+[tool.uv.build-backend]
+module-name = "livery.extensions.basedpyright"
+namespace = true

livery_extensions_basedpyright-0.0.0/pyproject.toml.orig

@@ -0,0 +1,43 @@
+# Seeded from the package-python seeds at
+# birth; this file is the workspace's own. Edit it directly:
+# nothing rewrites it.
+[build-system]
+requires = ["uv_build>=0.11,<0.13"]
+build-backend = "uv_build"
+
+[project]
+name = "livery-extensions-basedpyright"
+version = "0.0.0"
+description = "basedpyright as a check of the livery workshop: the type checker, and type completeness as its option."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+authors = [{ name = "Willem Kokke", email = "mail@willem.net" }]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Typing :: Typed",
+]
+
+dependencies = [
+    "livery-toolroom>=0.10.0",
+    "livery-workshop>=0.6.0",
+]
+
+[project.urls]
+Repository = "https://github.com/willemkokke/livery"
+
+# The name a workspace lists in [workspace] extensions, and the package
+# whose extension.toml the workshop mounts it from. Nothing else: the
+# extension adds no verb of its own, and nothing activates by being
+# installed.
+[project.entry-points."workshop.extensions"]
+basedpyright = "livery.extensions.basedpyright"
+
+[tool.uv.build-backend]
+# PEP 420 namespace: the importable package is livery.extensions.basedpyright and
+# there is no livery/__init__.py anywhere in this repository.
+module-name = "livery.extensions.basedpyright"
+namespace = true

livery_extensions_basedpyright-0.0.0/src/livery/extensions/basedpyright/_checks.py

@@ -0,0 +1,69 @@
+"""basedpyright's two checks: the type checker, and type completeness as its option.
+
+The extension's ``extension.toml`` declares both and names the bodies
+here. ``typecheck.basedpyright`` narrows by paths: the workshop names the
+paths a run reaches ([livery.workshop.scoped_paths][]) and splits
+them into calls ([livery.workshop.run_batched][]). A run that
+reaches the whole calls basedpyright with no path, since basedpyright
+reads ``.`` as every file under the root and ignores the configured
+``include`` then. ``typecomplete.basedpyright`` narrows by packages
+([livery.workshop.scoped_packages][]) and verifies the modules each
+one declares public ([livery.workshop.public_modules][]); it
+registers only when the workspace lists ``basedpyright[typecomplete]``.
+Each check hands basedpyright the words after ``--`` on its own verb
+(``fm typecheck.basedpyright -- --level error``). A body resolves its
+runner on this module when it runs, so a test that replaces
+`run_typecheck` or `run_typecomplete` here sees its replacement called.
+"""
+
+from __future__ import annotations
+
+from functools import partial
+
+import livery.toolroom.tools as tools
+from livery.workshop import (
+    WHOLE,
+    GateContext,
+    public_modules,
+    run_batched,
+    scoped_packages,
+    scoped_paths,
+)
+
+
+def run_typecheck(paths: tuple[str, ...] = (), arguments: tuple[str, ...] = ()) -> None:
+    """Type-check *paths* with basedpyright, its warnings gating as errors.
+
+    No path checks the configured whole: what ``pyrightconfig.json``
+    includes, less what it excludes. *arguments* go to basedpyright
+    before the paths.
+    """
+    tools.basedpyright(*arguments, *paths, warnings=True)
+
+
+def run_typecomplete(modules: tuple[str, ...], arguments: tuple[str, ...] = ()) -> None:
+    """Verify that each of *modules* is 100% type-complete.
+
+    Every public symbol needs a fully known type; the exit code is the
+    verdict. The verifier reads the ``py.typed`` at the distribution's
+    root and follows what a module declares public, so a public package
+    a root's ``__init__`` declares is verified through it.
+    *arguments* go to basedpyright in each module's call.
+    """
+    for module in modules:
+        tools.basedpyright(*arguments, verifytypes=module, ignoreexternal=True)
+
+
+def judge_typecheck(ctx: GateContext) -> None:
+    """Type-check the paths the run reaches, or the configured whole."""
+    chosen = scoped_paths(ctx, "typecheck.basedpyright")
+    if chosen == WHOLE:
+        run_typecheck(arguments=ctx.arguments)
+        return
+    run_batched(chosen, partial(run_typecheck, arguments=ctx.arguments))
+
+
+def judge_typecomplete(ctx: GateContext) -> None:
+    """Verify the public modules of each package the run reaches."""
+    for package in scoped_packages(ctx, "typecomplete.basedpyright"):
+        run_typecomplete(public_modules(package), ctx.arguments)

livery_extensions_basedpyright-0.0.0/src/livery/extensions/basedpyright/_docs/index.md

@@ -0,0 +1,75 @@
+<!-- Seeded from the package-base seeds at
+     birth; this file is the workspace's own. Edit it directly:
+     nothing rewrites it.
+-->
+# livery-extensions-basedpyright
+
+basedpyright as a check of the workshop: `typecheck.basedpyright`
+type-checks the python files a run reaches, its warnings gating as errors.
+A workspace turns it on by listing the extension:
+
+```toml
+[workspace]
+extensions = ["basedpyright"]
+```
+
+`fm typecheck` then runs it, and `fm check` runs it with the rest of the
+gate. It reads the files its claims reach in the python packages: their
+sources, tests and test support. A run that reaches every package checks
+what the configuration includes, the root's `tasks.py` and tests among it;
+a run that reaches some checks their `src` and `tests` directories.
+`fm typecheck.basedpyright -- --level error` hands basedpyright the words
+after `--`.
+
+## Type completeness
+
+Listed with its option, the extension also registers
+`typecomplete.basedpyright`:
+
+```toml
+[workspace]
+extensions = ["basedpyright[typecomplete]"]
+```
+
+It verifies that each package's public API has a fully known type, through
+`basedpyright --verifytypes`. A package's public API is what its roots
+declare: a root that is a regular package declares it in its `__init__`,
+its public packages too (imported under `TYPE_CHECKING` and listed in
+`__all__`). A namespace root, one with no `__init__`, has nothing public
+and verifies nothing. The verifier reads the `py.typed` at the
+distribution's root.
+
+A package turns either check off in its own contract:
+
+```toml
+[checks.basedpyright.typecomplete]
+enabled = false
+```
+
+## The configuration
+
+`fm sync` writes the root `pyrightconfig.json`, and a bare `basedpyright`
+in the repository, and the editor's language server, read the same file
+the check does. It names what the whole includes and excludes, the
+environment in `.venv`, the stubs in `typings/`, the python version the
+workspace supports, and the checking mode.
+
+The file is the extension's: an edit outside its region is drift, which
+`fm check --fix` puts back. The repository's own settings go inside the
+region at the end, each line ending with a comma. A key set there wins
+over the same key above it, since basedpyright reads the last one:
+
+```json
+  // -- workshop: region settings, yours to edit; the render keeps it --
+  "executionEnvironments": [
+    { "root": "packages/acme/tests", "reportPrivateImportUsage": false },
+  ],
+  // -- workshop: end settings --
+```
+
+A workspace that lists the extension recommends basedpyright's editor
+extension, `detachhead.basedpyright`, in `.vscode/extensions.json`, and
+turns the editor's default python language server off in
+`.vscode/settings.json` (`"python.languageServer": "None"`): the type
+checker that answers in the editor is the one this file configures, and
+no second one answers with settings of its own.

livery_extensions_basedpyright-0.0.0/src/livery/extensions/basedpyright/_docs/nav.toml

@@ -0,0 +1,12 @@
+# This package's section of the workspace site, hand-authored.
+# Labels map to pages relative to this docs/ tree, or to nested
+# lists. Every authored page must appear here, and every entry must
+# name a real page. A generator owns a block between `# nav:begin
+# <name>` and `# nav:end <name>` markers (tasks, tools); the emitter's
+# own sections, changelog, coverage and api, are blocks too: place a
+# pair where one belongs, and a section without one lands after the
+# authored entries, changelog and coverage ahead of the tasks block,
+# api last.
+nav = [
+    { "Index" = "index.md" },
+]

livery_extensions_basedpyright-0.0.0/src/livery/extensions/basedpyright/content/root/pyrightconfig.json.jinja

@@ -0,0 +1,29 @@
+{
+  // Written by `{{ prog }} sync` from the basedpyright extension; the
+  // gate keeps it matching. Edit inside the region at the end, which is
+  // the repository's own; an edit anywhere else is drift.
+  "include": [{% if packages %}"packages", {% endif %}{% for path in root_tests %}"{{ path }}", {% endfor %}"tasks.py"],
+  // A conan recipe is conan's input, read by conan's own interpreter
+  // where the conan package lives; the workspace venv never has it, so
+  // the checker that reads the whole tree skips the recipes. The cpp
+  // members are skipped whole: their kind type-checks nothing. A
+  // documentation example is judged for its names by lint and run by
+  // the examples check; it is not typed code.
+  "exclude": [{% for package in native %}"packages/{{ package.dir }}", {% endfor %}"packages/**/conanfile.py", "packages/**/docs/examples"],
+  // The editor and the command line resolve the same environment: the
+  // workspace members are editable installs in .venv, so basedpyright
+  // looks there whatever interpreter the editor has selected.
+  "venvPath": ".",
+  "venv": ".venv",
+  // The tool stubs `{{ runner_prog }} tools.restub` writes; the default
+  // stub path, named so every type checker visibly reads one directory.
+  "stubPath": "typings",
+  "pythonVersion": "{{ python_floor }}",
+  "typeCheckingMode": "standard",
+  "reportMissingModuleSource": false,
+  // What the listed extensions contribute.
+{{ contributed_entries }}  // The repository's own settings, each line ending with a comma. A key
+  // set here wins over the same key above: basedpyright reads the last.
+  // -- workshop: region settings, yours to edit; the render keeps it --
+  // -- workshop: end settings --
+}

livery_extensions_basedpyright-0.0.0/src/livery/extensions/basedpyright/extension.toml

@@ -0,0 +1,42 @@
+# The basedpyright extension: the type checker, and type completeness as
+# its option. Read at every mount; a check's code is imported when the
+# check runs.
+
+[extension]
+api-version = 1
+# Listed in the workspace's list alone: one configuration for every member.
+levels = ["workspace"]
+
+# Off unless the workspace lists it, `basedpyright[typecomplete]`.
+[options]
+typecomplete = "verifies that every package's public API is type-complete"
+
+[checks.basedpyright.typecheck]
+run = "livery.extensions.basedpyright._checks:judge_typecheck"
+narrowing = "paths"
+kinds = ["python"]
+tools = ["basedpyright"]
+arguments = true
+editor-extension = "detachhead.basedpyright"
+claims = [
+    { category = "source", suffixes = [".py", ".pyi"] },
+    { category = "test", suffixes = [".py", ".pyi"] },
+    { category = "test-support", suffixes = [".py", ".pyi"] },
+]
+
+# The type checker that answers in the editor is the one this workspace
+# configures: the editor's default python language server is off, so it
+# adds no second verdict with settings of its own.
+[checks.basedpyright.typecheck.fragments]
+".vscode/settings.json" = '''
+{"python.languageServer": "None"}
+'''
+
+[checks.basedpyright.typecomplete]
+run = "livery.extensions.basedpyright._checks:judge_typecomplete"
+narrowing = "packages"
+kinds = ["python"]
+tools = ["basedpyright"]
+arguments = true
+listed-with = "typecomplete"
+claims = [{ category = "source", suffixes = [".py", ".pyi"] }]