paranoid-atlas-cli 0.1.1__tar.gz

paranoid_atlas_cli-0.1.1/.github/workflows/publish-pypi.yml

@@ -0,0 +1,43 @@
+name: Publish paranoid-atlas-cli to PyPI
+
+on:
+  push:
+    tags:
+      - "v*"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Check the tag matches the package version
+        if: startsWith(github.ref, 'refs/tags/v')
+        run: |
+          version=$(python -c "import tomllib; print(tomllib.load(open('pyproject.toml', 'rb'))['project']['version'])")
+          if [ "v$version" != "$GITHUB_REF_NAME" ]; then
+            echo "Tag $GITHUB_REF_NAME does not match pyproject.toml version $version"
+            exit 1
+          fi
+
+      - name: Build
+        run: |
+          python -m pip install --upgrade pip build twine
+          python -m build
+          twine check dist/*
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          username: __token__
+          password: ${{ secrets.PYPI_API_TOKEN }}

paranoid_atlas_cli-0.1.1/.gitignore

@@ -0,0 +1,5 @@
+.venv/
+__pycache__/
+*.pyc
+dist/
+.pytest_cache/

paranoid_atlas_cli-0.1.1/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.5
+Name: paranoid-atlas-cli
+Version: 0.1.1
+Summary: The Atlas method made executable: create and keep Atlases in order
+Project-URL: Homepage, https://atlas.paranoid.software
+Project-URL: Repository, https://github.com/paranoid-software/atlas-cli
+Project-URL: Issues, https://github.com/paranoid-software/atlas-cli/issues
+Author: Paranoid Software
+License-Expression: MIT
+Keywords: agents,atlas,claude,cli,spec-driven
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# atlas-cli
+
+The [Atlas](https://atlas.paranoid.software) method made executable: create an Atlas and keep
+it in order while several people and agents work in it.
+
+## Install
+
+```bash
+uv tool install paranoid-atlas-cli
+```
+
+## Develop
+
+```bash
+uv sync
+uv run atlas --version
+uv run pytest
+```
+
+## Release
+
+Bump `version` in `pyproject.toml`, commit, then push a matching tag (`v0.1.1` for `0.1.1`):
+the `Publish paranoid-atlas-cli to PyPI` workflow builds and publishes it. A tag that doesn't match the
+version fails the workflow.

paranoid_atlas_cli-0.1.1/README.md

@@ -0,0 +1,24 @@
+# atlas-cli
+
+The [Atlas](https://atlas.paranoid.software) method made executable: create an Atlas and keep
+it in order while several people and agents work in it.
+
+## Install
+
+```bash
+uv tool install paranoid-atlas-cli
+```
+
+## Develop
+
+```bash
+uv sync
+uv run atlas --version
+uv run pytest
+```
+
+## Release
+
+Bump `version` in `pyproject.toml`, commit, then push a matching tag (`v0.1.1` for `0.1.1`):
+the `Publish paranoid-atlas-cli to PyPI` workflow builds and publishes it. A tag that doesn't match the
+version fails the workflow.

paranoid_atlas_cli-0.1.1/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "paranoid-atlas-cli"
+version = "0.1.1"
+description = "The Atlas method made executable: create and keep Atlases in order"
+readme = "README.md"
+requires-python = ">=3.11"
+authors = [
+    { name = "Paranoid Software" },
+]
+license = "MIT"
+keywords = ["atlas", "cli", "agents", "spec-driven", "claude"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Build Tools",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://atlas.paranoid.software"
+Repository = "https://github.com/paranoid-software/atlas-cli"
+Issues = "https://github.com/paranoid-software/atlas-cli/issues"
+
+[project.scripts]
+atlas = "atlas_cli.cli:main"
+
+[dependency-groups]
+dev = ["pytest>=8"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/atlas_cli"]

paranoid_atlas_cli-0.1.1/src/atlas_cli/__init__.py

@@ -0,0 +1,3 @@
+from importlib.metadata import version
+
+__version__ = version("paranoid-atlas-cli")

paranoid_atlas_cli-0.1.1/src/atlas_cli/cli.py

@@ -0,0 +1,29 @@
+import argparse
+import sys
+
+from atlas_cli import __version__
+from atlas_cli.commands import init
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="atlas",
+        description="Create and keep Atlases in order — https://atlas.paranoid.software",
+    )
+    parser.add_argument("--version", action="version", version=f"atlas {__version__}")
+    subparsers = parser.add_subparsers(dest="command", metavar="<command>")
+    init.register(subparsers)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    if args.command is None:
+        parser.print_help()
+        return 0
+    return args.handler(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paranoid_atlas_cli-0.1.1/src/atlas_cli/commands/init.py

@@ -0,0 +1,97 @@
+import argparse
+import json
+from datetime import date
+from importlib.resources import files
+from pathlib import Path
+from string import Template
+
+ATLAS_FILES = {
+    "CLAUDE.md": "CLAUDE.md",
+    "STATUS.md": "STATUS.md",
+    "BACKLOG.md": "BACKLOG.md",
+    "_archived/README.md": "archived.md",
+    "_settings/atlas.toml": "atlas.toml",
+}
+CLAUDE_SETTINGS = ".claude/settings.local.json"
+VSCODE_SETTINGS = ".vscode/settings.json"
+GITIGNORE = ".gitignore"
+ATLAS_MARKERS = ("_settings/atlas.toml", "CLAUDE.md", "STATUS.md")
+
+
+def register(subparsers) -> None:
+    parser = subparsers.add_parser("init", help="create an Atlas in the current folder, named after it")
+    parser.set_defaults(handler=run)
+
+
+def run(args: argparse.Namespace) -> int:
+    folder = Path.cwd()
+    found = [marker for marker in ATLAS_MARKERS if (folder / marker).exists()]
+    if found:
+        print(f"This folder is already an Atlas (found {', '.join(found)}); nothing was changed.")
+        if "_settings/atlas.toml" not in found:
+            print("It predates _settings/ — bring it up to date with `atlas migrate`.")
+        return 1
+    try:
+        plan = _plan_base_set(folder, date.today())
+    except ValueError as error:
+        print(f"{error}; nothing was changed.")
+        return 1
+    for path, (action, content) in plan.items():
+        if content is not None:
+            _write(folder / path, content)
+        print(f"{action} {path}")
+    if plan[GITIGNORE][0] == "kept":
+        print(f"Check that the existing {GITIGNORE} keeps only the Atlas's own files (see 07-sharing-an-atlas).")
+    print("Next: add each source with `atlas link <name> <path>`.")
+    return 0
+
+
+def _plan_base_set(folder: Path, today: date) -> dict[str, tuple[str, str | None]]:
+    plan = {
+        path: ("created", _render_template(template, name=folder.name, today=today.isoformat()))
+        for path, template in ATLAS_FILES.items()
+    }
+    plan[CLAUDE_SETTINGS] = _plan_json(folder / CLAUDE_SETTINGS, _complete_claude_settings)
+    plan[VSCODE_SETTINGS] = _plan_json(folder / VSCODE_SETTINGS, _complete_vscode_settings)
+    if (folder / GITIGNORE).exists():
+        plan[GITIGNORE] = ("kept", None)
+    else:
+        plan[GITIGNORE] = ("created", _render_template("gitignore"))
+    return plan
+
+
+def _plan_json(target: Path, complete) -> tuple[str, str]:
+    if not target.exists():
+        return "created", _dump_json(complete({}))
+    try:
+        settings = json.loads(target.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as error:
+        raise ValueError(f"Cannot read {target.name} in {target.parent.name}/ ({error.msg})") from error
+    return "updated", _dump_json(complete(settings))
+
+
+def _complete_claude_settings(settings: dict) -> dict:
+    permissions = settings.setdefault("permissions", {})
+    permissions.setdefault("allow", [])
+    permissions.setdefault("additionalDirectories", [])
+    return settings
+
+
+def _complete_vscode_settings(settings: dict) -> dict:
+    settings["git.autoRepositoryDetection"] = True
+    settings.setdefault("git.scanRepositories", [])
+    return settings
+
+
+def _dump_json(settings: dict) -> str:
+    return json.dumps(settings, indent=2, ensure_ascii=False) + "\n"
+
+
+def _render_template(template: str, **values: str) -> str:
+    text = files("atlas_cli.templates").joinpath(template).read_text(encoding="utf-8")
+    return Template(text).safe_substitute(values)
+
+
+def _write(target: Path, content: str) -> None:
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(content, encoding="utf-8", newline="\n")

paranoid_atlas_cli-0.1.1/src/atlas_cli/templates/BACKLOG.md

@@ -0,0 +1,7 @@
+# $name — BACKLOG
+
+The queue: one line per open workitem (`SPEC_*` / `DRAFT_*`) not yet in flight. Index only —
+no bodies, no rules, no decisions.
+
+## Open
+_(empty)_

paranoid_atlas_cli-0.1.1/src/atlas_cli/templates/CLAUDE.md

@@ -0,0 +1,36 @@
+# $name Atlas — agent instructions
+
+This is the **$name Atlas** — the context of the $name project. Project orientation +
+Atlas-specific glue only. Universal rules and behavior live in the memory store; autonomous
+file-memory is off. **Current state & next steps live in [STATUS.md](STATUS.md) — read it
+first.**
+
+---
+
+## 1. What lives here — sources and their purposes
+
+Each source is a symlink; where it lives is up to each machine and is never recorded here.
+
+_(no sources yet — add each one with `atlas link <name> <path>`, then its block below)_
+
+Editing a file under a symlink writes to the source itself. Changes across sources are
+flagged explicitly.
+
+---
+
+## 2. How I work in this Atlas
+- **Before editing, identify the target source** — most changes belong to exactly one;
+  changes across sources are called out explicitly.
+
+---
+
+## 3. $name — product / architecture
+_(no domain conventions yet)_
+
+---
+
+## 5. Conventions we're establishing (Atlas-level, not in the memory store)
+_Rules that apply to this Atlas and that we've decided not (yet) to lift into the memory
+store. Keep it short; promote to the memory store only after a dedicated session, and only
+if they generalize._
+- _(empty — fill in as conventions get decided.)_

paranoid_atlas_cli-0.1.1/src/atlas_cli/templates/STATUS.md

@@ -0,0 +1,15 @@
+# $name — STATUS (living)
+
+Where this project is now. Standing decisions + orientation live in CLAUDE.md; the
+BACKLOG / SPEC_ / _archived artifacts are the record. Refresh with `/atlas-sync`.
+
+_Last updated: ${today}_
+
+## What $name is (one line)
+_(one-line summary)_
+
+## Active
+_(one block per SPEC in progress / in review — rewritten to the current state, never appended)_
+
+## Recently closed
+_(short rolling window — last N — pointing into _archived/; the full history lives there)_

paranoid_atlas_cli-0.1.1/src/atlas_cli/templates/archived.md

@@ -0,0 +1,3 @@
+# _archived
+
+Holds only closed `SPEC_NNNN_<SLUG>.md` files and their `SPEC_NNNN_FINDINGS.md` — the project's history of work.

paranoid_atlas_cli-0.1.1/src/atlas_cli/templates/atlas.toml

@@ -0,0 +1,3 @@
+version = 1
+
+[plugins]

paranoid_atlas_cli-0.1.1/src/atlas_cli/templates/gitignore

@@ -0,0 +1,5 @@
+/*
+!/*.md
+!/_*/
+!/.vscode/
+!/.gitignore

paranoid_atlas_cli-0.1.1/tests/test_askingtheversionshould.py

@@ -0,0 +1,11 @@
+import pytest
+
+from atlas_cli import __version__
+from atlas_cli.cli import main
+
+
+def test_print_the_installed_version(capsys):
+    with pytest.raises(SystemExit) as exit_info:
+        main(["--version"])
+    assert exit_info.value.code == 0
+    assert capsys.readouterr().out.strip() == f"atlas {__version__}"

paranoid_atlas_cli-0.1.1/tests/test_initializinganatlasshould.py

@@ -0,0 +1,182 @@
+import json
+import tomllib
+from datetime import date
+from pathlib import Path
+
+from atlas_cli.cli import main
+
+
+def _files_under(folder: Path) -> set[str]:
+    return {str(path.relative_to(folder)) for path in folder.rglob("*") if path.is_file()}
+
+
+def test_create_the_base_set_and_nothing_else(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+
+    assert main(["init"]) == 0
+
+    assert _files_under(tmp_path) == {
+        "CLAUDE.md",
+        "STATUS.md",
+        "BACKLOG.md",
+        "_archived/README.md",
+        "_settings/atlas.toml",
+        ".claude/settings.local.json",
+        ".vscode/settings.json",
+        ".gitignore",
+    }
+
+
+def test_start_with_no_sources_and_no_plugins(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+
+    main(["init"])
+
+    settings = tomllib.loads((tmp_path / "_settings/atlas.toml").read_text(encoding="utf-8"))
+    assert settings == {"version": 1, "plugins": {}}
+    claude = json.loads((tmp_path / ".claude/settings.local.json").read_text(encoding="utf-8"))
+    assert claude == {"permissions": {"allow": [], "additionalDirectories": []}}
+    vscode = json.loads((tmp_path / ".vscode/settings.json").read_text(encoding="utf-8"))
+    assert vscode == {"git.autoRepositoryDetection": True, "git.scanRepositories": []}
+
+
+def test_ignore_everything_but_the_atlas_files(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+
+    main(["init"])
+
+    assert (tmp_path / ".gitignore").read_text(encoding="utf-8").splitlines() == [
+        "/*",
+        "!/*.md",
+        "!/_*/",
+        "!/.vscode/",
+        "!/.gitignore",
+    ]
+
+
+def test_name_the_atlas_after_its_folder(tmp_path, monkeypatch):
+    folder = tmp_path / "log-daemon"
+    folder.mkdir()
+    monkeypatch.chdir(folder)
+
+    main(["init"])
+
+    assert (folder / "CLAUDE.md").read_text(encoding="utf-8").startswith("# log-daemon Atlas")
+    assert (folder / "STATUS.md").read_text(encoding="utf-8").startswith("# log-daemon — STATUS")
+
+
+def test_date_the_status_with_today(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+
+    main(["init"])
+
+    assert f"_Last updated: {date.today().isoformat()}_" in (tmp_path / "STATUS.md").read_text(encoding="utf-8")
+
+
+def test_write_the_same_files_on_every_run(tmp_path, monkeypatch):
+    first, second = tmp_path / "acme", tmp_path / "other" / "acme"
+    for folder in (first, second):
+        folder.mkdir(parents=True)
+        monkeypatch.chdir(folder)
+        main(["init"])
+
+    for path in _files_under(first):
+        assert (first / path).read_bytes() == (second / path).read_bytes(), path
+
+
+def test_write_utf8_with_unix_line_endings(tmp_path, monkeypatch):
+    folder = tmp_path / "señal"
+    folder.mkdir()
+    monkeypatch.chdir(folder)
+
+    main(["init"])
+
+    for path in _files_under(folder):
+        assert b"\r\n" not in (folder / path).read_bytes(), path
+    assert (folder / "CLAUDE.md").read_bytes().startswith("# señal Atlas".encode("utf-8"))
+
+
+def test_keep_what_an_existing_claude_settings_already_allows(tmp_path, monkeypatch):
+    (tmp_path / ".claude").mkdir()
+    (tmp_path / ".claude/settings.local.json").write_text(
+        '{"permissions": {"allow": ["Bash(ls:*)"]}}', encoding="utf-8"
+    )
+    monkeypatch.chdir(tmp_path)
+
+    assert main(["init"]) == 0
+
+    claude = json.loads((tmp_path / ".claude/settings.local.json").read_text(encoding="utf-8"))
+    assert claude == {"permissions": {"allow": ["Bash(ls:*)"], "additionalDirectories": []}}
+
+
+def test_turn_on_repository_detection_in_existing_vscode_settings(tmp_path, monkeypatch):
+    (tmp_path / ".vscode").mkdir()
+    (tmp_path / ".vscode/settings.json").write_text(
+        '{"editor.tabSize": 4, "git.autoRepositoryDetection": "openEditors"}', encoding="utf-8"
+    )
+    monkeypatch.chdir(tmp_path)
+
+    assert main(["init"]) == 0
+
+    vscode = json.loads((tmp_path / ".vscode/settings.json").read_text(encoding="utf-8"))
+    assert vscode == {
+        "editor.tabSize": 4,
+        "git.autoRepositoryDetection": True,
+        "git.scanRepositories": [],
+    }
+
+
+def test_keep_an_existing_gitignore_and_ask_to_check_it(tmp_path, monkeypatch, capsys):
+    (tmp_path / ".gitignore").write_text("node_modules/\n", encoding="utf-8")
+    monkeypatch.chdir(tmp_path)
+
+    assert main(["init"]) == 0
+
+    assert (tmp_path / ".gitignore").read_text(encoding="utf-8") == "node_modules/\n"
+    assert "Check that the existing .gitignore" in capsys.readouterr().out
+
+
+def test_refuse_unreadable_claude_settings_and_change_nothing(tmp_path, monkeypatch, capsys):
+    (tmp_path / ".claude").mkdir()
+    (tmp_path / ".claude/settings.local.json").write_text("{ not json", encoding="utf-8")
+    monkeypatch.chdir(tmp_path)
+
+    assert main(["init"]) == 1
+
+    assert _files_under(tmp_path) == {".claude/settings.local.json"}
+    assert "nothing was changed" in capsys.readouterr().out
+
+
+def test_refuse_a_folder_that_is_already_an_atlas(tmp_path, monkeypatch, capsys):
+    monkeypatch.chdir(tmp_path)
+    main(["init"])
+    (tmp_path / "STATUS.md").write_text("work in progress", encoding="utf-8")
+    capsys.readouterr()
+
+    assert main(["init"]) == 1
+
+    assert (tmp_path / "STATUS.md").read_text(encoding="utf-8") == "work in progress"
+    assert "already an Atlas" in capsys.readouterr().out
+
+
+def test_suggest_migrate_for_an_atlas_without_settings(tmp_path, monkeypatch, capsys):
+    monkeypatch.chdir(tmp_path)
+    (tmp_path / "CLAUDE.md").write_text("an Atlas from before _settings/", encoding="utf-8")
+
+    assert main(["init"]) == 1
+
+    assert not (tmp_path / "_settings").exists()
+    assert "atlas migrate" in capsys.readouterr().out
+
+
+def test_leave_existing_sources_untouched(tmp_path, monkeypatch):
+    source = tmp_path / "elsewhere" / "log-daemon"
+    source.mkdir(parents=True)
+    atlas = tmp_path / "acme"
+    atlas.mkdir()
+    (atlas / "log-daemon").symlink_to(source)
+    monkeypatch.chdir(atlas)
+
+    assert main(["init"]) == 0
+
+    assert (atlas / "log-daemon").is_symlink()

paranoid_atlas_cli-0.1.1/tests/test_runningwithoutacommandshould.py

@@ -0,0 +1,6 @@
+from atlas_cli.cli import main
+
+
+def test_print_the_usage(capsys):
+    assert main([]) == 0
+    assert "usage: atlas" in capsys.readouterr().out

paranoid_atlas_cli-0.1.1/uv.lock

@@ -0,0 +1,79 @@
+version = 1
+revision = 3
+requires-python = ">=3.11"
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" },
+]
+
+[[package]]
+name = "paranoid-atlas-cli"
+version = "0.1.1"
+source = { editable = "." }
+
+[package.dev-dependencies]
+dev = [
+    { name = "pytest" },
+]
+
+[package.metadata]
+
+[package.metadata.requires-dev]
+dev = [{ name = "pytest", specifier = ">=8" }]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.21.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" },
+]