diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 0cfc785..f6912e8 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -2,9 +2,9 @@ name: CI
 
 on:
   push:
-    branches: ["**"]
+    branches: ["main"]
   pull_request:
-    branches: ["**"]
+    branches: ["main"]
 
 jobs:
   test:
diff --git a/.github/workflows/jekyll-gh-pages.yml b/.github/workflows/deploy-gh-pages.yml
similarity index 88%
rename from .github/workflows/jekyll-gh-pages.yml
rename to .github/workflows/deploy-gh-pages.yml
index abea45d..8ce1918 100644
--- a/.github/workflows/jekyll-gh-pages.yml
+++ b/.github/workflows/deploy-gh-pages.yml
@@ -1,9 +1,9 @@
 # Sample workflow for building and deploying a Jekyll site to GitHub Pages
-name: Deploy Jekyll with GitHub Pages dependencies preinstalled
+name: Deploy GitHub Pages
 
 on:
   workflow_run:
-    workflows: ["publish"] 
+    workflows: ["Publish to PyPI"] 
     types: [completed]
 
   # Allows you to run this workflow manually from the Actions tab
@@ -25,6 +25,7 @@ jobs:
   # Build job
   build:
     runs-on: ubuntu-latest
+    if: ${{ github.event.workflow_run.conclusion == 'success' || github.event_name == 'workflow_dispatch' }}
     steps:
       - name: Checkout
         uses: actions/checkout@v4
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish-pypi.yml
similarity index 95%
rename from .github/workflows/publish.yml
rename to .github/workflows/publish-pypi.yml
index 2ad2f8b..236c04f 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish-pypi.yml
@@ -1,4 +1,4 @@
-name: Publish
+name: Publish to PyPi
 
 on:
   push:
diff --git a/.gitignore b/.gitignore
index fe89a3a..298d749 100644
--- a/.gitignore
+++ b/.gitignore
@@ -175,3 +175,41 @@ pyrightconfig.json
 
 # End of https://www.toptal.com/developers/gitignore/api/python
 
+# Created by https://www.toptal.com/developers/gitignore/api/macos
+# Edit at https://www.toptal.com/developers/gitignore?templates=macos
+
+### macOS ###
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### macOS Patch ###
+# iCloud generated files
+*.icloud
+
+# End of https://www.toptal.com/developers/gitignore/api/macos
+uv.lock
\ No newline at end of file
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..853dd52
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,42 @@
+.PHONY: lint typecheck test all \
+        changelog changelog-preview changelog-bump release
+
+# ── CI / quality ────────────────────────────────────────────────────────────
+
+lint:
+	ruff check .
+
+typecheck:
+	mypy src/
+
+test:
+	pytest --cov=src --cov-report=term-missing
+
+all: lint typecheck test
+
+# ── Changelog / release ──────────────────────────────────────────────────────
+
+# Preview what the next changelog entry will look like (dry-run, no files changed)
+changelog-preview:
+	git cliff --unreleased --bump
+
+# Show what the next version number will be
+changelog-bump:
+	git cliff --bumped-version
+
+# Prepend new entries to CHANGELOG.md for the next release
+changelog:
+	$(eval VERSION := $(shell git cliff --bumped-version 2>/dev/null))
+	touch CHANGELOG.md
+	git cliff --unreleased --prepend CHANGELOG.md --bump
+	@echo "CHANGELOG.md updated to $(VERSION). Review, then run: make release"
+
+# Full release: update changelog, commit, tag, push
+release:
+	$(eval VERSION := $(shell git cliff --bumped-version 2>/dev/null))
+	git add CHANGELOG.md
+	@git commit -m "chore: release $(VERSION)" || { echo "Error: CHANGELOG.md unchanged. Run 'make changelog' first."; exit 1; }
+	git tag $(VERSION)
+	git push origin main
+	git push origin $(VERSION)
+	@echo "Released $(VERSION)"
\ No newline at end of file
diff --git a/README.md b/README.md
index 549cb58..299ea19 100644
--- a/README.md
+++ b/README.md
@@ -20,7 +20,7 @@ Reusable Dev Containers for any project — without modifying the repository.
 
 ---
 
-![](https://github.com/dacrystal/dev-code/raw/main/demo/demo.gif "Demo gif")
+![](assets/demo.gif "Demo gif")
 
 `devcode` is a CLI that opens any project in VS Code Dev Containers using reusable, local templates.
 
@@ -50,11 +50,11 @@ Typical Dev Container workflows involve:
 # Install
 pip install dev-code
 
-# Create default template
-devcode init
+# Open a project (auto-detects template from container history, or uses default)
+devcode open ~/projects/my-app
 
-# Open a project
-devcode open dev-code ~/projects/my-app
+# Open with an explicit template
+devcode open ~/projects/my-app dev-code
 
 # Reopen projects later
 devcode ps -a -i
@@ -81,14 +81,7 @@ Default location:
 ~/.local/share/dev-code/templates/
 ```
 
-Override search paths:
-
-```bash
-DEVCODE_TEMPLATE_PATH=/my/templates:/team/templates
-```
-
-* The first path is used for writes
-* Additional paths are read-only
+Override search paths via `settings.json` (see [Configuration](#configuration)).
 
 ---
 
@@ -105,14 +98,16 @@ DEVCODE_TEMPLATE_PATH=/my/templates:/team/templates
 ### devcode open
 
 ```bash
-devcode open <template> <path> [options]
+devcode open <path> [template] [options]
 ```
 
-Open a project using a template.
+Open a project in VS Code using a devcontainer template.
 
 #### Arguments
 
-* `<template>`
+* `<path>` — Project directory (must exist)
+
+* `[template]` *(optional)*
 
   * Template name, or
   * Path to a `devcontainer.json`, or
@@ -120,10 +115,12 @@ Open a project using a template.
 
   Paths must start with `./`, `../`, `/`, or `~/`.
 
-  If both a template and directory match, the template takes precedence and a warning is shown.
+  If both a template name and a local directory match, the template takes precedence and a warning is shown.
 
-* `<path>`
-  Project directory
+  **If omitted**, devcode auto-detects the template in this order:
+  1. Most recently running container for this project path (uses its stored config)
+  2. Most recently stopped container for this project path
+  3. `default_template` from `settings.json` (error if not set)
 
 #### Options
 
@@ -135,16 +132,6 @@ Open a project using a template.
 
 ---
 
-### devcode init
-
-```bash
-devcode init
-```
-
-Creates the default template.
-
----
-
 ### devcode new
 
 ```bash
@@ -229,32 +216,54 @@ eval "$(devcode completion bash)"
 ## Typical Workflow
 
 ```bash
-devcode init
 devcode new python-dev
 devcode edit python-dev
-devcode open python-dev ~/projects/my-app
+devcode open ~/projects/my-app python-dev
 ```
 
 ---
 
-## Template System
+## Configuration
 
-### Default Location
+devcode reads `settings.json` from:
 
 ```
-~/.local/share/dev-code/templates/
+~/.config/dev-code/settings.json
 ```
 
-### Custom Paths
+Override the config directory:
 
 ```bash
-DEVCODE_TEMPLATE_PATH=$HOME/my/templates:/team/shared/templates
+DEVCODE_CONF_DIR=/custom/path devcode open ~/projects/my-app
+```
+
+The file is created automatically with defaults on first run.
+
+### settings.json
+
+```json
+{
+  "template_sources": ["~/.local/share/dev-code/templates"],
+  "default_template": "dev-code"
+}
 ```
 
-Resolution order:
+| Key | Description |
+| --- | --- |
+| `template_sources` | Ordered list of template directories. First is the write target; rest are read-only. |
+| `default_template` | Template used when `devcode open` is called without a template argument and no container history is found. Error if unset. |
+
+---
+
+## Template System
+
+### Default Location
+
+```
+~/.local/share/dev-code/templates/
+```
 
-1. First directory is the write target
-2. Remaining directories are used for lookup
+Configure additional paths via `template_sources` in `settings.json`.
 
 ---
 
@@ -348,8 +357,8 @@ Lists containers and allows reopening projects interactively.
 
 ## Internal Flow
 
-1. Resolve template
-2. Resolve project path
+1. Validate project path (must exist)
+2. Resolve template (explicit → container history → settings default)
 3. Launch VS Code Dev Container
 4. Apply file injection rules
 
diff --git a/assets/demo.gif b/assets/demo.gif
new file mode 100644
index 0000000..8bf9b17
Binary files /dev/null and b/assets/demo.gif differ
diff --git a/cliff.toml b/cliff.toml
new file mode 100644
index 0000000..2ca5ad5
--- /dev/null
+++ b/cliff.toml
@@ -0,0 +1,45 @@
+# git-cliff configuration
+# https://git-cliff.org/docs/configuration
+
+[changelog]
+body = """
+{% if version %}\
+    ## [{{ version | trim_start_matches(pat="v") }}] - {{ timestamp | date(format="%Y-%m-%d") }}
+{% else %}\
+    ## [Unreleased]
+{% endif %}\
+{% for group, commits in commits | group_by(attribute="group") %}
+    ### {{ group | striptags | trim | upper_first }}
+    {% for commit in commits %}
+        - {% if commit.scope %}*({{ commit.scope }})* {% endif %}\
+            {% if commit.breaking %}[**breaking**] {% endif %}\
+            {{ commit.message | upper_first }}\
+    {% endfor %}
+{% endfor %}\n
+"""
+trim = true
+render_always = true
+postprocessors = [
+    { pattern = "<REPO>", replace = "https://github.com/dacrystal/dev-code" },
+]
+
+[git]
+conventional_commits = true
+filter_unconventional = true
+split_commits = false
+commit_preprocessors = [
+    { pattern = '\((\w+\s)?#([0-9]+)\)', replace = "([#${2}](<REPO>/issues/${2}))" },
+]
+commit_parsers = [
+    { message = "^feat", group = "Added" },
+    { message = "^fix", group = "Fixed" },
+    { message = "^refactor", group = "Changed" },
+    { message = "^perf", group = "Changed" },
+    { message = "^revert", group = "Fixed" },
+    { message = "^docs|^chore|^ci|^style|^test", skip = true },
+]
+filter_commits = true
+protect_breaking_commits = true
+sort_commits = "oldest"
+topo_order = false
+skip_tags = "v*.*.*.post"
\ No newline at end of file
diff --git a/pyproject.toml b/pyproject.toml
index f0a1c29..54ec474 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,14 +1,16 @@
 [build-system]
-requires = ["hatchling", "hatch-vcs"]
+requires = ["hatchling", "hatch-vcs", "hatch-fancy-pypi-readme"]
 build-backend = "hatchling.build"
 
 [project]
 name = "dev-code"
-dynamic = ["version"]
+dynamic = ["version", "readme"]
 description = "Project · editor · container — simplified"
-readme = "README.md"
 requires-python = ">=3.10"
-dependencies = []
+authors = [
+    {name = "Nasser Alansari", email = "dacrystal@users.noreply.github.com"},
+]
+dependencies = ["click>=8.0"]
 classifiers = [
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.10",
@@ -24,7 +26,7 @@ classifiers = [
 "Issues" = "https://github.com/dacrystal/dev-code/issues"
 
 [project.scripts]
-devcode = "devcode:main"
+devcode = "devcode:cli"
 
 [tool.hatch.version]
 source = "vcs"
@@ -34,12 +36,18 @@ force-include = {"src/devcode.py" = "devcode.py", "src/templates" = "dev_code_te
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
+pythonpath = ["src"]
 
 [dependency-groups]
-dev = [
-    "pytest>=7.0.1",
-    "pyfiglet>=1.0.4",
-    "pytest-cov>=4.0",
-    "tox>=4.0",
-    "pyyaml>=6.0",
-]
+test = ["pytest>=7", "pytest-cov>=4"]
+dev = ["tox>=4", "pyyaml>=6", "git-cliff>=2"]
+
+[tool.hatch.metadata.hooks.fancy-pypi-readme]
+content-type = "text/markdown"
+
+[[tool.hatch.metadata.hooks.fancy-pypi-readme.fragments]]
+path = "README.md"
+
+[[tool.hatch.metadata.hooks.fancy-pypi-readme.substitutions]]
+pattern = '\(assets/'
+replacement = "(https://raw.githubusercontent.com/dacrystal/dev-code/main/assets/"
diff --git a/src/devcode.py b/src/devcode.py
index 47fc6c5..ed953d3 100644
--- a/src/devcode.py
+++ b/src/devcode.py
@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
-import argparse
+import click
+import click.shell_completion
 import importlib.metadata
 import json
 import logging
@@ -25,37 +26,10 @@
 
 KNOWN_CP_FIELDS = {"source", "target", "override", "owner", "group", "permissions"}
 
-_BASH_COMPLETION = """\
-# devcode bash completion
-# Requires bash 4.0+ (macOS ships bash 3.2; install bash 5 via Homebrew if needed).
-_dev_code() {
-    local -a candidates
-    mapfile -t candidates < <(devcode completion --complete "$COMP_CWORD" "${COMP_WORDS[@]}" 2>/dev/null)
-    if [[ ${#candidates[@]} -eq 0 ]]; then
-        local cur="${COMP_WORDS[COMP_CWORD]}"
-        mapfile -t COMPREPLY < <(compgen -f -- "$cur")
-    else
-        COMPREPLY=("${candidates[@]}")
-    fi
+_DEFAULT_SETTINGS = {
+    "template_sources": ["~/.local/share/dev-code/templates"],
+    "default_template": "dev-code",
 }
-complete -F _dev_code devcode
-"""
-
-_ZSH_COMPLETION = """\
-# devcode zsh completion
-_dev_code() {
-    local candidates
-    candidates=$(devcode completion --complete "$(( CURRENT - 1 ))" "${words[@]}" 2>/dev/null)
-    if [[ -z "$candidates" ]]; then
-        _files
-    else
-        compadd -- ${(f)candidates}
-    fi
-}
-# Note: compdef requires compinit to have been called first.
-compdef _dev_code devcode
-"""
-
 
 def _configure_logging(verbose: bool) -> None:
     """Configure the module logger. Guard prevents double-registration."""
@@ -90,15 +64,49 @@ def wsl_to_windows(path: str) -> str:
         raise RuntimeError(f"Failed to convert path with wslpath: {path}") from e
 
 
+def _conf_dir() -> str:
+    """Return the devcode config directory path."""
+    override = os.environ.get("DEVCODE_CONF_DIR")
+    if override:
+        return override
+    xdg_config = os.environ.get(
+        "XDG_CONFIG_HOME", os.path.join(os.path.expanduser("~"), ".config")
+    )
+    return os.path.join(xdg_config, "dev-code")
+
+
+def _load_settings() -> dict:
+    """Read settings.json, creating it with defaults if absent. Never raises."""
+    conf_dir = _conf_dir()
+    settings_path = os.path.join(conf_dir, "settings.json")
+    if not os.path.exists(settings_path):
+        try:
+            os.makedirs(conf_dir, exist_ok=True)
+            with open(settings_path, "w") as f:
+                json.dump(_DEFAULT_SETTINGS, f, indent=2)
+                f.write("\n")
+            logger.info("created default settings at %s", settings_path)
+        except OSError as e:
+            logger.warning("could not create settings file %s: %s", settings_path, e)
+        return dict(_DEFAULT_SETTINGS)
+    try:
+        with open(settings_path) as f:
+            return json.load(f)
+    except (json.JSONDecodeError, OSError) as e:
+        logger.warning("failed to load settings from %s: %s; using defaults", settings_path, e)
+        return dict(_DEFAULT_SETTINGS)
+
+
 def resolve_template_search_path() -> list[str]:
-    """Return ordered list of template search directories from DEVCODE_TEMPLATE_PATH."""
-    new_var = os.environ.get("DEVCODE_TEMPLATE_PATH")
-    xdg = os.environ.get("XDG_DATA_HOME", os.path.join(os.path.expanduser("~"), ".local", "share"))
-    default = os.path.join(xdg, "dev-code", "templates")
-    if not new_var:
-        return [default]
-    dirs = [d for d in new_var.split(os.pathsep) if d]
-    return dirs if dirs else [default]
+    """Return ordered list of template search directories from settings.json."""
+    settings = _load_settings()
+    sources = settings.get("template_sources")
+    if not sources:
+        xdg = os.environ.get(
+            "XDG_DATA_HOME", os.path.join(os.path.expanduser("~"), ".local", "share")
+        )
+        return [os.path.join(xdg, "dev-code", "templates")]
+    return [os.path.expanduser(d) for d in sources if d]
 
 
 def _write_template_dir() -> str:
@@ -521,11 +529,47 @@ def _git_repo_root(path: str) -> str | None:
         return None
 
 
-def cmd_open(args) -> None:
-    """open subcommand: open a project in VS Code using a devcontainer template."""
-    config_file = resolve_template(args.template)
+def _find_container_config_for_project(project_path: str) -> str | None:
+    """Return config_file of most recently created container for project_path, or None.
+
+    Checks running containers first; falls back to all containers (stopped too).
+    """
+    label_value = wsl_to_windows(project_path) if is_wsl() else project_path
+    fmt = '{{.CreatedAt}}\t{{.Label "devcontainer.config_file"}}'
+
+    for extra_args in [[], ["-a"]]:
+        try:
+            result = subprocess.run(
+                ["docker", "container", "ls"] + extra_args + [
+                    "--filter", f"label=devcontainer.local_folder={label_value}",
+                    "--format", fmt,
+                ],
+                capture_output=True, text=True,
+            )
+        except OSError:
+            return None
+        if result.returncode != 0:
+            return None
+        rows = []
+        for line in result.stdout.splitlines():
+            parts = line.split("\t", 1)
+            if len(parts) == 2 and parts[1].strip():
+                rows.append((parts[0], parts[1].strip()))
+        if rows:
+            rows.sort(key=lambda r: r[0], reverse=True)
+            return rows[0][1]
+
+    return None
+
+
+def _do_open(projectpath: str, template, container_folder, timeout: int, dry_run: bool) -> None:
+    """Core open logic shared by the open command and internal callers."""
+    project_path = os.path.abspath(projectpath)
+
+    if not os.path.exists(project_path):
+        logger.error("projectpath not found: %s", projectpath)
+        sys.exit(1)
 
-    project_path = os.path.abspath(args.projectpath)
     if project_path == "/":
         logger.error("projectpath must not resolve to /")
         sys.exit(1)
@@ -541,10 +585,24 @@ def cmd_open(args) -> None:
             )
             sys.exit(1)
 
-    container_folder = args.container_folder or f"/workspaces/{os.path.basename(project_path)}"
+    if template:
+        config_file = resolve_template(template)
+    else:
+        config_file = _find_container_config_for_project(project_path)
+        if config_file is None:
+            settings = _load_settings()
+            default = settings.get("default_template", "")
+            if not default:
+                logger.error(
+                    "no template specified and no default_template configured in settings"
+                )
+                sys.exit(1)
+            config_file = resolve_template(default)
+
+    container_folder = container_folder or f"/workspaces/{os.path.basename(project_path)}"
     uri = build_devcontainer_uri(project_path, config_file, container_folder)
 
-    if args.dry_run:
+    if dry_run:
         _cmd_open_dry_run(config_file, project_path, uri)
         return
 
@@ -553,7 +611,7 @@ def cmd_open(args) -> None:
         sys.exit(1)
 
     subprocess.Popen(["code", "--folder-uri", uri], start_new_session=True)
-    run_post_launch(config_file, project_path, args.timeout)
+    run_post_launch(config_file, project_path, timeout)
 
 
 def _cmd_open_dry_run(config_file: str, project_path: str, uri: str) -> None:
@@ -597,18 +655,70 @@ def _cmd_open_dry_run(config_file: str, project_path: str, uri: str) -> None:
     print("(dry run — no operations executed)")
 
 
-def cmd_new(args) -> None:
+def _template_name_from_config(config_path: str) -> str:
+    """Extract template name as the directory immediately above .devcontainer/."""
+    norm = os.path.normpath(config_path)
+    parts = norm.replace("\\", "/").split("/")
+    for i, part in enumerate(parts):
+        if part == ".devcontainer" and i > 0:
+            return parts[i - 1]
+    return os.path.basename(os.path.dirname(os.path.dirname(norm)))
+
+
+def _complete_templates(ctx, param, incomplete):
+    """Shell completion callback: return template names matching the incomplete prefix."""
+    return [
+        click.shell_completion.CompletionItem(t)
+        for t in _list_template_names()
+        if t.startswith(incomplete)
+    ]
+
+
+@click.group(invoke_without_command=True)
+@click.version_option(package_name="dev-code", prog_name="devcode")
+@click.option(
+    "-v", "--verbose",
+    is_flag=True,
+    is_eager=True,
+    expose_value=False,
+    callback=lambda ctx, param, v: _configure_logging(v),
+)
+@click.pass_context
+def cli(ctx):
+    """project · editor · container — simplified."""
+    if ctx.invoked_subcommand is None:
+        click.echo(BANNER)
+        click.echo(ctx.get_help())
+
+
+@cli.command("open")
+@click.argument("projectpath")
+@click.argument("template", required=False, shell_complete=_complete_templates)
+@click.option("--container-folder", default=None, help="Path inside the container.")
+@click.option("--timeout", type=int, default=300, show_default=True,
+              help="Seconds to wait for devcontainer to start.")
+@click.option("--dry-run", is_flag=True, help="Print plan without executing.")
+def open_command(projectpath, template, container_folder, timeout, dry_run):
+    """Open a project in VS Code using a devcontainer template."""
+    _do_open(projectpath, template, container_folder, timeout, dry_run)
+
+
+@cli.command("new")
+@click.argument("name")
+@click.argument("base", required=False)
+@click.option("--edit", is_flag=True, help="Open the new template in VS Code after creating it.")
+def new_command(name, base, edit):
     """Create a new template by copying a base template."""
     write_dir = _write_template_dir()
-    dest = os.path.join(write_dir, args.name)
+    dest = os.path.join(write_dir, name)
 
     # Step 1: fail if name already exists
     if os.path.exists(dest):
-        logger.error("template '%s' already exists: %s", args.name, dest)
+        logger.error("template '%s' already exists: %s", name, dest)
         sys.exit(1)
 
     # Step 2: resolve base — search all dirs, then builtins
-    base_name = args.base or "dev-code"
+    base_name = base or "dev-code"
     base_root = _find_template_in_search_path(base_name)
     if base_root:
         base_src = base_root
@@ -629,32 +739,35 @@ def cmd_new(args) -> None:
 
     # Step 5: copy
     shutil.copytree(base_src, dest)
-    print(f"Created template '{args.name}' at {dest}")
+    print(f"Created template '{name}' at {dest}")
 
     # Step 6: --edit
-    if args.edit:
-        open_args = argparse.Namespace(
-            template=args.name,
+    if edit:
+        _do_open(
             projectpath=dest,
+            template=name,
             container_folder=None,
             timeout=300,
             dry_run=False,
         )
-        cmd_open(open_args)
 
 
-def cmd_edit(args) -> None:
-    """Open a template directory directly in VS Code for editing."""
-    template_root = _find_template_in_search_path(args.template)
+@cli.command("edit")
+@click.argument("template", shell_complete=_complete_templates)
+def edit_command(template):
+    """Open a template directory in VS Code for editing."""
+    template_root = _find_template_in_search_path(template)
     if template_root is None:
-        logger.error("template not found: %s", args.template)
+        logger.error("template not found: %s", template)
         sys.exit(1)
     subprocess.run(["code", template_root])
 
 
-def cmd_list(args) -> None:
+@cli.command("list")
+@click.option("--long", is_flag=True, help="Show description and path for each template.")
+def list_command(long):
     """List available templates."""
-    if not args.long:
+    if not long:
         names = _list_template_names()
         for name in names:
             print(name)
@@ -691,18 +804,11 @@ def cmd_list(args) -> None:
         print(_fmt_row(row, widths))
 
 
-def _template_name_from_config(config_path: str) -> str:
-    """Extract template name as the directory immediately above .devcontainer/."""
-    norm = os.path.normpath(config_path)
-    parts = norm.replace("\\", "/").split("/")
-    for i, part in enumerate(parts):
-        if part == ".devcontainer" and i > 0:
-            return parts[i - 1]
-    return os.path.basename(os.path.dirname(os.path.dirname(norm)))
-
-
-def cmd_ps(args) -> None:
-    """List devcontainers (running by default; all with -a)."""
+@cli.command("ps")
+@click.option("-a", "--all", "show_all", is_flag=True, help="Show all containers (not just running).")
+@click.option("-i", "--interactive", is_flag=True, help="Prompt to reopen a listed container.")
+def ps_command(show_all, interactive):
+    """List dev containers."""
     fmt = "{{.CreatedAt}}\t{{.ID}}\t{{.Label \"devcontainer.local_folder\"}}\t{{.Label \"devcontainer.config_file\"}}\t{{.Status}}"
     result = subprocess.run(
         ["docker", "container", "ls", "-a",
@@ -721,14 +827,14 @@ def cmd_ps(args) -> None:
     rows = [r[1:] for r in rows]  # now: [cid, local_folder, config_file, status]
 
     # Filter: without -a keep only running containers
-    if not args.all:
+    if not show_all:
         rows = [r for r in rows if len(r) >= 4 and r[3].startswith("Up")]
 
     # Always drop malformed rows so rows and display stay parallel
     rows = [r for r in rows if len(r) >= 4]
 
     if not rows:
-        print("no devcontainers" if args.all else "no running devcontainers")
+        print("no devcontainers" if show_all else "no running devcontainers")
         return
 
     # Build display rows: (num, cid, template, path, status)
@@ -745,10 +851,10 @@ def cmd_ps(args) -> None:
     for row in display:
         print(_fmt_row(row, widths))
 
-    if not args.interactive:
+    if not interactive:
         return
 
-    choice = input(f"Open [1-{len(display)}]: ").strip()
+    choice = input(f"\nOpen [1-{len(display)}]: ").strip()
     try:
         idx = int(choice) - 1
         if not (0 <= idx < len(display)):
@@ -788,144 +894,14 @@ def cmd_ps(args) -> None:
     if not container_folder:
         container_folder = f"/workspaces/{os.path.basename(local_folder)}"
 
-    open_args = argparse.Namespace(
-        template=config_file,
+    _do_open(
         projectpath=projectpath,
+        template=config_file,
         container_folder=container_folder,
         timeout=300,
         dry_run=False,
     )
-    cmd_open(open_args)
-
-
-_SUBCOMMANDS = ["open", "new", "edit", "list", "ps", "completion"]
-
-_SUBCOMMAND_FLAGS = {
-    "open": ["--dry-run", "--container-folder", "--timeout"],
-    "new": ["--edit"],
-    "edit": [],
-    "list": ["--long"],
-    "ps": ["-a", "-i"],
-    "completion": [],
-}
-
-
-def cmd_completion(args) -> None:
-    """completion subcommand: print shell completion script or candidates to stdout."""
-    if args.complete_words is not None:
-        # Internal path: called by the shell completion scripts.
-        # Always exits 0; prints nothing on any error.
-        try:
-            words = args.complete_words
-            if not words:
-                sys.exit(0)
-            try:
-                cword_index = int(words[0])
-            except ValueError:
-                sys.exit(0)
-            words = words[1:]
-
-            if not (0 <= cword_index < len(words)):
-                sys.exit(0)
-
-            current_word = words[cword_index]
-
-            if cword_index == 1:
-                candidates = _SUBCOMMANDS
-            else:
-                subcommand = words[1] if len(words) > 1 else ""
-                if subcommand == "list":
-                    candidates = ["--long"]
-                elif subcommand == "completion":
-                    candidates = ["bash", "zsh"] if cword_index == 2 else []
-                elif current_word.startswith("-"):
-                    candidates = _SUBCOMMAND_FLAGS.get(subcommand, [])
-                else:
-                    if subcommand == "open" and cword_index == 2:
-                        candidates = _list_template_names()
-                    elif subcommand == "new" and cword_index == 3:
-                        candidates = _list_template_names()
-                    elif subcommand == "edit" and cword_index == 2:
-                        candidates = _list_template_names()
-                    else:
-                        candidates = []
-
-            for c in candidates:
-                if c.startswith(current_word):
-                    print(c)
-        except Exception:
-            pass
-        sys.exit(0)
-
-    if args.shell == "bash":
-        print(_BASH_COMPLETION, end="")
-    elif args.shell == "zsh":
-        print(_ZSH_COMPLETION, end="")
-    else:
-        logger.error("unknown shell %r: supported shells are bash and zsh", args.shell)
-        sys.exit(1)
-
-
-class _BannerParser(argparse.ArgumentParser):
-    """ArgumentParser that shows the banner only in full --help output, not in error usage lines."""
-
-    def format_help(self):
-        return BANNER + "\n\n" + super().format_help()
-
-
-def main():
-    try:
-        _version = importlib.metadata.version("dev-code")
-    except importlib.metadata.PackageNotFoundError:
-        _version = "(dev)"
-
-    parser = _BannerParser(prog="devcode")
-    parser.add_argument("--version", action="version", version=f"%(prog)s {_version}")
-    parser.add_argument("-v", "--verbose", action="store_true")
-    subparsers = parser.add_subparsers(dest="subcommand")
-
-    p_open = subparsers.add_parser("open")
-    p_open.add_argument("template")
-    p_open.add_argument("projectpath")
-    p_open.add_argument("--container-folder")
-    p_open.add_argument("--timeout", type=int, default=300)
-    p_open.add_argument("--dry-run", action="store_true", dest="dry_run")
-
-    p_new = subparsers.add_parser("new")
-    p_new.add_argument("name")
-    p_new.add_argument("base", nargs="?")
-    p_new.add_argument("--edit", action="store_true")
-
-    p_edit = subparsers.add_parser("edit")
-    p_edit.add_argument("template")
-
-    p_list = subparsers.add_parser("list")
-    p_list.add_argument("--long", action="store_true")
-
-    p_ps = subparsers.add_parser("ps")
-    p_ps.add_argument("-a", "--all", action="store_true", dest="all")
-    p_ps.add_argument("-i", "--interactive", action="store_true", dest="interactive")
-
-    p_completion = subparsers.add_parser("completion")
-    p_completion.add_argument("shell", nargs="?")
-    p_completion.add_argument("--complete", nargs="*", dest="complete_words", help=argparse.SUPPRESS)
-
-    args = parser.parse_args()
-    if args.subcommand is None:
-        parser.print_help()
-        sys.exit(0)
-    _configure_logging(args.verbose)
-
-    dispatch = {
-        "open": cmd_open,
-        "new": cmd_new,
-        "edit": cmd_edit,
-        "list": cmd_list,
-        "ps": cmd_ps,
-        "completion": cmd_completion,
-    }
-    dispatch[args.subcommand](args)
 
 
 if __name__ == "__main__":
-    main()
\ No newline at end of file
+    cli()
diff --git a/tests/test_dev_code.py b/tests/test_dev_code.py
index d2f51de..57ce026 100644
--- a/tests/test_dev_code.py
+++ b/tests/test_dev_code.py
@@ -1,4 +1,3 @@
-import argparse
 import importlib.util
 import io
 import json
@@ -10,6 +9,8 @@
 import unittest
 from unittest.mock import MagicMock, patch
 
+from click.testing import CliRunner
+
 # Load src/devcode.py as a module
 spec = importlib.util.spec_from_file_location(
     "dev_code",
@@ -150,52 +151,200 @@ def fake_run(cmd, **kw):
         self.assertIn(r"C:\myproject", label_filter)
 
 
-class TestResolveTemplateSearchPath(unittest.TestCase):
-    def _clean_env(self, extra=None):
-        """Return env with DEVCODE_TEMPLATE_PATH/XDG_DATA_HOME stripped."""
-        env = {k: v for k, v in os.environ.items()
-               if k not in ("DEVCODE_TEMPLATE_PATH", "XDG_DATA_HOME")}
-        if extra:
-            env.update(extra)
-        return env
+class TestFindContainerConfigForProject(unittest.TestCase):
+    def _mock_result(self, output, returncode=0):
+        return MagicMock(returncode=returncode, stdout=output)
 
-    def test_single_path(self):
-        env = self._clean_env({"DEVCODE_TEMPLATE_PATH": "/a/b"})
-        with patch.dict(os.environ, env, clear=True):
-            self.assertEqual(devcode.resolve_template_search_path(), ["/a/b"])
+    def test_returns_config_from_running_container(self):
+        output = "2024-01-15 10:00:00 +0000 UTC\t/path/to/devcontainer.json\n"
+        with patch("subprocess.run", return_value=self._mock_result(output)):
+            result = devcode._find_container_config_for_project("/myproject")
+        self.assertEqual(result, "/path/to/devcontainer.json")
 
-    def test_multiple_paths(self):
-        env = self._clean_env({"DEVCODE_TEMPLATE_PATH": os.pathsep.join(["/a", "/b", "/c"])})
-        with patch.dict(os.environ, env, clear=True):
-            self.assertEqual(devcode.resolve_template_search_path(), ["/a", "/b", "/c"])
+    def test_returns_most_recent_when_multiple_running(self):
+        output = (
+            "2024-01-14 10:00:00 +0000 UTC\t/path/old.json\n"
+            "2024-01-15 10:00:00 +0000 UTC\t/path/new.json\n"
+        )
+        with patch("subprocess.run", return_value=self._mock_result(output)):
+            result = devcode._find_container_config_for_project("/myproject")
+        self.assertEqual(result, "/path/new.json")
+
+    def test_falls_back_to_stopped_when_no_running(self):
+        running_result = self._mock_result("")
+        stopped_result = self._mock_result(
+            "2024-01-15 10:00:00 +0000 UTC\t/stopped.json\n"
+        )
+        with patch("subprocess.run", side_effect=[running_result, stopped_result]):
+            result = devcode._find_container_config_for_project("/myproject")
+        self.assertEqual(result, "/stopped.json")
 
-    def test_empty_entries_skipped(self):
-        env = self._clean_env({"DEVCODE_TEMPLATE_PATH": f"/a{os.pathsep}{os.pathsep}/b{os.pathsep}"})
-        with patch.dict(os.environ, env, clear=True):
-            self.assertEqual(devcode.resolve_template_search_path(), ["/a", "/b"])
+    def test_returns_none_when_no_containers(self):
+        with patch("subprocess.run", return_value=self._mock_result("")):
+            result = devcode._find_container_config_for_project("/myproject")
+        self.assertIsNone(result)
+
+    def test_returns_none_on_docker_failure(self):
+        with patch("subprocess.run", return_value=self._mock_result("", returncode=1)):
+            result = devcode._find_container_config_for_project("/myproject")
+        self.assertIsNone(result)
+
+    def test_wsl_converts_path(self):
+        calls = []
+        def fake_run(cmd, **kw):
+            calls.append(cmd)
+            return self._mock_result("")
+        with patch("subprocess.run", side_effect=fake_run):
+            with patch.object(devcode, "is_wsl", return_value=True):
+                with patch.object(devcode, "wsl_to_windows", return_value=r"C:\myproject"):
+                    devcode._find_container_config_for_project("/myproject")
+        label_filter = next(a for a in calls[0] if "devcontainer.local_folder" in a)
+        self.assertIn(r"C:\myproject", label_filter)
+
+    def test_returns_none_when_docker_not_installed(self):
+        with patch("subprocess.run", side_effect=OSError("docker not found")):
+            result = devcode._find_container_config_for_project("/myproject")
+        self.assertIsNone(result)
 
-    def test_all_empty_entries_falls_back_to_xdg(self):
-        env = self._clean_env({"DEVCODE_TEMPLATE_PATH": os.pathsep * 3, "XDG_DATA_HOME": "/xdg"})
-        with patch.dict(os.environ, env, clear=True):
-            result = devcode.resolve_template_search_path()
-        self.assertEqual(result, [os.path.join("/xdg", "dev-code", "templates")])
 
-    def test_unset_uses_xdg_data_home(self):
-        env = self._clean_env({"XDG_DATA_HOME": "/xdg"})
+class TestCmdOpen(unittest.TestCase):
+    def test_errors_on_nonexistent_projectpath(self):
+        with self.assertRaises(SystemExit):
+            devcode._do_open("/nonexistent/path/xyz123", "mytemplate", None, 300, False)
+
+    def test_errors_on_root_path(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            # patch abspath to return "/" so the root guard triggers
+            with patch("os.path.abspath", return_value="/"):
+                with patch("os.path.exists", return_value=True):
+                    with self.assertRaises(SystemExit):
+                        devcode._do_open(tmp, "mytemplate", None, 300, False)
+
+    def test_uses_explicit_template(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            with patch.object(devcode, "resolve_template", return_value="/fake/devcontainer.json") as mock_rt:
+                with patch.object(devcode, "_git_repo_root", return_value=None):
+                    with patch("shutil.which", return_value="/usr/bin/code"):
+                        with patch("subprocess.Popen"):
+                            with patch.object(devcode, "run_post_launch"):
+                                devcode._do_open(tmp, "mytemplate", None, 300, False)
+            mock_rt.assert_called_once_with("mytemplate")
+
+    def test_auto_detects_from_container(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            with patch.object(devcode, "_find_container_config_for_project",
+                               return_value="/found/devcontainer.json") as mock_find:
+                with patch.object(devcode, "_git_repo_root", return_value=None):
+                    with patch("shutil.which", return_value="/usr/bin/code"):
+                        with patch("subprocess.Popen"):
+                            with patch.object(devcode, "run_post_launch"):
+                                devcode._do_open(tmp, None, None, 300, False)
+            mock_find.assert_called_once()
+
+    def test_auto_detects_falls_back_to_default_template(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            with patch.object(devcode, "_find_container_config_for_project", return_value=None):
+                with patch.object(devcode, "_load_settings",
+                                   return_value={"default_template": "dev-code"}):
+                    with patch.object(devcode, "resolve_template",
+                                       return_value="/fake/devcontainer.json") as mock_rt:
+                        with patch.object(devcode, "_git_repo_root", return_value=None):
+                            with patch("shutil.which", return_value="/usr/bin/code"):
+                                with patch("subprocess.Popen"):
+                                    with patch.object(devcode, "run_post_launch"):
+                                        devcode._do_open(tmp, None, None, 300, False)
+                mock_rt.assert_called_once_with("dev-code")
+
+    def test_errors_when_no_container_and_no_default_template(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            with patch.object(devcode, "_find_container_config_for_project", return_value=None):
+                with patch.object(devcode, "_load_settings", return_value={"default_template": ""}):
+                    with patch.object(devcode, "_git_repo_root", return_value=None):
+                        with self.assertRaises(SystemExit):
+                            devcode._do_open(tmp, None, None, 300, False)
+
+
+class TestConfDir(unittest.TestCase):
+    def test_uses_devcode_conf_dir_override(self):
+        with patch.dict(os.environ, {"DEVCODE_CONF_DIR": "/custom/conf"}):
+            self.assertEqual(devcode._conf_dir(), "/custom/conf")
+
+    def test_falls_back_to_xdg_config_home(self):
+        env = {k: v for k, v in os.environ.items()
+               if k not in ("DEVCODE_CONF_DIR", "XDG_CONFIG_HOME")}
+        env["XDG_CONFIG_HOME"] = "/xdg/config"
         with patch.dict(os.environ, env, clear=True):
-            result = devcode.resolve_template_search_path()
-        self.assertEqual(result, [os.path.join("/xdg", "dev-code", "templates")])
+            self.assertEqual(devcode._conf_dir(), os.path.join("/xdg/config", "dev-code"))
 
-    def test_unset_uses_default_xdg(self):
-        env = self._clean_env()
+    def test_falls_back_to_default_config_dir(self):
+        env = {k: v for k, v in os.environ.items()
+               if k not in ("DEVCODE_CONF_DIR", "XDG_CONFIG_HOME")}
         with patch.dict(os.environ, env, clear=True):
-            result = devcode.resolve_template_search_path()
-        self.assertIn(os.path.join(".local", "share", "dev-code", "templates"), result[0])
+            result = devcode._conf_dir()
+        self.assertTrue(result.endswith(os.path.join(".config", "dev-code")))
+
+
+class TestLoadSettings(unittest.TestCase):
+    def test_creates_default_settings_when_missing(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            with patch.dict(os.environ, {"DEVCODE_CONF_DIR": tmp}):
+                settings = devcode._load_settings()
+        self.assertEqual(settings["default_template"], "dev-code")
+        self.assertIn("template_sources", settings)
+
+    def test_creates_settings_file_on_disk_when_missing(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            conf_dir = os.path.join(tmp, "conf")
+            with patch.dict(os.environ, {"DEVCODE_CONF_DIR": conf_dir}):
+                devcode._load_settings()
+            self.assertTrue(os.path.exists(os.path.join(conf_dir, "settings.json")))
+
+    def test_reads_existing_settings(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            settings_path = os.path.join(tmp, "settings.json")
+            with open(settings_path, "w") as f:
+                json.dump({"template_sources": ["/custom"], "default_template": "mytemplate"}, f)
+            with patch.dict(os.environ, {"DEVCODE_CONF_DIR": tmp}):
+                settings = devcode._load_settings()
+        self.assertEqual(settings["default_template"], "mytemplate")
+        self.assertEqual(settings["template_sources"], ["/custom"])
+
+    def test_invalid_json_returns_defaults(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            settings_path = os.path.join(tmp, "settings.json")
+            with open(settings_path, "w") as f:
+                f.write("not valid json {{{")
+            with patch.dict(os.environ, {"DEVCODE_CONF_DIR": tmp}):
+                with self.assertLogs("devcode", level="WARNING"):
+                    settings = devcode._load_settings()
+        self.assertEqual(settings["default_template"], "dev-code")
+
+
+class TestResolveTemplateSearchPath(unittest.TestCase):
+    def test_uses_template_sources_from_settings(self):
+        with patch.object(devcode, "_load_settings", return_value={"template_sources": ["/a", "/b"]}):
+            self.assertEqual(devcode.resolve_template_search_path(), ["/a", "/b"])
 
+    def test_expands_tilde_in_sources(self):
+        with patch.object(devcode, "_load_settings", return_value={"template_sources": ["~/templates"]}):
+            result = devcode.resolve_template_search_path()
+        self.assertTrue(os.path.isabs(result[0]))
+        self.assertNotIn("~", result[0])
+
+    def test_falls_back_to_xdg_data_home_when_no_sources(self):
+        env = {k: v for k, v in os.environ.items() if k != "XDG_DATA_HOME"}
+        env["XDG_DATA_HOME"] = "/xdg/data"
+        with patch.object(devcode, "_load_settings", return_value={}):
+            with patch.dict(os.environ, env, clear=True):
+                result = devcode.resolve_template_search_path()
+        self.assertEqual(result, [os.path.join("/xdg/data", "dev-code", "templates")])
+
+    def test_skips_empty_entries(self):
+        with patch.object(devcode, "_load_settings", return_value={"template_sources": ["/a", "", "/b"]}):
+            self.assertEqual(devcode.resolve_template_search_path(), ["/a", "/b"])
 
     def test_write_template_dir_returns_first_entry(self):
-        env = self._clean_env({"DEVCODE_TEMPLATE_PATH": os.pathsep.join(["/first", "/second"])})
-        with patch.dict(os.environ, env, clear=True):
+        with patch.object(devcode, "_load_settings", return_value={"template_sources": ["/first", "/second"]}):
             self.assertEqual(devcode._write_template_dir(), "/first")
 
 
@@ -289,13 +438,13 @@ def test_finds_user_template(self):
             os.makedirs(tpath)
             cfg = os.path.join(tpath, "devcontainer.json")
             open(cfg, "w").close()
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": d}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [d]}):
                 result = devcode.resolve_template("mytemplate")
         self.assertEqual(result, cfg)
 
     def test_exits_when_not_found(self):
         with tempfile.TemporaryDirectory() as d:
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": d}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [d]}):
                 with patch.object(devcode, "__file__", os.path.join(d, "devcode.py")):
                     with self.assertRaises(SystemExit):
                         devcode.resolve_template("no-such-template")
@@ -304,7 +453,7 @@ def test_resolves_file_path_when_no_template(self):
         with tempfile.TemporaryDirectory() as d:
             cfg = os.path.join(d, "devcontainer.json")
             open(cfg, "w").close()
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": d + "_templates"}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [d + "_templates"]}):
                 with patch.object(devcode, "__file__", os.path.join(d, "devcode.py")):
                     result = devcode.resolve_template(cfg)
         self.assertEqual(result, cfg)
@@ -315,7 +464,7 @@ def test_resolves_directory_path_when_no_template(self):
             os.makedirs(sub)
             cfg = os.path.join(sub, "devcontainer.json")
             open(cfg, "w").close()
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": d + "_templates"}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [d + "_templates"]}):
                 with patch.object(devcode, "__file__", os.path.join(d, "devcode.py")):
                     result = devcode.resolve_template(d)
         self.assertEqual(result, cfg)
@@ -333,7 +482,7 @@ def test_dot_slash_prefix_resolves_as_path_not_template(self):
             old_cwd = os.getcwd()
             os.chdir(d)
             try:
-                with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": os.path.join(d, "templates")}):
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [os.path.join(d, "templates")]}):
                     with patch.object(devcode, "__file__", os.path.join(d, "devcode.py")):
                         result = devcode.resolve_template("./mydev")
             finally:
@@ -350,7 +499,7 @@ def test_absolute_path_resolves_as_path_not_template(self):
             os.makedirs(local)
             local_cfg = os.path.join(local, "devcontainer.json")
             open(local_cfg, "w").close()
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": os.path.join(d, "templates")}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [os.path.join(d, "templates")]}):
                 with patch.object(devcode, "__file__", os.path.join(d, "devcode.py")):
                     result = devcode.resolve_template(os.path.join(d, "mydev"))
         self.assertEqual(result, local_cfg)
@@ -368,7 +517,7 @@ def test_ambiguity_warns_and_uses_template(self):
             old_cwd = os.getcwd()
             os.chdir(os.path.dirname(d))
             try:
-                with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": d + "_templates"}):
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [d + "_templates"]}):
                     with patch.object(devcode, "__file__", os.path.join(d, "devcode.py")):
                         with self.assertLogs("devcode", level="WARNING") as cm:
                             result = devcode.resolve_template(dirname)
@@ -382,7 +531,7 @@ def test_exits_with_wrong_filename_in_path(self):
         with tempfile.TemporaryDirectory() as d:
             cfg = os.path.join(d, "custom.json")
             open(cfg, "w").close()
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": d + "_t"}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [d + "_t"]}):
                 with patch.object(devcode, "__file__", os.path.join(d, "devcode.py")):
                     with self.assertRaises(SystemExit):
                         devcode.resolve_template(cfg)
@@ -391,7 +540,7 @@ def test_exits_when_path_prefix_dir_has_no_devcontainer(self):
         with tempfile.TemporaryDirectory() as d:
             empty_dir = os.path.join(d, "myproject")
             os.makedirs(empty_dir)
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": d + "_t"}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [d + "_t"]}):
                 with patch.object(devcode, "__file__", os.path.join(d, "devcode.py")):
                     with self.assertRaises(SystemExit):
                         devcode.resolve_template(empty_dir)
@@ -399,7 +548,7 @@ def test_exits_when_path_prefix_dir_has_no_devcontainer(self):
     def test_exits_when_path_prefix_but_path_not_found(self):
         with tempfile.TemporaryDirectory() as d:
             nonexistent = os.path.join(d, "nonexistent")
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": d + "_t"}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [d + "_t"]}):
                 with patch.object(devcode, "__file__", os.path.join(d, "devcode.py")):
                     with self.assertLogs("devcode", level="ERROR") as cm:
                         with self.assertRaises(SystemExit):
@@ -412,8 +561,7 @@ def test_finds_template_via_search_path(self):
             os.makedirs(tpath)
             cfg = os.path.join(tpath, "devcontainer.json")
             open(cfg, "w").close()
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": d},
-                            clear=False):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [d]}):
                 result = devcode.resolve_template("mytemplate")
         self.assertEqual(result, cfg)
 
@@ -424,7 +572,7 @@ def test_does_not_fall_back_to_builtin(self):
                 builtin = os.path.join(pkg_dir, "dev_code_templates", "dev-code", ".devcontainer")
                 os.makedirs(builtin)
                 open(os.path.join(builtin, "devcontainer.json"), "w").close()
-                with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": user_dir}):
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
                     with patch.object(devcode, "__file__", os.path.join(pkg_dir, "devcode.py")):
                         with self.assertRaises(SystemExit):
                             devcode.resolve_template("dev-code")
@@ -436,7 +584,7 @@ def test_finds_in_second_search_dir(self):
                 os.makedirs(tpath)
                 cfg = os.path.join(tpath, "devcontainer.json")
                 open(cfg, "w").close()
-                with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": os.pathsep.join([d1, d2])}):
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [d1, d2]}):
                     result = devcode.resolve_template("mytemplate")
         self.assertEqual(result, cfg)
 
@@ -532,24 +680,30 @@ def setUp(self):
         tpl = os.path.join(self.tmpdir, "claude", ".devcontainer")
         os.makedirs(tpl)
         open(os.path.join(tpl, "devcontainer.json"), "w").close()
-        self.env_patch = patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": self.tmpdir})
-        self.env_patch.start()
+        self.patch_settings = patch.object(devcode, "_load_settings", return_value={"template_sources": [self.tmpdir]})
+        self.patch_settings.start()
+        # Snapshot logger handlers so we can restore after CliRunner calls install one
+        self._logger_handlers = list(devcode.logger.handlers)
 
     def tearDown(self):
-        self.env_patch.stop()
+        self.patch_settings.stop()
         shutil.rmtree(self.tmpdir, ignore_errors=True)
+        # Remove any logger handlers added during the test (CliRunner installs a StreamHandler
+        # pointing at its fake stderr; that stream becomes invalid after CliRunner exits)
+        devcode.logger.handlers[:] = self._logger_handlers
 
     def test_projectpath_root_exits(self):
-        with patch.object(sys, "argv", ["devcode", "open", "claude", "/"]):
-            with self.assertRaises(SystemExit):
-                devcode.main()
+        runner = CliRunner()
+        result = runner.invoke(devcode.cli, ["open", "/", "claude"])
+        self.assertNotEqual(result.exit_code, 0)
 
     def test_code_not_on_path_exits(self):
-        with patch.object(sys, "argv", ["devcode", "open", "claude", "/myproject"]):
+        runner = CliRunner()
+        with patch("os.path.exists", return_value=True):
             with patch.object(devcode, "_git_repo_root", return_value=None):
                 with patch("shutil.which", return_value=None):
-                    with self.assertRaises(SystemExit):
-                        devcode.main()
+                    result = runner.invoke(devcode.cli, ["open", "/myproject", "claude"])
+        self.assertNotEqual(result.exit_code, 0)
 
     def test_launches_vscode_with_folder_uri(self):
         launched = []
@@ -557,13 +711,15 @@ def fake_popen(cmd, **kw):
             launched.append(cmd)
             return MagicMock()
 
-        with patch.object(sys, "argv", ["devcode", "open", "claude", "/myproject"]):
+        runner = CliRunner()
+        with patch("os.path.exists", return_value=True):
             with patch("shutil.which", return_value="/usr/bin/code"):
                 with patch.object(devcode, "_git_repo_root", return_value=None):
                     with patch("subprocess.Popen", side_effect=fake_popen):
                         with patch.object(devcode, "run_post_launch"):
-                            devcode.main()
+                            result = runner.invoke(devcode.cli, ["open", "/myproject", "claude"])
 
+        self.assertEqual(result.exit_code, 0)
         self.assertEqual(len(launched), 1)
         self.assertEqual(launched[0][0], "code")
         self.assertEqual(launched[0][1], "--folder-uri")
@@ -575,13 +731,15 @@ def fake_popen(cmd, **kw):
             launched.append(cmd)
             return MagicMock()
 
-        with patch.object(sys, "argv", ["devcode", "open", "claude", "/myproject"]):
+        runner = CliRunner()
+        with patch("os.path.exists", return_value=True):
             with patch("shutil.which", return_value="/usr/bin/code"):
                 with patch.object(devcode, "_git_repo_root", return_value=None):
                     with patch("subprocess.Popen", side_effect=fake_popen):
                         with patch.object(devcode, "run_post_launch"):
-                            devcode.main()
+                            result = runner.invoke(devcode.cli, ["open", "/myproject", "claude"])
 
+        self.assertEqual(result.exit_code, 0)
         self.assertIn("/workspaces/myproject", launched[0][2])
 
     def test_custom_container_folder(self):
@@ -590,13 +748,18 @@ def fake_popen(cmd, **kw):
             launched.append(cmd)
             return MagicMock()
 
-        with patch.object(sys, "argv", ["devcode", "open", "claude", "/myproject", "--container-folder", "/workspace/custom"]):
+        runner = CliRunner()
+        with patch("os.path.exists", return_value=True):
             with patch("shutil.which", return_value="/usr/bin/code"):
                 with patch.object(devcode, "_git_repo_root", return_value=None):
                     with patch("subprocess.Popen", side_effect=fake_popen):
                         with patch.object(devcode, "run_post_launch"):
-                            devcode.main()
+                            result = runner.invoke(
+                                devcode.cli,
+                                ["open", "/myproject", "claude", "--container-folder", "/workspace/custom"]
+                            )
 
+        self.assertEqual(result.exit_code, 0)
         self.assertIn("/workspace/custom", launched[0][2])
 
     def test_timeout_passed_to_run_post_launch(self):
@@ -604,13 +767,18 @@ def test_timeout_passed_to_run_post_launch(self):
         def fake_rpl(config_file, project_path, timeout):
             captured["timeout"] = timeout
 
-        with patch.object(sys, "argv", ["devcode", "open", "claude", "/myproject", "--timeout", "42"]):
+        runner = CliRunner()
+        with patch("os.path.exists", return_value=True):
             with patch("shutil.which", return_value="/usr/bin/code"):
                 with patch.object(devcode, "_git_repo_root", return_value=None):
                     with patch("subprocess.Popen", return_value=MagicMock()):
                         with patch.object(devcode, "run_post_launch", side_effect=fake_rpl):
-                            devcode.main()
+                            result = runner.invoke(
+                                devcode.cli,
+                                ["open", "/myproject", "claude", "--timeout", "42"]
+                            )
 
+        self.assertEqual(result.exit_code, 0)
         self.assertEqual(captured["timeout"], 42)
 
     def test_default_timeout_is_300(self):
@@ -618,13 +786,15 @@ def test_default_timeout_is_300(self):
         def fake_rpl(config_file, project_path, timeout):
             captured["timeout"] = timeout
 
-        with patch.object(sys, "argv", ["devcode", "open", "claude", "/myproject"]):
+        runner = CliRunner()
+        with patch("os.path.exists", return_value=True):
             with patch("shutil.which", return_value="/usr/bin/code"):
                 with patch.object(devcode, "_git_repo_root", return_value=None):
                     with patch("subprocess.Popen", return_value=MagicMock()):
                         with patch.object(devcode, "run_post_launch", side_effect=fake_rpl):
-                            devcode.main()
+                            result = runner.invoke(devcode.cli, ["open", "/myproject", "claude"])
 
+        self.assertEqual(result.exit_code, 0)
         self.assertEqual(captured["timeout"], 300)
 
 
@@ -634,37 +804,47 @@ def setUp(self):
         tpl = os.path.join(self.tmpdir, "claude", ".devcontainer")
         os.makedirs(tpl)
         open(os.path.join(tpl, "devcontainer.json"), "w").close()
-        self.env_patch = patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": self.tmpdir})
-        self.env_patch.start()
+        self.patch_settings = patch.object(devcode, "_load_settings", return_value={"template_sources": [self.tmpdir]})
+        self.patch_settings.start()
+        # Snapshot logger handlers so we can restore after CliRunner calls install one
+        self._logger_handlers = list(devcode.logger.handlers)
 
     def tearDown(self):
-        self.env_patch.stop()
+        self.patch_settings.stop()
         shutil.rmtree(self.tmpdir, ignore_errors=True)
+        # Remove any logger handlers added during the test (CliRunner installs a StreamHandler
+        # pointing at its fake stderr; that stream becomes invalid after CliRunner exits)
+        devcode.logger.handlers[:] = self._logger_handlers
 
     def test_subdir_of_git_repo_exits(self):
         """Guard fires when git root differs from project_path."""
-        with patch.object(sys, "argv", ["devcode", "open", "claude", "/repo/subproject"]):
+        runner = CliRunner()
+        with patch("os.path.exists", return_value=True):
             with patch.object(devcode, "_git_repo_root", return_value="/repo"):
-                with self.assertRaises(SystemExit):
-                    devcode.main()
+                result = runner.invoke(devcode.cli, ["open", "/repo/subproject", "claude"])
+        self.assertNotEqual(result.exit_code, 0)
 
     def test_project_is_git_root_does_not_exit(self):
         """Guard does not fire when project_path IS the git root."""
-        with patch.object(sys, "argv", ["devcode", "open", "claude", "/repo"]):
+        runner = CliRunner()
+        with patch("os.path.exists", return_value=True):
             with patch.object(devcode, "_git_repo_root", return_value="/repo"):
                 with patch("shutil.which", return_value="/usr/bin/code"):
                     with patch("subprocess.Popen", return_value=MagicMock()):
                         with patch.object(devcode, "run_post_launch"):
-                            devcode.main()  # must not raise
+                            result = runner.invoke(devcode.cli, ["open", "/repo", "claude"])
+        self.assertEqual(result.exit_code, 0)
 
     def test_not_in_git_repo_does_not_exit(self):
         """Guard does not fire when _git_repo_root returns None."""
-        with patch.object(sys, "argv", ["devcode", "open", "claude", "/myproject"]):
+        runner = CliRunner()
+        with patch("os.path.exists", return_value=True):
             with patch.object(devcode, "_git_repo_root", return_value=None):
                 with patch("shutil.which", return_value="/usr/bin/code"):
                     with patch("subprocess.Popen", return_value=MagicMock()):
                         with patch.object(devcode, "run_post_launch"):
-                            devcode.main()  # must not raise
+                            result = runner.invoke(devcode.cli, ["open", "/myproject", "claude"])
+        self.assertEqual(result.exit_code, 0)
 
     def test_git_not_available_does_not_exit(self):
         """_git_repo_root returns None when git is unavailable (OSError)."""
@@ -1115,10 +1295,10 @@ def _make_template_with_name(self, base_dir, template_name, devcontainer_name):
 
     def _run_list(self, search_path, long=False):
         lines = []
-        with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": search_path}):
-            args = MagicMock(subcommand="list", verbose=False, long=long)
+        dirs = [d for d in search_path.split(os.pathsep) if d]
+        with patch.object(devcode, "_load_settings", return_value={"template_sources": dirs}):
             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.cmd_list(args)
+                devcode.list_command.callback(long=long)
         return lines
 
     def test_short_lists_user_templates(self):
@@ -1257,12 +1437,9 @@ def test_creates_template_from_default_base_legacy_env(self):
         with tempfile.TemporaryDirectory() as pkg_dir:
             self._setup_pkg(pkg_dir)
             with tempfile.TemporaryDirectory() as user_dir:
-                args = MagicMock(subcommand="new", verbose=False,
-                                 base=None, edit=False)
-                args.name = "myapp"
-                with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": user_dir}):
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
                     with patch.object(devcode, "__file__", os.path.join(pkg_dir, "devcode.py")):
-                        devcode.cmd_new(args)
+                        devcode.new_command.callback(name="myapp", base=None, edit=False)
                 self.assertTrue(os.path.isdir(os.path.join(user_dir, "myapp")))
 
     def test_creates_template_from_explicit_base(self):
@@ -1272,60 +1449,45 @@ def test_creates_template_from_explicit_base(self):
             os.makedirs(base_path)
             open(os.path.join(base_path, "devcontainer.json"), "w").close()
 
-            args = MagicMock(subcommand="new", verbose=False,
-                             base="mybase", edit=False)
-            args.name = "myapp"
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": user_dir}):
-                devcode.cmd_new(args)
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
+                devcode.new_command.callback(name="myapp", base="mybase", edit=False)
             self.assertTrue(os.path.isdir(os.path.join(user_dir, "myapp")))
 
     def test_exits_if_name_already_exists(self):
         with tempfile.TemporaryDirectory() as user_dir:
             existing = os.path.join(user_dir, "myapp")
             os.makedirs(existing)
-            args = MagicMock(subcommand="new", verbose=False,
-                             base=None, edit=False)
-            args.name = "myapp"
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": user_dir}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
                 with self.assertRaises(SystemExit):
-                    devcode.cmd_new(args)
+                    devcode.new_command.callback(name="myapp", base=None, edit=False)
 
     def test_exits_if_base_not_found(self):
         with tempfile.TemporaryDirectory() as pkg_dir:
             with tempfile.TemporaryDirectory() as user_dir:
-                args = MagicMock(subcommand="new", verbose=False,
-                                 base="no-such-base", edit=False)
-                args.name = "myapp"
-                with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": user_dir}):
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
                     with patch.object(devcode, "__file__", os.path.join(pkg_dir, "devcode.py")):
                         with self.assertRaises(SystemExit):
-                            devcode.cmd_new(args)
+                            devcode.new_command.callback(name="myapp", base="no-such-base", edit=False)
 
-    def test_edit_flag_calls_cmd_open(self):
+    def test_edit_flag_calls_do_open(self):
         with tempfile.TemporaryDirectory() as pkg_dir:
             self._setup_pkg(pkg_dir)
             with tempfile.TemporaryDirectory() as user_dir:
-                args = MagicMock(subcommand="new", verbose=False,
-                                 base=None, edit=True)
-                args.name = "myapp"
-                with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": user_dir}):
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
                     with patch.object(devcode, "__file__", os.path.join(pkg_dir, "devcode.py")):
-                        with patch.object(devcode, "cmd_open") as mock_open:
-                            devcode.cmd_new(args)
+                        with patch.object(devcode, "_do_open") as mock_open:
+                            devcode.new_command.callback(name="myapp", base=None, edit=True)
                 mock_open.assert_called_once()
-                call_args = mock_open.call_args[0][0]
-                self.assertEqual(call_args.template, "myapp")
-                self.assertEqual(call_args.projectpath, os.path.join(user_dir, "myapp"))
+                self.assertEqual(mock_open.call_args.kwargs["template"], "myapp")
+                self.assertEqual(mock_open.call_args.kwargs["projectpath"], os.path.join(user_dir, "myapp"))
 
     def test_creates_template_from_default_base(self):
         with tempfile.TemporaryDirectory() as pkg_dir:
             self._setup_pkg(pkg_dir)
             with tempfile.TemporaryDirectory() as user_dir:
-                args = MagicMock(subcommand="new", verbose=False, base=None, edit=False)
-                args.name = "myapp"
-                with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": user_dir}):
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
                     with patch.object(devcode, "__file__", os.path.join(pkg_dir, "devcode.py")):
-                        devcode.cmd_new(args)
+                        devcode.new_command.callback(name="myapp", base=None, edit=False)
                 self.assertTrue(os.path.isdir(os.path.join(user_dir, "myapp")))
 
     def test_base_found_in_second_search_dir(self):
@@ -1334,10 +1496,8 @@ def test_base_found_in_second_search_dir(self):
                 base = os.path.join(d2, "mybase", ".devcontainer")
                 os.makedirs(base)
                 open(os.path.join(base, "devcontainer.json"), "w").close()
-                args = MagicMock(subcommand="new", verbose=False, base="mybase", edit=False)
-                args.name = "myapp"
-                with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": os.pathsep.join([d1, d2])}):
-                    devcode.cmd_new(args)
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [d1, d2]}):
+                    devcode.new_command.callback(name="myapp", base="mybase", edit=False)
                 # writes to first dir
                 self.assertTrue(os.path.isdir(os.path.join(d1, "myapp")))
 
@@ -1353,44 +1513,39 @@ def _make_template(self, base_dir, name):
     def test_named_template_opens_root_in_code(self):
         with tempfile.TemporaryDirectory() as d:
             root = self._make_template(d, "mytemplate")
-            args = MagicMock(subcommand="edit", verbose=False, template="mytemplate")
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": d}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [d]}):
                 with patch("subprocess.run") as mock_run:
-                    devcode.cmd_edit(args)
+                    devcode.edit_command.callback(template="mytemplate")
             mock_run.assert_called_once_with(["code", root])
 
     def test_named_template_found_in_second_dir(self):
         with tempfile.TemporaryDirectory() as d1:
             with tempfile.TemporaryDirectory() as d2:
                 root = self._make_template(d2, "mytemplate")
-                args = MagicMock(subcommand="edit", verbose=False, template="mytemplate")
-                with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": os.pathsep.join([d1, d2])}):
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [d1, d2]}):
                     with patch("subprocess.run") as mock_run:
-                        devcode.cmd_edit(args)
+                        devcode.edit_command.callback(template="mytemplate")
                 mock_run.assert_called_once_with(["code", root])
 
     def test_named_template_not_found_exits(self):
         with tempfile.TemporaryDirectory() as d:
-            args = MagicMock(subcommand="edit", verbose=False, template="no-such")
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": d}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [d]}):
                 with self.assertRaises(SystemExit):
-                    devcode.cmd_edit(args)
+                    devcode.edit_command.callback(template="no-such")
 
-    def test_no_arg_is_argparse_error(self):
-        """edit requires a template argument; omitting it should exit with code 2."""
-        with self.assertRaises(SystemExit) as ctx:
-            with patch("sys.argv", ["devcode", "edit"]):
-                devcode.main()
-        self.assertEqual(ctx.exception.code, 2)
+    def test_no_arg_is_missing_argument_error(self):
+        """edit requires a template argument; omitting it should exit non-zero."""
+        runner = CliRunner()
+        result = runner.invoke(devcode.cli, ["edit"])
+        self.assertNotEqual(result.exit_code, 0)
 
-    def test_does_not_call_cmd_open(self):
+    def test_does_not_call_do_open(self):
         with tempfile.TemporaryDirectory() as d:
             self._make_template(d, "mytemplate")
-            args = MagicMock(subcommand="edit", verbose=False, template="mytemplate")
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": d}):
-                with patch.object(devcode, "cmd_open") as mock_open:
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [d]}):
+                with patch.object(devcode, "_do_open") as mock_open:
                     with patch("subprocess.run"):
-                        devcode.cmd_edit(args)
+                        devcode.edit_command.callback(template="mytemplate")
             mock_open.assert_not_called()
 
 
@@ -1418,9 +1573,8 @@ def test_lists_containers(self):
         mock_result = MagicMock(returncode=0, stdout=self._docker_output(rows))
         lines = []
         with patch("subprocess.run", return_value=mock_result):
-            args = MagicMock(subcommand="ps", verbose=False, all=False, interactive=False)
             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.cmd_ps(args)
+                devcode.ps_command.callback(show_all=False, interactive=False)
         combined = "\n".join(lines)
         self.assertIn("claude", combined)
         self.assertIn("abc123def456", combined)
@@ -1431,17 +1585,15 @@ def test_no_containers_message(self):
         mock_result = MagicMock(returncode=0, stdout="")
         lines = []
         with patch("subprocess.run", return_value=mock_result):
-            args = MagicMock(subcommand="ps", verbose=False, all=False, interactive=False)
             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.cmd_ps(args)
+                devcode.ps_command.callback(show_all=False, interactive=False)
         self.assertTrue(any("no running devcontainers" in str(l) for l in lines))
 
     def test_docker_unavailable_exits(self):
         mock_result = MagicMock(returncode=1, stdout="")
         with patch("subprocess.run", return_value=mock_result):
-            args = MagicMock(subcommand="ps", verbose=False, all=False, interactive=False)
             with self.assertRaises(SystemExit):
-                devcode.cmd_ps(args)
+                devcode.ps_command.callback(show_all=False, interactive=False)
 
     def test_malformed_row_skipped(self):
         # A row with fewer than 4 fields after dropping CreatedAt should be skipped silently
@@ -1451,9 +1603,8 @@ def test_malformed_row_skipped(self):
         mock_result = MagicMock(returncode=0, stdout=stdout)
         lines = []
         with patch("subprocess.run", return_value=mock_result):
-            args = MagicMock(subcommand="ps", verbose=False, all=False, interactive=False)
             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.cmd_ps(args)  # must not raise
+                devcode.ps_command.callback(show_all=False, interactive=False)  # must not raise
         combined = "\n".join(lines)
         self.assertIn("bbb222", combined)  # good row shown
         self.assertNotIn("abc123", combined)  # malformed row skipped
@@ -1470,9 +1621,8 @@ def test_all_flag_includes_stopped(self):
         mock_result = MagicMock(returncode=0, stdout=self._docker_output(rows))
         lines = []
         with patch("subprocess.run", return_value=mock_result):
-            args = MagicMock(subcommand="ps", verbose=False, all=True, interactive=False)
             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.cmd_ps(args)
+                devcode.ps_command.callback(show_all=True, interactive=False)
         combined = "\n".join(lines)
         self.assertIn("aaa111", combined)   # stopped container included
         self.assertIn("bbb222", combined)   # running container included
@@ -1489,9 +1639,8 @@ def test_no_all_flag_excludes_stopped(self):
         mock_result = MagicMock(returncode=0, stdout=self._docker_output(rows))
         lines = []
         with patch("subprocess.run", return_value=mock_result):
-            args = MagicMock(subcommand="ps", verbose=False, all=False, interactive=False)
             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.cmd_ps(args)
+                devcode.ps_command.callback(show_all=False, interactive=False)
         combined = "\n".join(lines)
         self.assertNotIn("aaa111", combined)   # stopped excluded
         self.assertIn("bbb222", combined)      # running shown
@@ -1500,12 +1649,11 @@ def test_all_flag_empty_message(self):
         mock_result = MagicMock(returncode=0, stdout="")
         lines = []
         with patch("subprocess.run", return_value=mock_result):
-            args = MagicMock(subcommand="ps", verbose=False, all=True, interactive=False)
             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.cmd_ps(args)
+                devcode.ps_command.callback(show_all=True, interactive=False)
         self.assertTrue(any("no devcontainers" in str(l) and "running" not in str(l) for l in lines))
 
-    def test_interactive_valid_selection_calls_cmd_open(self):
+    def test_interactive_valid_selection_opens_container(self):
         rows = [
             ("2026-03-24 10:00:00 +0000 UTC", "abc123def456", "/home/user/myapp",
              "/home/user/.local/share/dev-code/templates/python/.devcontainer/devcontainer.json",
@@ -1518,16 +1666,15 @@ def test_interactive_valid_selection_calls_cmd_open(self):
         )
         with patch("subprocess.run", side_effect=[ls_result, inspect_result]):
             with patch("builtins.input", return_value="1"):
-                with patch("devcode.cmd_open") as mock_open:
-                    args = MagicMock(subcommand="ps", verbose=False, all=False, interactive=True)
-                    devcode.cmd_ps(args)
-        mock_open.assert_called_once()
-        call_args = mock_open.call_args[0][0]
-        self.assertEqual(call_args.template, "/home/user/.local/share/dev-code/templates/python/.devcontainer/devcontainer.json")
-        self.assertEqual(call_args.projectpath, "/home/user/myapp")
-        self.assertEqual(call_args.container_folder, "/workspaces/myapp")
-        self.assertEqual(call_args.timeout, 300)
-        self.assertFalse(call_args.dry_run)
+                with patch("devcode._do_open") as mock_open:
+                    devcode.ps_command.callback(show_all=False, interactive=True)
+        mock_open.assert_called_once_with(
+            projectpath="/home/user/myapp",
+            template="/home/user/.local/share/dev-code/templates/python/.devcontainer/devcontainer.json",
+            container_folder="/workspaces/myapp",
+            timeout=300,
+            dry_run=False,
+        )
 
     def test_interactive_mount_fallback(self):
         rows = [
@@ -1543,11 +1690,9 @@ def test_interactive_mount_fallback(self):
         )
         with patch("subprocess.run", side_effect=[ls_result, inspect_result]):
             with patch("builtins.input", return_value="1"):
-                with patch("devcode.cmd_open") as mock_open:
-                    args = MagicMock(subcommand="ps", verbose=False, all=False, interactive=True)
-                    devcode.cmd_ps(args)
-        call_args = mock_open.call_args[0][0]
-        self.assertEqual(call_args.container_folder, "/workspaces/myapp")  # fallback
+                with patch("devcode._do_open") as mock_open:
+                    devcode.ps_command.callback(show_all=False, interactive=True)
+        self.assertEqual(mock_open.call_args.kwargs["container_folder"], "/workspaces/myapp")
 
     def test_interactive_invalid_selection_exits(self):
         rows = [
@@ -1558,9 +1703,8 @@ def test_interactive_invalid_selection_exits(self):
         ls_result = MagicMock(returncode=0, stdout=self._docker_output(rows))
         with patch("subprocess.run", return_value=ls_result):
             with patch("builtins.input", return_value="99"):
-                args = MagicMock(subcommand="ps", verbose=False, all=False, interactive=True)
                 with self.assertRaises(SystemExit):
-                    devcode.cmd_ps(args)
+                    devcode.ps_command.callback(show_all=False, interactive=True)
 
     def test_interactive_non_integer_exits(self):
         rows = [
@@ -1571,9 +1715,8 @@ def test_interactive_non_integer_exits(self):
         ls_result = MagicMock(returncode=0, stdout=self._docker_output(rows))
         with patch("subprocess.run", return_value=ls_result):
             with patch("builtins.input", return_value="abc"):
-                args = MagicMock(subcommand="ps", verbose=False, all=False, interactive=True)
                 with self.assertRaises(SystemExit):
-                    devcode.cmd_ps(args)
+                    devcode.ps_command.callback(show_all=False, interactive=True)
 
     def test_interactive_missing_config_label_exits(self):
         rows = [
@@ -1584,17 +1727,15 @@ def test_interactive_missing_config_label_exits(self):
         ls_result = MagicMock(returncode=0, stdout=self._docker_output(rows))
         with patch("subprocess.run", return_value=ls_result):
             with patch("builtins.input", return_value="1"):
-                args = MagicMock(subcommand="ps", verbose=False, all=False, interactive=True)
                 with self.assertRaises(SystemExit):
-                    devcode.cmd_ps(args)
+                    devcode.ps_command.callback(show_all=False, interactive=True)
 
     def test_interactive_empty_table_no_prompt(self):
         ls_result = MagicMock(returncode=0, stdout="")
         prompted = []
         with patch("subprocess.run", return_value=ls_result):
             with patch("builtins.input", side_effect=lambda _: prompted.append(True) or "1"):
-                args = MagicMock(subcommand="ps", verbose=False, all=False, interactive=True)
-                devcode.cmd_ps(args)
+                devcode.ps_command.callback(show_all=False, interactive=True)
         self.assertEqual(prompted, [])   # input() was never called
 
     def test_interactive_all_with_malformed_row_correct_selection(self):
@@ -1606,12 +1747,10 @@ def test_interactive_all_with_malformed_row_correct_selection(self):
         inspect_result = MagicMock(returncode=0, stdout='[]')
         with patch("subprocess.run", side_effect=[ls_result, inspect_result]):
             with patch("builtins.input", return_value="1"):
-                with patch("devcode.cmd_open") as mock_open:
-                    args = MagicMock(subcommand="ps", verbose=False, all=True, interactive=True)
-                    devcode.cmd_ps(args)
+                with patch("devcode._do_open") as mock_open:
+                    devcode.ps_command.callback(show_all=True, interactive=True)
         mock_open.assert_called_once()
-        call_args = mock_open.call_args[0][0]
-        self.assertEqual(call_args.projectpath, "/home/user/myapp")  # good row, not malformed
+        self.assertEqual(mock_open.call_args.kwargs["projectpath"], "/home/user/myapp")
 
     def test_sort_ascending_by_created_at(self):
         # Docker returns rows newest-first; cmd_ps must reorder oldest-first
@@ -1626,9 +1765,8 @@ def test_sort_ascending_by_created_at(self):
         mock_result = MagicMock(returncode=0, stdout=self._docker_output(rows))
         lines = []
         with patch("subprocess.run", return_value=mock_result):
-            args = MagicMock(subcommand="ps", verbose=False, all=False, interactive=False)
             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.cmd_ps(args)
+                devcode.ps_command.callback(show_all=False, interactive=False)
         # Find data rows (skip header)
         data_rows = [l for l in lines if "older222" in l or "newer111" in l]
         self.assertEqual(len(data_rows), 2)
@@ -1640,6 +1778,18 @@ def test_sort_ascending_by_created_at(self):
         self.assertIn("1", lines[idx_older])
 
 
+class TestDoOpen(unittest.TestCase):
+    def test_errors_on_nonexistent_projectpath(self):
+        with self.assertRaises(SystemExit):
+            devcode._do_open(
+                projectpath="/nonexistent/path/xyz123",
+                template="mytemplate",
+                container_folder=None,
+                timeout=300,
+                dry_run=False,
+            )
+
+
 class TestCmdOpenDryRun(unittest.TestCase):
     def _make_template(self, base_dir, name, cp_entries=None):
         """Create template with optional cp entries in devcontainer.json."""
@@ -1653,17 +1803,11 @@ def _make_template(self, base_dir, name, cp_entries=None):
 
     def _run_dry_run(self, user_dir, template, projectpath, container_folder=None):
         lines = []
-        args = argparse.Namespace(
-            template=template,
-            projectpath=projectpath,
-            container_folder=container_folder,
-            timeout=300,
-            dry_run=True,
-            verbose=False,
-        )
-        with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": user_dir}):
-            with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.cmd_open(args)
+        with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
+            with patch("os.path.exists", return_value=True):
+                with patch.object(devcode, "_git_repo_root", return_value=None):
+                    with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
+                        devcode._do_open(projectpath, template, container_folder, 300, True)
         return lines
 
     def test_prints_config_and_uri(self):
@@ -1716,29 +1860,23 @@ def test_unset_env_var_shown_as_placeholder(self):
                 {"source": "${localEnv:NONEXISTENT_VAR_XYZ}", "target": "/home/vscode/x"}
             ])
             with patch.dict(os.environ, env_clean, clear=True):
-                with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": user_dir}):
-                    lines = []
-                    args = argparse.Namespace(template="mytemplate", projectpath="/myproject",
-                                              container_folder=None, timeout=300, dry_run=True,
-                                              verbose=False)
-                    with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                        devcode.cmd_open(args)
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
+                    with patch("os.path.exists", return_value=True):
+                        with patch.object(devcode, "_git_repo_root", return_value=None):
+                            lines = []
+                            with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
+                                devcode._do_open("/myproject", "mytemplate", None, 300, True)
         combined = "\n".join(lines)
         self.assertIn("<unset:", combined)
 
 
 class TestBanner(unittest.TestCase):
     def test_help_contains_tagline(self):
-        """Banner tagline appears in --help output.
-        Uses subprocess to avoid argparse SystemExit contaminating the test runner.
-        """
-        result = subprocess.run(
-            ["uv", "run", "python", "src/devcode.py", "--help"],
-            capture_output=True, text=True, encoding="utf-8",
-            cwd=os.path.join(os.path.dirname(__file__), ".."),
-        )
-        self.assertEqual(result.returncode, 0, result.stderr)
-        self.assertIn("project · editor · container — simplified", result.stdout)
+        """Banner tagline appears in --help output."""
+        runner = CliRunner()
+        result = runner.invoke(devcode.cli, ["--help"])
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("project · editor · container", result.output)
 
 
 class TestListTemplateNames(unittest.TestCase):
@@ -1798,188 +1936,71 @@ def test_does_not_include_builtins(self):
                         names = devcode._list_template_names()
         self.assertEqual(names, [])
 
-class TestCmdComplete(unittest.TestCase):
-    def _run(self, cword_index, words, template_names=None):
-        """Run cmd_completion --complete path, capture printed lines, assert exit code 0."""
-        if template_names is None:
-            template_names = []
-        # --complete receives [cword_index_str, *words] as complete_words
-        args = argparse.Namespace(complete_words=[str(cword_index)] + words, shell=None)
-        captured = []
-        with patch.object(devcode, "_list_template_names", return_value=template_names):
-            with patch("builtins.print", side_effect=lambda x: captured.append(x)):
-                with self.assertRaises(SystemExit) as cm:
-                    devcode.cmd_completion(args)
-        self.assertEqual(cm.exception.code, 0)
-        return captured
-
-    def test_completing_subcommand_returns_all_subcommands(self):
-        result = self._run(1, ["devcode", ""])
-        for sub in ("open", "new", "edit", "list", "ps", "completion"):
-            self.assertIn(sub, result)
-        self.assertNotIn("init", result)
-
-    def test_prefix_filters_subcommands(self):
-        result = self._run(1, ["devcode", "op"])
-        self.assertEqual(result, ["open"])
-
-    def test_open_index2_returns_template_names(self):
-        result = self._run(2, ["devcode", "open", ""], template_names=["alpha", "beta"])
-        self.assertIn("alpha", result)
-        self.assertIn("beta", result)
-
-    def test_open_index2_prefix_filters_templates(self):
-        result = self._run(2, ["devcode", "open", "al"], template_names=["alpha", "beta"])
-        self.assertEqual(result, ["alpha"])
-
-    def test_open_index3_returns_empty(self):
-        result = self._run(3, ["devcode", "open", "mytemplate", ""])
-        self.assertEqual(result, [])
-
-    def test_open_index4_returns_empty(self):
-        result = self._run(4, ["devcode", "open", "mytemplate", "/path", ""])
-        self.assertEqual(result, [])
-
-    def test_open_flag_completion_at_index3(self):
-        result = self._run(3, ["devcode", "open", "mytemplate", "--"])
-        self.assertIn("--dry-run", result)
-        self.assertIn("--container-folder", result)
-        self.assertIn("--timeout", result)
-
-    def test_open_flag_completion_at_index2(self):
-        result = self._run(2, ["devcode", "open", "--"])
-        self.assertIn("--dry-run", result)
-
-    def test_new_index2_returns_empty(self):
-        result = self._run(2, ["devcode", "new", ""])
-        self.assertEqual(result, [])
-
-    def test_new_index3_returns_template_names(self):
-        result = self._run(3, ["devcode", "new", "myname", ""], template_names=["base1"])
-        self.assertIn("base1", result)
-
-    def test_new_flag_completion(self):
-        result = self._run(2, ["devcode", "new", "--"])
-        self.assertEqual(result, ["--edit"])
-
-    def test_edit_index2_returns_template_names(self):
-        result = self._run(2, ["devcode", "edit", ""], template_names=["mytemplate"])
-        self.assertIn("mytemplate", result)
-
-    def test_edit_index3_returns_empty(self):
-        result = self._run(3, ["devcode", "edit", "mytemplate", ""])
-        self.assertEqual(result, [])
-
-    def test_edit_flag_returns_empty(self):
-        result = self._run(2, ["devcode", "edit", "--"])
-        self.assertEqual(result, [])
-
-    def test_list_index2_returns_long(self):
-        result = self._run(2, ["devcode", "list", ""])
-        self.assertEqual(result, ["--long"])
-
-    def test_list_higher_index_returns_long(self):
-        result = self._run(3, ["devcode", "list", "--long", ""])
-        self.assertEqual(result, ["--long"])
-
-    def test_list_prefix_filter_long(self):
-        result = self._run(2, ["devcode", "list", "--l"])
-        self.assertEqual(result, ["--long"])
-
-    def test_list_partial_word_no_match_returns_empty(self):
-        # list branch fires unconditionally; prefix filter removes --long when current_word="x"
-        result = self._run(2, ["devcode", "list", "x"])
-        self.assertEqual(result, [])
-
-    def test_ps_returns_empty(self):
-        result = self._run(2, ["devcode", "ps", ""])
-        self.assertEqual(result, [])
-
-    def test_ps_flags_completion(self):
-        result = self._run(2, ["devcode", "ps", "-"])
-        self.assertIn("-a", result)
-        self.assertIn("-i", result)
-
-    def test_completion_index2_returns_shells(self):
-        result = self._run(2, ["devcode", "completion", ""])
-        self.assertIn("bash", result)
-        self.assertIn("zsh", result)
-
-    def test_completion_index2_prefix_filter(self):
-        result = self._run(2, ["devcode", "completion", "b"])
-        self.assertEqual(result, ["bash"])
-
-    def test_completion_index3_returns_empty(self):
-        result = self._run(3, ["devcode", "completion", "bash", ""])
-        self.assertEqual(result, [])
-
-    def test_empty_complete_words_exits_zero_no_output(self):
-        args = argparse.Namespace(complete_words=[], shell=None)
-        captured = []
-        with patch("builtins.print", side_effect=lambda x: captured.append(x)):
-            with self.assertRaises(SystemExit) as cm:
-                devcode.cmd_completion(args)
-        self.assertEqual(cm.exception.code, 0)
-        self.assertEqual(captured, [])
-
-    def test_non_integer_cword_exits_zero_no_output(self):
-        args = argparse.Namespace(complete_words=["notanint", "dev-code", "open"], shell=None)
-        captured = []
-        with patch("builtins.print", side_effect=lambda x: captured.append(x)):
-            with self.assertRaises(SystemExit) as cm:
-                devcode.cmd_completion(args)
-        self.assertEqual(cm.exception.code, 0)
-        self.assertEqual(captured, [])
-
-    def test_out_of_range_cword_exits_zero_no_output(self):
-        args = argparse.Namespace(complete_words=["5", "dev-code", "open"], shell=None)
-        captured = []
-        with patch("builtins.print", side_effect=lambda x: captured.append(x)):
-            with self.assertRaises(SystemExit) as cm:
-                devcode.cmd_completion(args)
-        self.assertEqual(cm.exception.code, 0)
-        self.assertEqual(captured, [])
-
-    def test_cword_index0_returns_empty(self):
-        # index 0 is the command name slot — nothing to complete
-        result = self._run(0, ["devcode"])
+class TestClickCLI(unittest.TestCase):
+    def test_no_args_shows_banner(self):
+        runner = CliRunner()
+        result = runner.invoke(devcode.cli, [])
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("project · editor · container", result.output)
+
+    def test_version_flag(self):
+        runner = CliRunner()
+        result = runner.invoke(devcode.cli, ["--version"])
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("devcode", result.output)
+
+    def test_open_dry_run(self):
+        runner = CliRunner()
+        with runner.isolated_filesystem():
+            os.makedirs("mytemplate/.devcontainer")
+            with open("mytemplate/.devcontainer/devcontainer.json", "w") as f:
+                f.write('{"name": "test"}')
+            project = os.path.abspath(".")
+            with patch.object(devcode, "_load_settings",
+                               return_value={"template_sources": [os.path.abspath(".")]}):
+                with patch.object(devcode, "_git_repo_root", return_value=None):
+                    result = runner.invoke(
+                        devcode.cli, ["open", project, "mytemplate", "--dry-run"]
+                    )
+        self.assertEqual(result.exit_code, 0)
+
+    def test_list_command(self):
+        runner = CliRunner()
+        with patch.object(devcode, "_list_template_names", return_value=["tmpl-a", "tmpl-b"]):
+            result = runner.invoke(devcode.cli, ["list"])
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("tmpl-a", result.output)
+        self.assertIn("tmpl-b", result.output)
+
+    def test_new_command_unknown_base_exits(self):
+        runner = CliRunner()
+        with runner.isolated_filesystem():
+            with patch.object(devcode, "_load_settings",
+                               return_value={"template_sources": [os.path.abspath(".")]}):
+                result = runner.invoke(devcode.cli, ["new", "myapp", "no-such-base"])
+        self.assertNotEqual(result.exit_code, 0)
+
+    def test_ps_no_docker_exits(self):
+        runner = CliRunner()
+        with patch("subprocess.run", return_value=MagicMock(returncode=1, stdout="")):
+            result = runner.invoke(devcode.cli, ["ps"])
+        self.assertNotEqual(result.exit_code, 0)
+
+
+class TestCompleteTemplates(unittest.TestCase):
+    def test_returns_all_when_incomplete_is_empty(self):
+        with patch.object(devcode, "_list_template_names", return_value=["alpha", "beta", "gamma"]):
+            result = devcode._complete_templates(None, None, "")
+        names = [item.value for item in result]
+        self.assertEqual(sorted(names), ["alpha", "beta", "gamma"])
+
+    def test_filters_by_prefix(self):
+        with patch.object(devcode, "_list_template_names", return_value=["alpha", "beta", "gamma"]):
+            result = devcode._complete_templates(None, None, "al")
+        names = [item.value for item in result]
+        self.assertEqual(names, ["alpha"])
+
+    def test_returns_empty_when_no_match(self):
+        with patch.object(devcode, "_list_template_names", return_value=["alpha", "beta"]):
+            result = devcode._complete_templates(None, None, "z")
         self.assertEqual(result, [])
-
-
-class TestCmdCompletion(unittest.TestCase):
-    def _capture(self, shell):
-        args = argparse.Namespace(shell=shell, complete_words=None)
-        buf = io.StringIO()
-        with patch("builtins.print", side_effect=lambda *a, **kw: buf.write(a[0] if a else "")):
-            devcode.cmd_completion(args)
-        return buf.getvalue()
-
-    def test_bash_contains_function_name(self):
-        output = self._capture("bash")
-        self.assertIn("_dev_code", output)
-
-    def test_bash_contains_complete_registration(self):
-        output = self._capture("bash")
-        self.assertIn("complete -F", output)
-
-    def test_bash_contains_mapfile(self):
-        output = self._capture("bash")
-        self.assertIn("mapfile", output)
-
-    def test_zsh_contains_function_name(self):
-        output = self._capture("zsh")
-        self.assertIn("_dev_code", output)
-
-    def test_zsh_contains_compdef(self):
-        output = self._capture("zsh")
-        self.assertIn("compdef", output)
-
-    def test_zsh_contains_compinit_warning(self):
-        output = self._capture("zsh")
-        self.assertIn("compinit", output)
-
-    def test_unknown_shell_exits_1(self):
-        args = argparse.Namespace(shell="fish", complete_words=None)
-        with self.assertRaises(SystemExit) as cm:
-            devcode.cmd_completion(args)
-        self.assertEqual(cm.exception.code, 1)
diff --git a/tox.ini b/tox.ini
index c6704df..661c4f6 100644
--- a/tox.ini
+++ b/tox.ini
@@ -2,10 +2,6 @@
 envlist = py310, py311, py312, py313
 
 [testenv]
-skip_install = true
-deps =
-    pytest
-    pytest-cov
-    pyfiglet
+dependency_groups = test
 commands =
     pytest --cov=src --cov-report=term-missing --cov-report=xml
diff --git a/uv.lock b/uv.lock
deleted file mode 100644
index b822310..0000000
--- a/uv.lock
+++ /dev/null
@@ -1,479 +0,0 @@
-version = 1
-revision = 3
-requires-python = ">=3.10"
-
-[[package]]
-name = "cachetools"
-version = "7.0.5"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/dd/57fe3fdb6e65b25a5987fd2cdc7e22db0aef508b91634d2e57d22928d41b/cachetools-7.0.5.tar.gz", hash = "sha256:0cd042c24377200c1dcd225f8b7b12b0ca53cc2c961b43757e774ebe190fd990", size = 37367, upload-time = "2026-03-09T20:51:29.451Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/06/f3/39cf3367b8107baa44f861dc802cbf16263c945b62d8265d36034fc07bea/cachetools-7.0.5-py3-none-any.whl", hash = "sha256:46bc8ebefbe485407621d0a4264b23c080cedd913921bad7ac3ed2f26c183114", size = 13918, upload-time = "2026-03-09T20:51:27.33Z" },
-]
-
-[[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 = "coverage"
-version = "7.13.5"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/9d/e0/70553e3000e345daff267cec284ce4cbf3fc141b6da229ac52775b5428f1/coverage-7.13.5.tar.gz", hash = "sha256:c81f6515c4c40141f83f502b07bbfa5c240ba25bbe73da7b33f1e5b6120ff179", size = 915967, upload-time = "2026-03-17T10:33:18.341Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/69/33/e8c48488c29a73fd089f9d71f9653c1be7478f2ad6b5bc870db11a55d23d/coverage-7.13.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e0723d2c96324561b9aa76fb982406e11d93cdb388a7a7da2b16e04719cf7ca5", size = 219255, upload-time = "2026-03-17T10:29:51.081Z" },
-    { url = "https://files.pythonhosted.org/packages/da/bd/b0ebe9f677d7f4b74a3e115eec7ddd4bcf892074963a00d91e8b164a6386/coverage-7.13.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:52f444e86475992506b32d4e5ca55c24fc88d73bcbda0e9745095b28ef4dc0cf", size = 219772, upload-time = "2026-03-17T10:29:52.867Z" },
-    { url = "https://files.pythonhosted.org/packages/48/cc/5cb9502f4e01972f54eedd48218bb203fe81e294be606a2bc93970208013/coverage-7.13.5-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:704de6328e3d612a8f6c07000a878ff38181ec3263d5a11da1db294fa6a9bdf8", size = 246532, upload-time = "2026-03-17T10:29:54.688Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/d8/3217636d86c7e7b12e126e4f30ef1581047da73140614523af7495ed5f2d/coverage-7.13.5-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a1a6d79a14e1ec1832cabc833898636ad5f3754a678ef8bb4908515208bf84f4", size = 248333, upload-time = "2026-03-17T10:29:56.221Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/30/2002ac6729ba2d4357438e2ed3c447ad8562866c8c63fc16f6dfc33afe56/coverage-7.13.5-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:79060214983769c7ba3f0cee10b54c97609dca4d478fa1aa32b914480fd5738d", size = 250211, upload-time = "2026-03-17T10:29:57.938Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/85/552496626d6b9359eb0e2f86f920037c9cbfba09b24d914c6e1528155f7d/coverage-7.13.5-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:356e76b46783a98c2a2fe81ec79df4883a1e62895ea952968fb253c114e7f930", size = 252125, upload-time = "2026-03-17T10:29:59.388Z" },
-    { url = "https://files.pythonhosted.org/packages/44/21/40256eabdcbccdb6acf6b381b3016a154399a75fe39d406f790ae84d1f3c/coverage-7.13.5-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0cef0cdec915d11254a7f549c1170afecce708d30610c6abdded1f74e581666d", size = 247219, upload-time = "2026-03-17T10:30:01.199Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/e8/96e2a6c3f21a0ea77d7830b254a1542d0328acc8d7bdf6a284ba7e529f77/coverage-7.13.5-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:dc022073d063b25a402454e5712ef9e007113e3a676b96c5f29b2bda29352f40", size = 248248, upload-time = "2026-03-17T10:30:03.317Z" },
-    { url = "https://files.pythonhosted.org/packages/da/ba/8477f549e554827da390ec659f3c38e4b6d95470f4daafc2d8ff94eaa9c2/coverage-7.13.5-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:9b74db26dfea4f4e50d48a4602207cd1e78be33182bc9cbf22da94f332f99878", size = 246254, upload-time = "2026-03-17T10:30:04.832Z" },
-    { url = "https://files.pythonhosted.org/packages/55/59/bc22aef0e6aa179d5b1b001e8b3654785e9adf27ef24c93dc4228ebd5d68/coverage-7.13.5-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:ad146744ca4fd09b50c482650e3c1b1f4dfa1d4792e0a04a369c7f23336f0400", size = 250067, upload-time = "2026-03-17T10:30:06.535Z" },
-    { url = "https://files.pythonhosted.org/packages/de/1b/c6a023a160806a5137dca53468fd97530d6acad24a22003b1578a9c2e429/coverage-7.13.5-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:c555b48be1853fe3997c11c4bd521cdd9a9612352de01fa4508f16ec341e6fe0", size = 246521, upload-time = "2026-03-17T10:30:08.486Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/3f/3532c85a55aa2f899fa17c186f831cfa1aa434d88ff792a709636f64130e/coverage-7.13.5-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7034b5c56a58ae5e85f23949d52c14aca2cfc6848a31764995b7de88f13a1ea0", size = 247126, upload-time = "2026-03-17T10:30:09.966Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/2e/b9d56af4a24ef45dfbcda88e06870cb7d57b2b0bfa3a888d79b4c8debd76/coverage-7.13.5-cp310-cp310-win32.whl", hash = "sha256:eb7fdf1ef130660e7415e0253a01a7d5a88c9c4d158bcf75cbbd922fd65a5b58", size = 221860, upload-time = "2026-03-17T10:30:11.393Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/cc/d938417e7a4d7f0433ad4edee8bb2acdc60dc7ac5af19e2a07a048ecbee3/coverage-7.13.5-cp310-cp310-win_amd64.whl", hash = "sha256:3e1bb5f6c78feeb1be3475789b14a0f0a5b47d505bfc7267126ccbd50289999e", size = 222788, upload-time = "2026-03-17T10:30:12.886Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/37/d24c8f8220ff07b839b2c043ea4903a33b0f455abe673ae3c03bbdb7f212/coverage-7.13.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66a80c616f80181f4d643b0f9e709d97bcea413ecd9631e1dedc7401c8e6695d", size = 219381, upload-time = "2026-03-17T10:30:14.68Z" },
-    { url = "https://files.pythonhosted.org/packages/35/8b/cd129b0ca4afe886a6ce9d183c44d8301acbd4ef248622e7c49a23145605/coverage-7.13.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:145ede53ccbafb297c1c9287f788d1bc3efd6c900da23bf6931b09eafc931587", size = 219880, upload-time = "2026-03-17T10:30:16.231Z" },
-    { url = "https://files.pythonhosted.org/packages/55/2f/e0e5b237bffdb5d6c530ce87cc1d413a5b7d7dfd60fb067ad6d254c35c76/coverage-7.13.5-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0672854dc733c342fa3e957e0605256d2bf5934feeac328da9e0b5449634a642", size = 250303, upload-time = "2026-03-17T10:30:17.748Z" },
-    { url = "https://files.pythonhosted.org/packages/92/be/b1afb692be85b947f3401375851484496134c5554e67e822c35f28bf2fbc/coverage-7.13.5-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:ec10e2a42b41c923c2209b846126c6582db5e43a33157e9870ba9fb70dc7854b", size = 252218, upload-time = "2026-03-17T10:30:19.804Z" },
-    { url = "https://files.pythonhosted.org/packages/da/69/2f47bb6fa1b8d1e3e5d0c4be8ccb4313c63d742476a619418f85740d597b/coverage-7.13.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be3d4bbad9d4b037791794ddeedd7d64a56f5933a2c1373e18e9e568b9141686", size = 254326, upload-time = "2026-03-17T10:30:21.321Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/d0/79db81da58965bd29dabc8f4ad2a2af70611a57cba9d1ec006f072f30a54/coverage-7.13.5-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4d2afbc5cc54d286bfb54541aa50b64cdb07a718227168c87b9e2fb8f25e1743", size = 256267, upload-time = "2026-03-17T10:30:23.094Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/32/d0d7cc8168f91ddab44c0ce4806b969df5f5fdfdbb568eaca2dbc2a04936/coverage-7.13.5-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3ad050321264c49c2fa67bb599100456fc51d004b82534f379d16445da40fb75", size = 250430, upload-time = "2026-03-17T10:30:25.311Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/06/a055311d891ddbe231cd69fdd20ea4be6e3603ffebddf8704b8ca8e10a3c/coverage-7.13.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7300c8a6d13335b29bb76d7651c66af6bd8658517c43499f110ddc6717bfc209", size = 252017, upload-time = "2026-03-17T10:30:27.284Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/f6/d0fd2d21e29a657b5f77a2fe7082e1568158340dceb941954f776dce1b7b/coverage-7.13.5-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:eb07647a5738b89baab047f14edd18ded523de60f3b30e75c2acc826f79c839a", size = 250080, upload-time = "2026-03-17T10:30:29.481Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/ab/0d7fb2efc2e9a5eb7ddcc6e722f834a69b454b7e6e5888c3a8567ecffb31/coverage-7.13.5-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:9adb6688e3b53adffefd4a52d72cbd8b02602bfb8f74dcd862337182fd4d1a4e", size = 253843, upload-time = "2026-03-17T10:30:31.301Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/6f/7467b917bbf5408610178f62a49c0ed4377bb16c1657f689cc61470da8ce/coverage-7.13.5-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7c8d4bc913dd70b93488d6c496c77f3aff5ea99a07e36a18f865bca55adef8bd", size = 249802, upload-time = "2026-03-17T10:30:33.358Z" },
-    { url = "https://files.pythonhosted.org/packages/75/2c/1172fb689df92135f5bfbbd69fc83017a76d24ea2e2f3a1154007e2fb9f8/coverage-7.13.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0e3c426ffc4cd952f54ee9ffbdd10345709ecc78a3ecfd796a57236bfad0b9b8", size = 250707, upload-time = "2026-03-17T10:30:35.2Z" },
-    { url = "https://files.pythonhosted.org/packages/67/21/9ac389377380a07884e3b48ba7a620fcd9dbfaf1d40565facdc6b36ec9ef/coverage-7.13.5-cp311-cp311-win32.whl", hash = "sha256:259b69bb83ad9894c4b25be2528139eecba9a82646ebdda2d9db1ba28424a6bf", size = 221880, upload-time = "2026-03-17T10:30:36.775Z" },
-    { url = "https://files.pythonhosted.org/packages/af/7f/4cd8a92531253f9d7c1bbecd9fa1b472907fb54446ca768c59b531248dc5/coverage-7.13.5-cp311-cp311-win_amd64.whl", hash = "sha256:258354455f4e86e3e9d0d17571d522e13b4e1e19bf0f8596bcf9476d61e7d8a9", size = 222816, upload-time = "2026-03-17T10:30:38.891Z" },
-    { url = "https://files.pythonhosted.org/packages/12/a6/1d3f6155fb0010ca68eba7fe48ca6c9da7385058b77a95848710ecf189b1/coverage-7.13.5-cp311-cp311-win_arm64.whl", hash = "sha256:bff95879c33ec8da99fc9b6fe345ddb5be6414b41d6d1ad1c8f188d26f36e028", size = 221483, upload-time = "2026-03-17T10:30:40.463Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/c3/a396306ba7db865bf96fc1fb3b7fd29bcbf3d829df642e77b13555163cd6/coverage-7.13.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:460cf0114c5016fa841214ff5564aa4864f11948da9440bc97e21ad1f4ba1e01", size = 219554, upload-time = "2026-03-17T10:30:42.208Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/16/a68a19e5384e93f811dccc51034b1fd0b865841c390e3c931dcc4699e035/coverage-7.13.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0e223ce4b4ed47f065bfb123687686512e37629be25cc63728557ae7db261422", size = 219908, upload-time = "2026-03-17T10:30:43.906Z" },
-    { url = "https://files.pythonhosted.org/packages/29/72/20b917c6793af3a5ceb7fb9c50033f3ec7865f2911a1416b34a7cfa0813b/coverage-7.13.5-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:6e3370441f4513c6252bf042b9c36d22491142385049243253c7e48398a15a9f", size = 251419, upload-time = "2026-03-17T10:30:45.545Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/49/cd14b789536ac6a4778c453c6a2338bc0a2fb60c5a5a41b4008328b9acc1/coverage-7.13.5-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:03ccc709a17a1de074fb1d11f217342fb0d2b1582ed544f554fc9fc3f07e95f5", size = 254159, upload-time = "2026-03-17T10:30:47.204Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/00/7b0edcfe64e2ed4c0340dac14a52ad0f4c9bd0b8b5e531af7d55b703db7c/coverage-7.13.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3f4818d065964db3c1c66dc0fbdac5ac692ecbc875555e13374fdbe7eedb4376", size = 255270, upload-time = "2026-03-17T10:30:48.812Z" },
-    { url = "https://files.pythonhosted.org/packages/93/89/7ffc4ba0f5d0a55c1e84ea7cee39c9fc06af7b170513d83fbf3bbefce280/coverage-7.13.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:012d5319e66e9d5a218834642d6c35d265515a62f01157a45bcc036ecf947256", size = 257538, upload-time = "2026-03-17T10:30:50.77Z" },
-    { url = "https://files.pythonhosted.org/packages/81/bd/73ddf85f93f7e6fa83e77ccecb6162d9415c79007b4bc124008a4995e4a7/coverage-7.13.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8dd02af98971bdb956363e4827d34425cb3df19ee550ef92855b0acb9c7ce51c", size = 251821, upload-time = "2026-03-17T10:30:52.5Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/81/278aff4e8dec4926a0bcb9486320752811f543a3ce5b602cc7a29978d073/coverage-7.13.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f08fd75c50a760c7eb068ae823777268daaf16a80b918fa58eea888f8e3919f5", size = 253191, upload-time = "2026-03-17T10:30:54.543Z" },
-    { url = "https://files.pythonhosted.org/packages/70/ee/fe1621488e2e0a58d7e94c4800f0d96f79671553488d401a612bebae324b/coverage-7.13.5-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:843ea8643cf967d1ac7e8ecd4bb00c99135adf4816c0c0593fdcc47b597fcf09", size = 251337, upload-time = "2026-03-17T10:30:56.663Z" },
-    { url = "https://files.pythonhosted.org/packages/37/a6/f79fb37aa104b562207cc23cb5711ab6793608e246cae1e93f26b2236ed9/coverage-7.13.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:9d44d7aa963820b1b971dbecd90bfe5fe8f81cff79787eb6cca15750bd2f79b9", size = 255404, upload-time = "2026-03-17T10:30:58.427Z" },
-    { url = "https://files.pythonhosted.org/packages/75/f0/ed15262a58ec81ce457ceb717b7f78752a1713556b19081b76e90896e8d4/coverage-7.13.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7132bed4bd7b836200c591410ae7d97bf7ae8be6fc87d160b2bd881df929e7bf", size = 250903, upload-time = "2026-03-17T10:31:00.093Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/e9/9129958f20e7e9d4d56d51d42ccf708d15cac355ff4ac6e736e97a9393d2/coverage-7.13.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a698e363641b98843c517817db75373c83254781426e94ada3197cabbc2c919c", size = 252780, upload-time = "2026-03-17T10:31:01.916Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/d7/0ad9b15812d81272db94379fe4c6df8fd17781cc7671fdfa30c76ba5ff7b/coverage-7.13.5-cp312-cp312-win32.whl", hash = "sha256:bdba0a6b8812e8c7df002d908a9a2ea3c36e92611b5708633c50869e6d922fdf", size = 222093, upload-time = "2026-03-17T10:31:03.642Z" },
-    { url = "https://files.pythonhosted.org/packages/29/3d/821a9a5799fac2556bcf0bd37a70d1d11fa9e49784b6d22e92e8b2f85f18/coverage-7.13.5-cp312-cp312-win_amd64.whl", hash = "sha256:d2c87e0c473a10bffe991502eac389220533024c8082ec1ce849f4218dded810", size = 222900, upload-time = "2026-03-17T10:31:05.651Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/fa/2238c2ad08e35cf4f020ea721f717e09ec3152aea75d191a7faf3ef009a8/coverage-7.13.5-cp312-cp312-win_arm64.whl", hash = "sha256:bf69236a9a81bdca3bff53796237aab096cdbf8d78a66ad61e992d9dac7eb2de", size = 221515, upload-time = "2026-03-17T10:31:07.293Z" },
-    { url = "https://files.pythonhosted.org/packages/74/8c/74fedc9663dcf168b0a059d4ea756ecae4da77a489048f94b5f512a8d0b3/coverage-7.13.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5ec4af212df513e399cf11610cc27063f1586419e814755ab362e50a85ea69c1", size = 219576, upload-time = "2026-03-17T10:31:09.045Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/c9/44fb661c55062f0818a6ffd2685c67aa30816200d5f2817543717d4b92eb/coverage-7.13.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:941617e518602e2d64942c88ec8499f7fbd49d3f6c4327d3a71d43a1973032f3", size = 219942, upload-time = "2026-03-17T10:31:10.708Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/13/93419671cee82b780bab7ea96b67c8ef448f5f295f36bf5031154ec9a790/coverage-7.13.5-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:da305e9937617ee95c2e39d8ff9f040e0487cbf1ac174f777ed5eddd7a7c1f26", size = 250935, upload-time = "2026-03-17T10:31:12.392Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/68/1666e3a4462f8202d836920114fa7a5ee9275d1fa45366d336c551a162dd/coverage-7.13.5-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:78e696e1cc714e57e8b25760b33a8b1026b7048d270140d25dafe1b0a1ee05a3", size = 253541, upload-time = "2026-03-17T10:31:14.247Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/5e/3ee3b835647be646dcf3c65a7c6c18f87c27326a858f72ab22c12730773d/coverage-7.13.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:02ca0eed225b2ff301c474aeeeae27d26e2537942aa0f87491d3e147e784a82b", size = 254780, upload-time = "2026-03-17T10:31:16.193Z" },
-    { url = "https://files.pythonhosted.org/packages/44/b3/cb5bd1a04cfcc49ede6cd8409d80bee17661167686741e041abc7ee1b9a9/coverage-7.13.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:04690832cbea4e4663d9149e05dba142546ca05cb1848816760e7f58285c970a", size = 256912, upload-time = "2026-03-17T10:31:17.89Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/66/c1dceb7b9714473800b075f5c8a84f4588f887a90eb8645282031676e242/coverage-7.13.5-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0590e44dd2745c696a778f7bab6aa95256de2cbc8b8cff4f7db8ff09813d6969", size = 251165, upload-time = "2026-03-17T10:31:19.605Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/62/5502b73b97aa2e53ea22a39cf8649ff44827bef76d90bf638777daa27a9d/coverage-7.13.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d7cfad2d6d81dd298ab6b89fe72c3b7b05ec7544bdda3b707ddaecff8d25c161", size = 252908, upload-time = "2026-03-17T10:31:21.312Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/37/7792c2d69854397ca77a55c4646e5897c467928b0e27f2d235d83b5d08c6/coverage-7.13.5-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:e092b9499de38ae0fbfbc603a74660eb6ff3e869e507b50d85a13b6db9863e15", size = 250873, upload-time = "2026-03-17T10:31:23.565Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/23/bc866fb6163be52a8a9e5d708ba0d3b1283c12158cefca0a8bbb6e247a43/coverage-7.13.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:48c39bc4a04d983a54a705a6389512883d4a3b9862991b3617d547940e9f52b1", size = 255030, upload-time = "2026-03-17T10:31:25.58Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/8b/ef67e1c222ef49860701d346b8bbb70881bef283bd5f6cbba68a39a086c7/coverage-7.13.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2d3807015f138ffea1ed9afeeb8624fd781703f2858b62a8dd8da5a0994c57b6", size = 250694, upload-time = "2026-03-17T10:31:27.316Z" },
-    { url = "https://files.pythonhosted.org/packages/46/0d/866d1f74f0acddbb906db212e096dee77a8e2158ca5e6bb44729f9d93298/coverage-7.13.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ee2aa19e03161671ec964004fb74b2257805d9710bf14a5c704558b9d8dbaf17", size = 252469, upload-time = "2026-03-17T10:31:29.472Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/f5/be742fec31118f02ce42b21c6af187ad6a344fed546b56ca60caacc6a9a0/coverage-7.13.5-cp313-cp313-win32.whl", hash = "sha256:ce1998c0483007608c8382f4ff50164bfc5bd07a2246dd272aa4043b75e61e85", size = 222112, upload-time = "2026-03-17T10:31:31.526Z" },
-    { url = "https://files.pythonhosted.org/packages/66/40/7732d648ab9d069a46e686043241f01206348e2bbf128daea85be4d6414b/coverage-7.13.5-cp313-cp313-win_amd64.whl", hash = "sha256:631efb83f01569670a5e866ceb80fe483e7c159fac6f167e6571522636104a0b", size = 222923, upload-time = "2026-03-17T10:31:33.633Z" },
-    { url = "https://files.pythonhosted.org/packages/48/af/fea819c12a095781f6ccd504890aaddaf88b8fab263c4940e82c7b770124/coverage-7.13.5-cp313-cp313-win_arm64.whl", hash = "sha256:f4cd16206ad171cbc2470dbea9103cf9a7607d5fe8c242fdf1edf36174020664", size = 221540, upload-time = "2026-03-17T10:31:35.445Z" },
-    { url = "https://files.pythonhosted.org/packages/23/d2/17879af479df7fbbd44bd528a31692a48f6b25055d16482fdf5cdb633805/coverage-7.13.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0428cbef5783ad91fe240f673cc1f76b25e74bbfe1a13115e4aa30d3f538162d", size = 220262, upload-time = "2026-03-17T10:31:37.184Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/4c/d20e554f988c8f91d6a02c5118f9abbbf73a8768a3048cb4962230d5743f/coverage-7.13.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e0b216a19534b2427cc201a26c25da4a48633f29a487c61258643e89d28200c0", size = 220617, upload-time = "2026-03-17T10:31:39.245Z" },
-    { url = "https://files.pythonhosted.org/packages/29/9c/f9f5277b95184f764b24e7231e166dfdb5780a46d408a2ac665969416d61/coverage-7.13.5-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:972a9cd27894afe4bc2b1480107054e062df08e671df7c2f18c205e805ccd806", size = 261912, upload-time = "2026-03-17T10:31:41.324Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/f6/7f1ab39393eeb50cfe4747ae8ef0e4fc564b989225aa1152e13a180d74f8/coverage-7.13.5-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4b59148601efcd2bac8c4dbf1f0ad6391693ccf7a74b8205781751637076aee3", size = 263987, upload-time = "2026-03-17T10:31:43.724Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/d7/62c084fb489ed9c6fbdf57e006752e7c516ea46fd690e5ed8b8617c7d52e/coverage-7.13.5-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:505d7083c8b0c87a8fa8c07370c285847c1f77739b22e299ad75a6af6c32c5c9", size = 266416, upload-time = "2026-03-17T10:31:45.769Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/f6/df63d8660e1a0bff6125947afda112a0502736f470d62ca68b288ea762d8/coverage-7.13.5-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:60365289c3741e4db327e7baff2a4aaacf22f788e80fa4683393891b70a89fbd", size = 267558, upload-time = "2026-03-17T10:31:48.293Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/02/353ca81d36779bd108f6d384425f7139ac3c58c750dcfaafe5d0bee6436b/coverage-7.13.5-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1b88c69c8ef5d4b6fe7dea66d6636056a0f6a7527c440e890cf9259011f5e606", size = 261163, upload-time = "2026-03-17T10:31:50.125Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/16/2e79106d5749bcaf3aee6d309123548e3276517cd7851faa8da213bc61bf/coverage-7.13.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5b13955d31d1633cf9376908089b7cebe7d15ddad7aeaabcbe969a595a97e95e", size = 263981, upload-time = "2026-03-17T10:31:51.961Z" },
-    { url = "https://files.pythonhosted.org/packages/29/c7/c29e0c59ffa6942030ae6f50b88ae49988e7e8da06de7ecdbf49c6d4feae/coverage-7.13.5-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:f70c9ab2595c56f81a89620e22899eea8b212a4041bd728ac6f4a28bf5d3ddd0", size = 261604, upload-time = "2026-03-17T10:31:53.872Z" },
-    { url = "https://files.pythonhosted.org/packages/40/48/097cdc3db342f34006a308ab41c3a7c11c3f0d84750d340f45d88a782e00/coverage-7.13.5-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:084b84a8c63e8d6fc7e3931b316a9bcafca1458d753c539db82d31ed20091a87", size = 265321, upload-time = "2026-03-17T10:31:55.997Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/1f/4994af354689e14fd03a75f8ec85a9a68d94e0188bbdab3fc1516b55e512/coverage-7.13.5-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ad14385487393e386e2ea988b09d62dd42c397662ac2dabc3832d71253eee479", size = 260502, upload-time = "2026-03-17T10:31:58.308Z" },
-    { url = "https://files.pythonhosted.org/packages/22/c6/9bb9ef55903e628033560885f5c31aa227e46878118b63ab15dc7ba87797/coverage-7.13.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:7f2c47b36fe7709a6e83bfadf4eefb90bd25fbe4014d715224c4316f808e59a2", size = 262688, upload-time = "2026-03-17T10:32:00.141Z" },
-    { url = "https://files.pythonhosted.org/packages/14/4f/f5df9007e50b15e53e01edea486814783a7f019893733d9e4d6caad75557/coverage-7.13.5-cp313-cp313t-win32.whl", hash = "sha256:67e9bc5449801fad0e5dff329499fb090ba4c5800b86805c80617b4e29809b2a", size = 222788, upload-time = "2026-03-17T10:32:02.246Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/98/aa7fccaa97d0f3192bec013c4e6fd6d294a6ed44b640e6bb61f479e00ed5/coverage-7.13.5-cp313-cp313t-win_amd64.whl", hash = "sha256:da86cdcf10d2519e10cabb8ac2de03da1bcb6e4853790b7fbd48523332e3a819", size = 223851, upload-time = "2026-03-17T10:32:04.416Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/8b/e5c469f7352651e5f013198e9e21f97510b23de957dd06a84071683b4b60/coverage-7.13.5-cp313-cp313t-win_arm64.whl", hash = "sha256:0ecf12ecb326fe2c339d93fc131816f3a7367d223db37817208905c89bded911", size = 222104, upload-time = "2026-03-17T10:32:06.65Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/77/39703f0d1d4b478bfd30191d3c14f53caf596fac00efb3f8f6ee23646439/coverage-7.13.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fbabfaceaeb587e16f7008f7795cd80d20ec548dc7f94fbb0d4ec2e038ce563f", size = 219621, upload-time = "2026-03-17T10:32:08.589Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/3e/51dff36d99ae14639a133d9b164d63e628532e2974d8b1edb99dd1ebc733/coverage-7.13.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9bb2a28101a443669a423b665939381084412b81c3f8c0fcfbac57f4e30b5b8e", size = 219953, upload-time = "2026-03-17T10:32:10.507Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/6c/1f1917b01eb647c2f2adc9962bd66c79eb978951cab61bdc1acab3290c07/coverage-7.13.5-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bd3a2fbc1c6cccb3c5106140d87cc6a8715110373ef42b63cf5aea29df8c217a", size = 250992, upload-time = "2026-03-17T10:32:12.41Z" },
-    { url = "https://files.pythonhosted.org/packages/22/e5/06b1f88f42a5a99df42ce61208bdec3bddb3d261412874280a19796fc09c/coverage-7.13.5-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6c36ddb64ed9d7e496028d1d00dfec3e428e0aabf4006583bb1839958d280510", size = 253503, upload-time = "2026-03-17T10:32:14.449Z" },
-    { url = "https://files.pythonhosted.org/packages/80/28/2a148a51e5907e504fa7b85490277734e6771d8844ebcc48764a15e28155/coverage-7.13.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:380e8e9084d8eb38db3a9176a1a4f3c0082c3806fa0dc882d1d87abc3c789247", size = 254852, upload-time = "2026-03-17T10:32:16.56Z" },
-    { url = "https://files.pythonhosted.org/packages/61/77/50e8d3d85cc0b7ebe09f30f151d670e302c7ff4a1bf6243f71dd8b0981fa/coverage-7.13.5-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e808af52a0513762df4d945ea164a24b37f2f518cbe97e03deaa0ee66139b4d6", size = 257161, upload-time = "2026-03-17T10:32:19.004Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/c4/b5fd1d4b7bf8d0e75d997afd3925c59ba629fc8616f1b3aae7605132e256/coverage-7.13.5-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e301d30dd7e95ae068671d746ba8c34e945a82682e62918e41b2679acd2051a0", size = 251021, upload-time = "2026-03-17T10:32:21.344Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/66/6ea21f910e92d69ef0b1c3346ea5922a51bad4446c9126db2ae96ee24c4c/coverage-7.13.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:800bc829053c80d240a687ceeb927a94fd108bbdc68dfbe505d0d75ab578a882", size = 252858, upload-time = "2026-03-17T10:32:23.506Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/ea/879c83cb5d61aa2a35fb80e72715e92672daef8191b84911a643f533840c/coverage-7.13.5-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:0b67af5492adb31940ee418a5a655c28e48165da5afab8c7fa6fd72a142f8740", size = 250823, upload-time = "2026-03-17T10:32:25.516Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/fb/616d95d3adb88b9803b275580bdeee8bd1b69a886d057652521f83d7322f/coverage-7.13.5-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c9136ff29c3a91e25b1d1552b5308e53a1e0653a23e53b6366d7c2dcbbaf8a16", size = 255099, upload-time = "2026-03-17T10:32:27.944Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/93/25e6917c90ec1c9a56b0b26f6cad6408e5f13bb6b35d484a0d75c9cf000d/coverage-7.13.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:cff784eef7f0b8f6cb28804fbddcfa99f89efe4cc35fb5627e3ac58f91ed3ac0", size = 250638, upload-time = "2026-03-17T10:32:29.914Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/7b/dc1776b0464145a929deed214aef9fb1493f159b59ff3c7eeeedf91eddd0/coverage-7.13.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:68a4953be99b17ac3c23b6efbc8a38330d99680c9458927491d18700ef23ded0", size = 252295, upload-time = "2026-03-17T10:32:31.981Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/fb/99cbbc56a26e07762a2740713f3c8f9f3f3106e3a3dd8cc4474954bccd34/coverage-7.13.5-cp314-cp314-win32.whl", hash = "sha256:35a31f2b1578185fbe6aa2e74cea1b1d0bbf4c552774247d9160d29b80ed56cc", size = 222360, upload-time = "2026-03-17T10:32:34.233Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/b7/4758d4f73fb536347cc5e4ad63662f9d60ba9118cb6785e9616b2ce5d7fa/coverage-7.13.5-cp314-cp314-win_amd64.whl", hash = "sha256:2aa055ae1857258f9e0045be26a6d62bdb47a72448b62d7b55f4820f361a2633", size = 223174, upload-time = "2026-03-17T10:32:36.369Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/f2/24d84e1dfe70f8ac9fdf30d338239860d0d1d5da0bda528959d0ebc9da28/coverage-7.13.5-cp314-cp314-win_arm64.whl", hash = "sha256:1b11eef33edeae9d142f9b4358edb76273b3bfd30bc3df9a4f95d0e49caf94e8", size = 221739, upload-time = "2026-03-17T10:32:38.736Z" },
-    { url = "https://files.pythonhosted.org/packages/60/5b/4a168591057b3668c2428bff25dd3ebc21b629d666d90bcdfa0217940e84/coverage-7.13.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:10a0c37f0b646eaff7cce1874c31d1f1ccb297688d4c747291f4f4c70741cc8b", size = 220351, upload-time = "2026-03-17T10:32:41.196Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/21/1fd5c4dbfe4a58b6b99649125635df46decdfd4a784c3cd6d410d303e370/coverage-7.13.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b5db73ba3c41c7008037fa731ad5459fc3944cb7452fc0aa9f822ad3533c583c", size = 220612, upload-time = "2026-03-17T10:32:43.204Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/fe/2a924b3055a5e7e4512655a9d4609781b0d62334fa0140c3e742926834e2/coverage-7.13.5-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:750db93a81e3e5a9831b534be7b1229df848b2e125a604fe6651e48aa070e5f9", size = 261985, upload-time = "2026-03-17T10:32:45.514Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/0d/c8928f2bd518c45990fe1a2ab8db42e914ef9b726c975facc4282578c3eb/coverage-7.13.5-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9ddb4f4a5479f2539644be484da179b653273bca1a323947d48ab107b3ed1f29", size = 264107, upload-time = "2026-03-17T10:32:47.971Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/ae/4ae35bbd9a0af9d820362751f0766582833c211224b38665c0f8de3d487f/coverage-7.13.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8a7a2049c14f413163e2bdabd37e41179b1d1ccb10ffc6ccc4b7a718429c607", size = 266513, upload-time = "2026-03-17T10:32:50.1Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/20/d326174c55af36f74eac6ae781612d9492f060ce8244b570bb9d50d9d609/coverage-7.13.5-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1c85e0b6c05c592ea6d8768a66a254bfb3874b53774b12d4c89c481eb78cb90", size = 267650, upload-time = "2026-03-17T10:32:52.391Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/5e/31484d62cbd0eabd3412e30d74386ece4a0837d4f6c3040a653878bfc019/coverage-7.13.5-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:777c4d1eff1b67876139d24288aaf1817f6c03d6bae9c5cc8d27b83bcfe38fe3", size = 261089, upload-time = "2026-03-17T10:32:54.544Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/d8/49a72d6de146eebb0b7e48cc0f4bc2c0dd858e3d4790ab2b39a2872b62bd/coverage-7.13.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6697e29b93707167687543480a40f0db8f356e86d9f67ddf2e37e2dfd91a9dab", size = 263982, upload-time = "2026-03-17T10:32:56.803Z" },
-    { url = "https://files.pythonhosted.org/packages/06/3b/0351f1bd566e6e4dd39e978efe7958bde1d32f879e85589de147654f57bb/coverage-7.13.5-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:8fdf453a942c3e4d99bd80088141c4c6960bb232c409d9c3558e2dbaa3998562", size = 261579, upload-time = "2026-03-17T10:32:59.466Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/ce/796a2a2f4017f554d7810f5c573449b35b1e46788424a548d4d19201b222/coverage-7.13.5-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:32ca0c0114c9834a43f045a87dcebd69d108d8ffb666957ea65aa132f50332e2", size = 265316, upload-time = "2026-03-17T10:33:01.847Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/16/d5ae91455541d1a78bc90abf495be600588aff8f6db5c8b0dae739fa39c9/coverage-7.13.5-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8769751c10f339021e2638cd354e13adeac54004d1941119b2c96fe5276d45ea", size = 260427, upload-time = "2026-03-17T10:33:03.945Z" },
-    { url = "https://files.pythonhosted.org/packages/48/11/07f413dba62db21fb3fad5d0de013a50e073cc4e2dc4306e770360f6dfc8/coverage-7.13.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cec2d83125531bd153175354055cdb7a09987af08a9430bd173c937c6d0fba2a", size = 262745, upload-time = "2026-03-17T10:33:06.285Z" },
-    { url = "https://files.pythonhosted.org/packages/91/15/d792371332eb4663115becf4bad47e047d16234b1aff687b1b18c58d60ae/coverage-7.13.5-cp314-cp314t-win32.whl", hash = "sha256:0cd9ed7a8b181775459296e402ca4fb27db1279740a24e93b3b41942ebe4b215", size = 223146, upload-time = "2026-03-17T10:33:08.756Z" },
-    { url = "https://files.pythonhosted.org/packages/db/51/37221f59a111dca5e85be7dbf09696323b5b9f13ff65e0641d535ed06ea8/coverage-7.13.5-cp314-cp314t-win_amd64.whl", hash = "sha256:301e3b7dfefecaca37c9f1aa6f0049b7d4ab8dd933742b607765d757aca77d43", size = 224254, upload-time = "2026-03-17T10:33:11.174Z" },
-    { url = "https://files.pythonhosted.org/packages/54/83/6acacc889de8987441aa7d5adfbdbf33d288dad28704a67e574f1df9bcbb/coverage-7.13.5-cp314-cp314t-win_arm64.whl", hash = "sha256:9dacc2ad679b292709e0f5fc1ac74a6d4d5562e424058962c7bb0c658ad25e45", size = 222276, upload-time = "2026-03-17T10:33:13.466Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/ee/a4cf96b8ce1e566ed238f0659ac2d3f007ed1d14b181bcb684e19561a69a/coverage-7.13.5-py3-none-any.whl", hash = "sha256:34b02417cf070e173989b3db962f7ed56d2f644307b2cf9d5a0f258e13084a61", size = 211346, upload-time = "2026-03-17T10:33:15.691Z" },
-]
-
-[package.optional-dependencies]
-toml = [
-    { name = "tomli", marker = "python_full_version <= '3.11'" },
-]
-
-[[package]]
-name = "dev-code"
-source = { editable = "." }
-
-[package.dev-dependencies]
-dev = [
-    { name = "pyfiglet" },
-    { name = "pytest" },
-    { name = "pytest-cov" },
-    { name = "pyyaml" },
-    { name = "tox" },
-]
-
-[package.metadata]
-
-[package.metadata.requires-dev]
-dev = [
-    { name = "pyfiglet", specifier = ">=1.0.4" },
-    { name = "pytest", specifier = ">=7.0.1" },
-    { name = "pytest-cov", specifier = ">=4.0" },
-    { name = "pyyaml", specifier = ">=6.0" },
-    { name = "tox", specifier = ">=4.0" },
-]
-
-[[package]]
-name = "distlib"
-version = "0.4.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/96/8e/709914eb2b5749865801041647dc7f4e6d00b549cfe88b65ca192995f07c/distlib-0.4.0.tar.gz", hash = "sha256:feec40075be03a04501a973d81f633735b4b69f98b05450592310c0f401a4e0d", size = 614605, upload-time = "2025-07-17T16:52:00.465Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/33/6b/e0547afaf41bf2c42e52430072fa5658766e3d65bd4b03a563d1b6336f57/distlib-0.4.0-py2.py3-none-any.whl", hash = "sha256:9659f7d87e46584a30b5780e43ac7a2143098441670ff0a49d5f9034c54a6c16", size = 469047, upload-time = "2025-07-17T16:51:58.613Z" },
-]
-
-[[package]]
-name = "exceptiongroup"
-version = "1.3.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" },
-]
-
-[[package]]
-name = "filelock"
-version = "3.25.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/94/b8/00651a0f559862f3bb7d6f7477b192afe3f583cc5e26403b44e59a55ab34/filelock-3.25.2.tar.gz", hash = "sha256:b64ece2b38f4ca29dd3e810287aa8c48182bbecd1ae6e9ae126c9b35f1382694", size = 40480, upload-time = "2026-03-11T20:45:38.487Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a4/a5/842ae8f0c08b61d6484b52f99a03510a3a72d23141942d216ebe81fefbce/filelock-3.25.2-py3-none-any.whl", hash = "sha256:ca8afb0da15f229774c9ad1b455ed96e85a81373065fb10446672f64444ddf70", size = 26759, upload-time = "2026-03-11T20:45:37.437Z" },
-]
-
-[[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.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
-]
-
-[[package]]
-name = "platformdirs"
-version = "4.9.4"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/19/56/8d4c30c8a1d07013911a8fdbd8f89440ef9f08d07a1b50ab8ca8be5a20f9/platformdirs-4.9.4.tar.gz", hash = "sha256:1ec356301b7dc906d83f371c8f487070e99d3ccf9e501686456394622a01a934", size = 28737, upload-time = "2026-03-05T18:34:13.271Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/63/d7/97f7e3a6abb67d8080dd406fd4df842c2be0efaf712d1c899c32a075027c/platformdirs-4.9.4-py3-none-any.whl", hash = "sha256:68a9a4619a666ea6439f2ff250c12a853cd1cbd5158d258bd824a7df6be2f868", size = 21216, upload-time = "2026-03-05T18:34:12.172Z" },
-]
-
-[[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 = "pyfiglet"
-version = "1.0.4"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c8/e3/0a86276ad2c383ce08d76110a8eec2fe22e7051c4b8ba3fa163a0b08c428/pyfiglet-1.0.4.tar.gz", hash = "sha256:db9c9940ed1bf3048deff534ed52ff2dafbbc2cd7610b17bb5eca1df6d4278ef", size = 1560615, upload-time = "2025-08-15T18:32:47.302Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/9f/5c/fe9f95abd5eaedfa69f31e450f7e2768bef121dbdf25bcddee2cd3087a16/pyfiglet-1.0.4-py3-none-any.whl", hash = "sha256:65b57b7a8e1dff8a67dc8e940a117238661d5e14c3e49121032bd404d9b2b39f", size = 1806118, upload-time = "2025-08-15T18:32:45.556Z" },
-]
-
-[[package]]
-name = "pygments"
-version = "2.19.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
-]
-
-[[package]]
-name = "pyproject-api"
-version = "1.10.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "packaging" },
-    { name = "tomli", marker = "python_full_version < '3.11'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/45/7b/c0e1333b61d41c69e59e5366e727b18c4992688caf0de1be10b3e5265f6b/pyproject_api-1.10.0.tar.gz", hash = "sha256:40c6f2d82eebdc4afee61c773ed208c04c19db4c4a60d97f8d7be3ebc0bbb330", size = 22785, upload-time = "2025-10-09T19:12:27.21Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/54/cc/cecf97be298bee2b2a37dd360618c819a2a7fd95251d8e480c1f0eb88f3b/pyproject_api-1.10.0-py3-none-any.whl", hash = "sha256:8757c41a79c0f4ab71b99abed52b97ecf66bd20b04fa59da43b5840bac105a09", size = 13218, upload-time = "2025-10-09T19:12:24.428Z" },
-]
-
-[[package]]
-name = "pytest"
-version = "9.0.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "colorama", marker = "sys_platform == 'win32'" },
-    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
-    { name = "iniconfig" },
-    { name = "packaging" },
-    { name = "pluggy" },
-    { name = "pygments" },
-    { name = "tomli", marker = "python_full_version < '3.11'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
-]
-
-[[package]]
-name = "pytest-cov"
-version = "7.1.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "coverage", extra = ["toml"] },
-    { name = "pluggy" },
-    { name = "pytest" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/b1/51/a849f96e117386044471c8ec2bd6cfebacda285da9525c9106aeb28da671/pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2", size = 55592, upload-time = "2026-03-21T20:11:16.284Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/9d/7a/d968e294073affff457b041c2be9868a40c1c71f4a35fcc1e45e5493067b/pytest_cov-7.1.0-py3-none-any.whl", hash = "sha256:a0461110b7865f9a271aa1b51e516c9a95de9d696734a2f71e3e78f46e1d4678", size = 22876, upload-time = "2026-03-21T20:11:14.438Z" },
-]
-
-[[package]]
-name = "python-discovery"
-version = "1.2.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "filelock" },
-    { name = "platformdirs" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/9c/90/bcce6b46823c9bec1757c964dc37ed332579be512e17a30e9698095dcae4/python_discovery-1.2.0.tar.gz", hash = "sha256:7d33e350704818b09e3da2bd419d37e21e7c30db6e0977bb438916e06b41b5b1", size = 58055, upload-time = "2026-03-19T01:43:08.248Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c2/3c/2005227cb951df502412de2fa781f800663cccbef8d90ec6f1b371ac2c0d/python_discovery-1.2.0-py3-none-any.whl", hash = "sha256:1e108f1bbe2ed0ef089823d28805d5ad32be8e734b86a5f212bf89b71c266e4a", size = 31524, upload-time = "2026-03-19T01:43:07.045Z" },
-]
-
-[[package]]
-name = "pyyaml"
-version = "6.0.3"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" },
-    { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" },
-    { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" },
-    { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" },
-    { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" },
-    { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" },
-    { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" },
-    { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
-    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
-    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
-    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
-    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
-    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
-    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
-    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
-    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
-    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
-    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
-    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
-    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
-    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
-    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
-    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
-    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
-    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
-]
-
-[[package]]
-name = "tomli"
-version = "2.4.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/82/30/31573e9457673ab10aa432461bee537ce6cef177667deca369efb79df071/tomli-2.4.0.tar.gz", hash = "sha256:aa89c3f6c277dd275d8e243ad24f3b5e701491a860d5121f2cdd399fbb31fc9c", size = 17477, upload-time = "2026-01-11T11:22:38.165Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3c/d9/3dc2289e1f3b32eb19b9785b6a006b28ee99acb37d1d47f78d4c10e28bf8/tomli-2.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b5ef256a3fd497d4973c11bf142e9ed78b150d36f5773f1ca6088c230ffc5867", size = 153663, upload-time = "2026-01-11T11:21:45.27Z" },
-    { url = "https://files.pythonhosted.org/packages/51/32/ef9f6845e6b9ca392cd3f64f9ec185cc6f09f0a2df3db08cbe8809d1d435/tomli-2.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5572e41282d5268eb09a697c89a7bee84fae66511f87533a6f88bd2f7b652da9", size = 148469, upload-time = "2026-01-11T11:21:46.873Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/c2/506e44cce89a8b1b1e047d64bd495c22c9f71f21e05f380f1a950dd9c217/tomli-2.4.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:551e321c6ba03b55676970b47cb1b73f14a0a4dce6a3e1a9458fd6d921d72e95", size = 236039, upload-time = "2026-01-11T11:21:48.503Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/40/e1b65986dbc861b7e986e8ec394598187fa8aee85b1650b01dd925ca0be8/tomli-2.4.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e3f639a7a8f10069d0e15408c0b96a2a828cfdec6fca05296ebcdcc28ca7c76", size = 243007, upload-time = "2026-01-11T11:21:49.456Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/6f/6e39ce66b58a5b7ae572a0f4352ff40c71e8573633deda43f6a379d56b3e/tomli-2.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1b168f2731796b045128c45982d3a4874057626da0e2ef1fdd722848b741361d", size = 240875, upload-time = "2026-01-11T11:21:50.755Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/ad/cb089cb190487caa80204d503c7fd0f4d443f90b95cf4ef5cf5aa0f439b0/tomli-2.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:133e93646ec4300d651839d382d63edff11d8978be23da4cc106f5a18b7d0576", size = 246271, upload-time = "2026-01-11T11:21:51.81Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/63/69125220e47fd7a3a27fd0de0c6398c89432fec41bc739823bcc66506af6/tomli-2.4.0-cp311-cp311-win32.whl", hash = "sha256:b6c78bdf37764092d369722d9946cb65b8767bfa4110f902a1b2542d8d173c8a", size = 96770, upload-time = "2026-01-11T11:21:52.647Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/0d/a22bb6c83f83386b0008425a6cd1fa1c14b5f3dd4bad05e98cf3dbbf4a64/tomli-2.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:d3d1654e11d724760cdb37a3d7691f0be9db5fbdaef59c9f532aabf87006dbaa", size = 107626, upload-time = "2026-01-11T11:21:53.459Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/6d/77be674a3485e75cacbf2ddba2b146911477bd887dda9d8c9dfb2f15e871/tomli-2.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:cae9c19ed12d4e8f3ebf46d1a75090e4c0dc16271c5bce1c833ac168f08fb614", size = 94842, upload-time = "2026-01-11T11:21:54.831Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/43/7389a1869f2f26dba52404e1ef13b4784b6b37dac93bac53457e3ff24ca3/tomli-2.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:920b1de295e72887bafa3ad9f7a792f811847d57ea6b1215154030cf131f16b1", size = 154894, upload-time = "2026-01-11T11:21:56.07Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/05/2f9bf110b5294132b2edf13fe6ca6ae456204f3d749f623307cbb7a946f2/tomli-2.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7d6d9a4aee98fac3eab4952ad1d73aee87359452d1c086b5ceb43ed02ddb16b8", size = 149053, upload-time = "2026-01-11T11:21:57.467Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/41/1eda3ca1abc6f6154a8db4d714a4d35c4ad90adc0bcf700657291593fbf3/tomli-2.4.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:36b9d05b51e65b254ea6c2585b59d2c4cb91c8a3d91d0ed0f17591a29aaea54a", size = 243481, upload-time = "2026-01-11T11:21:58.661Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/6d/02ff5ab6c8868b41e7d4b987ce2b5f6a51d3335a70aa144edd999e055a01/tomli-2.4.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c8a885b370751837c029ef9bc014f27d80840e48bac415f3412e6593bbc18c1", size = 251720, upload-time = "2026-01-11T11:22:00.178Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/57/0405c59a909c45d5b6f146107c6d997825aa87568b042042f7a9c0afed34/tomli-2.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8768715ffc41f0008abe25d808c20c3d990f42b6e2e58305d5da280ae7d1fa3b", size = 247014, upload-time = "2026-01-11T11:22:01.238Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/0e/2e37568edd944b4165735687cbaf2fe3648129e440c26d02223672ee0630/tomli-2.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7b438885858efd5be02a9a133caf5812b8776ee0c969fea02c45e8e3f296ba51", size = 251820, upload-time = "2026-01-11T11:22:02.727Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/1c/ee3b707fdac82aeeb92d1a113f803cf6d0f37bdca0849cb489553e1f417a/tomli-2.4.0-cp312-cp312-win32.whl", hash = "sha256:0408e3de5ec77cc7f81960c362543cbbd91ef883e3138e81b729fc3eea5b9729", size = 97712, upload-time = "2026-01-11T11:22:03.777Z" },
-    { url = "https://files.pythonhosted.org/packages/69/13/c07a9177d0b3bab7913299b9278845fc6eaaca14a02667c6be0b0a2270c8/tomli-2.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:685306e2cc7da35be4ee914fd34ab801a6acacb061b6a7abca922aaf9ad368da", size = 108296, upload-time = "2026-01-11T11:22:04.86Z" },
-    { url = "https://files.pythonhosted.org/packages/18/27/e267a60bbeeee343bcc279bb9e8fbed0cbe224bc7b2a3dc2975f22809a09/tomli-2.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:5aa48d7c2356055feef06a43611fc401a07337d5b006be13a30f6c58f869e3c3", size = 94553, upload-time = "2026-01-11T11:22:05.854Z" },
-    { url = "https://files.pythonhosted.org/packages/34/91/7f65f9809f2936e1f4ce6268ae1903074563603b2a2bd969ebbda802744f/tomli-2.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84d081fbc252d1b6a982e1870660e7330fb8f90f676f6e78b052ad4e64714bf0", size = 154915, upload-time = "2026-01-11T11:22:06.703Z" },
-    { url = "https://files.pythonhosted.org/packages/20/aa/64dd73a5a849c2e8f216b755599c511badde80e91e9bc2271baa7b2cdbb1/tomli-2.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9a08144fa4cba33db5255f9b74f0b89888622109bd2776148f2597447f92a94e", size = 149038, upload-time = "2026-01-11T11:22:07.56Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/8a/6d38870bd3d52c8d1505ce054469a73f73a0fe62c0eaf5dddf61447e32fa/tomli-2.4.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c73add4bb52a206fd0c0723432db123c0c75c280cbd67174dd9d2db228ebb1b4", size = 242245, upload-time = "2026-01-11T11:22:08.344Z" },
-    { url = "https://files.pythonhosted.org/packages/59/bb/8002fadefb64ab2669e5b977df3f5e444febea60e717e755b38bb7c41029/tomli-2.4.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fb2945cbe303b1419e2706e711b7113da57b7db31ee378d08712d678a34e51e", size = 250335, upload-time = "2026-01-11T11:22:09.951Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/3d/4cdb6f791682b2ea916af2de96121b3cb1284d7c203d97d92d6003e91c8d/tomli-2.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bbb1b10aa643d973366dc2cb1ad94f99c1726a02343d43cbc011edbfac579e7c", size = 245962, upload-time = "2026-01-11T11:22:11.27Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/4a/5f25789f9a460bd858ba9756ff52d0830d825b458e13f754952dd15fb7bb/tomli-2.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4cbcb367d44a1f0c2be408758b43e1ffb5308abe0ea222897d6bfc8e8281ef2f", size = 250396, upload-time = "2026-01-11T11:22:12.325Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/2f/b73a36fea58dfa08e8b3a268750e6853a6aac2a349241a905ebd86f3047a/tomli-2.4.0-cp313-cp313-win32.whl", hash = "sha256:7d49c66a7d5e56ac959cb6fc583aff0651094ec071ba9ad43df785abc2320d86", size = 97530, upload-time = "2026-01-11T11:22:13.865Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/af/ca18c134b5d75de7e8dc551c5234eaba2e8e951f6b30139599b53de9c187/tomli-2.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:3cf226acb51d8f1c394c1b310e0e0e61fecdd7adcb78d01e294ac297dd2e7f87", size = 108227, upload-time = "2026-01-11T11:22:15.224Z" },
-    { url = "https://files.pythonhosted.org/packages/22/c3/b386b832f209fee8073c8138ec50f27b4460db2fdae9ffe022df89a57f9b/tomli-2.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:d20b797a5c1ad80c516e41bc1fb0443ddb5006e9aaa7bda2d71978346aeb9132", size = 94748, upload-time = "2026-01-11T11:22:16.009Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/c4/84047a97eb1004418bc10bdbcfebda209fca6338002eba2dc27cc6d13563/tomli-2.4.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:26ab906a1eb794cd4e103691daa23d95c6919cc2fa9160000ac02370cc9dd3f6", size = 154725, upload-time = "2026-01-11T11:22:17.269Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/5d/d39038e646060b9d76274078cddf146ced86dc2b9e8bbf737ad5983609a0/tomli-2.4.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:20cedb4ee43278bc4f2fee6cb50daec836959aadaf948db5172e776dd3d993fc", size = 148901, upload-time = "2026-01-11T11:22:18.287Z" },
-    { url = "https://files.pythonhosted.org/packages/73/e5/383be1724cb30f4ce44983d249645684a48c435e1cd4f8b5cded8a816d3c/tomli-2.4.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:39b0b5d1b6dd03684b3fb276407ebed7090bbec989fa55838c98560c01113b66", size = 243375, upload-time = "2026-01-11T11:22:19.154Z" },
-    { url = "https://files.pythonhosted.org/packages/31/f0/bea80c17971c8d16d3cc109dc3585b0f2ce1036b5f4a8a183789023574f2/tomli-2.4.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a26d7ff68dfdb9f87a016ecfd1e1c2bacbe3108f4e0f8bcd2228ef9a766c787d", size = 250639, upload-time = "2026-01-11T11:22:20.168Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/8f/2853c36abbb7608e3f945d8a74e32ed3a74ee3a1f468f1ffc7d1cb3abba6/tomli-2.4.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:20ffd184fb1df76a66e34bd1b36b4a4641bd2b82954befa32fe8163e79f1a702", size = 246897, upload-time = "2026-01-11T11:22:21.544Z" },
-    { url = "https://files.pythonhosted.org/packages/49/f0/6c05e3196ed5337b9fe7ea003e95fd3819a840b7a0f2bf5a408ef1dad8ed/tomli-2.4.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:75c2f8bbddf170e8effc98f5e9084a8751f8174ea6ccf4fca5398436e0320bc8", size = 254697, upload-time = "2026-01-11T11:22:23.058Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/f5/2922ef29c9f2951883525def7429967fc4d8208494e5ab524234f06b688b/tomli-2.4.0-cp314-cp314-win32.whl", hash = "sha256:31d556d079d72db7c584c0627ff3a24c5d3fb4f730221d3444f3efb1b2514776", size = 98567, upload-time = "2026-01-11T11:22:24.033Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/31/22b52e2e06dd2a5fdbc3ee73226d763b184ff21fc24e20316a44ccc4d96b/tomli-2.4.0-cp314-cp314-win_amd64.whl", hash = "sha256:43e685b9b2341681907759cf3a04e14d7104b3580f808cfde1dfdb60ada85475", size = 108556, upload-time = "2026-01-11T11:22:25.378Z" },
-    { url = "https://files.pythonhosted.org/packages/48/3d/5058dff3255a3d01b705413f64f4306a141a8fd7a251e5a495e3f192a998/tomli-2.4.0-cp314-cp314-win_arm64.whl", hash = "sha256:3d895d56bd3f82ddd6faaff993c275efc2ff38e52322ea264122d72729dca2b2", size = 96014, upload-time = "2026-01-11T11:22:26.138Z" },
-    { url = "https://files.pythonhosted.org/packages/b8/4e/75dab8586e268424202d3a1997ef6014919c941b50642a1682df43204c22/tomli-2.4.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:5b5807f3999fb66776dbce568cc9a828544244a8eb84b84b9bafc080c99597b9", size = 163339, upload-time = "2026-01-11T11:22:27.143Z" },
-    { url = "https://files.pythonhosted.org/packages/06/e3/b904d9ab1016829a776d97f163f183a48be6a4deb87304d1e0116a349519/tomli-2.4.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c084ad935abe686bd9c898e62a02a19abfc9760b5a79bc29644463eaf2840cb0", size = 159490, upload-time = "2026-01-11T11:22:28.399Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/5a/fc3622c8b1ad823e8ea98a35e3c632ee316d48f66f80f9708ceb4f2a0322/tomli-2.4.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f2e3955efea4d1cfbcb87bc321e00dc08d2bcb737fd1d5e398af111d86db5df", size = 269398, upload-time = "2026-01-11T11:22:29.345Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/33/62bd6152c8bdd4c305ad9faca48f51d3acb2df1f8791b1477d46ff86e7f8/tomli-2.4.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0e0fe8a0b8312acf3a88077a0802565cb09ee34107813bba1c7cd591fa6cfc8d", size = 276515, upload-time = "2026-01-11T11:22:30.327Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/ff/ae53619499f5235ee4211e62a8d7982ba9e439a0fb4f2f351a93d67c1dd2/tomli-2.4.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:413540dce94673591859c4c6f794dfeaa845e98bf35d72ed59636f869ef9f86f", size = 273806, upload-time = "2026-01-11T11:22:32.56Z" },
-    { url = "https://files.pythonhosted.org/packages/47/71/cbca7787fa68d4d0a9f7072821980b39fbb1b6faeb5f5cf02f4a5559fa28/tomli-2.4.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0dc56fef0e2c1c470aeac5b6ca8cc7b640bb93e92d9803ddaf9ea03e198f5b0b", size = 281340, upload-time = "2026-01-11T11:22:33.505Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/00/d595c120963ad42474cf6ee7771ad0d0e8a49d0f01e29576ee9195d9ecdf/tomli-2.4.0-cp314-cp314t-win32.whl", hash = "sha256:d878f2a6707cc9d53a1be1414bbb419e629c3d6e67f69230217bb663e76b5087", size = 108106, upload-time = "2026-01-11T11:22:34.451Z" },
-    { url = "https://files.pythonhosted.org/packages/de/69/9aa0c6a505c2f80e519b43764f8b4ba93b5a0bbd2d9a9de6e2b24271b9a5/tomli-2.4.0-cp314-cp314t-win_amd64.whl", hash = "sha256:2add28aacc7425117ff6364fe9e06a183bb0251b03f986df0e78e974047571fd", size = 120504, upload-time = "2026-01-11T11:22:35.764Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/9f/f1668c281c58cfae01482f7114a4b88d345e4c140386241a1a24dcc9e7bc/tomli-2.4.0-cp314-cp314t-win_arm64.whl", hash = "sha256:2b1e3b80e1d5e52e40e9b924ec43d81570f0e7d09d11081b797bc4692765a3d4", size = 99561, upload-time = "2026-01-11T11:22:36.624Z" },
-    { url = "https://files.pythonhosted.org/packages/23/d1/136eb2cb77520a31e1f64cbae9d33ec6df0d78bdf4160398e86eec8a8754/tomli-2.4.0-py3-none-any.whl", hash = "sha256:1f776e7d669ebceb01dee46484485f43a4048746235e683bcdffacdf1fb4785a", size = 14477, upload-time = "2026-01-11T11:22:37.446Z" },
-]
-
-[[package]]
-name = "tomli-w"
-version = "1.2.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/19/75/241269d1da26b624c0d5e110e8149093c759b7a286138f4efd61a60e75fe/tomli_w-1.2.0.tar.gz", hash = "sha256:2dd14fac5a47c27be9cd4c976af5a12d87fb1f0b4512f81d69cce3b35ae25021", size = 7184, upload-time = "2025-01-15T12:07:24.262Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c7/18/c86eb8e0202e32dd3df50d43d7ff9854f8e0603945ff398974c1d91ac1ef/tomli_w-1.2.0-py3-none-any.whl", hash = "sha256:188306098d013b691fcadc011abd66727d3c414c571bb01b1a174ba8c983cf90", size = 6675, upload-time = "2025-01-15T12:07:22.074Z" },
-]
-
-[[package]]
-name = "tox"
-version = "4.50.3"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "cachetools" },
-    { name = "colorama" },
-    { name = "filelock" },
-    { name = "packaging" },
-    { name = "platformdirs" },
-    { name = "pluggy" },
-    { name = "pyproject-api" },
-    { name = "tomli", marker = "python_full_version < '3.11'" },
-    { name = "tomli-w" },
-    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
-    { name = "virtualenv" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/ae/45/e4c0ac54af794f992790abe350770bb1fa6d5a85b25d47b6182c83ec7915/tox-4.50.3.tar.gz", hash = "sha256:c745641de6cc4f19d066bd9f98c1c25f7affb005b381b7f3694a1f142ea0946b", size = 266455, upload-time = "2026-03-20T01:17:59.351Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fe/ab/369d60db70d9031341082842071541f2497741b04140816c7df82734faf6/tox-4.50.3-py3-none-any.whl", hash = "sha256:5e788a512bfe6f7447e0c8d7c1b666eb2e56e5e676c65717490423bec37d1a07", size = 207667, upload-time = "2026-03-20T01:17:57.553Z" },
-]
-
-[[package]]
-name = "typing-extensions"
-version = "4.15.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
-]
-
-[[package]]
-name = "virtualenv"
-version = "21.2.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "distlib" },
-    { name = "filelock" },
-    { name = "platformdirs" },
-    { name = "python-discovery" },
-    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/aa/92/58199fe10049f9703c2666e809c4f686c54ef0a68b0f6afccf518c0b1eb9/virtualenv-21.2.0.tar.gz", hash = "sha256:1720dc3a62ef5b443092e3f499228599045d7fea4c79199770499df8becf9098", size = 5840618, upload-time = "2026-03-09T17:24:38.013Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c6/59/7d02447a55b2e55755011a647479041bc92a82e143f96a8195cb33bd0a1c/virtualenv-21.2.0-py3-none-any.whl", hash = "sha256:1bd755b504931164a5a496d217c014d098426cddc79363ad66ac78125f9d908f", size = 5825084, upload-time = "2026-03-09T17:24:35.378Z" },
-]