git-reclaim 0.1.0__tar.gz

git_reclaim-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,26 @@
+name: ci
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install dependencies
+        run: uv sync --group dev
+
+      - name: Ruff lint
+        run: uv run ruff check src tests
+
+      - name: Ruff format check
+        run: uv run ruff format --check src tests
+
+      - name: Pytest
+        run: uv run pytest

git_reclaim-0.1.0/.gitignore

@@ -0,0 +1,20 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.venv/
+venv/
+build/
+dist/
+.pytest_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+
+# uv
+.uv/
+
+# Editors and OS
+.DS_Store
+._*
+*.swp

git_reclaim-0.1.0/LICENSE

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

git_reclaim-0.1.0/PKG-INFO

@@ -0,0 +1,163 @@
+Metadata-Version: 2.5
+Name: git-reclaim
+Version: 0.1.0
+Summary: Reclaim disk space across a tree of git repositories
+Project-URL: Homepage, https://github.com/michael-borck/git-reclaim
+Project-URL: Repository, https://github.com/michael-borck/git-reclaim
+Project-URL: Issues, https://github.com/michael-borck/git-reclaim/issues
+Author-email: Michael Borck <michael@borck.dev>
+License: MIT
+License-File: LICENSE
+Keywords: cleanup,cli,disk-space,git,repository-management
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Version Control :: Git
+Classifier: Topic :: System :: Filesystems
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# git-reclaim
+
+A small, dependency-free **disk-reclaim** helper for people who keep many git
+clones side by side. It finds space you can safely get back across a whole tree
+of repos, and flags clones that are safe to delete because the remote already
+has everything.
+
+`git-reclaim` is a [git custom subcommand](https://git-scm.com/book/en/v2/Git-Internals-Git-Internals):
+an executable named `git-reclaim` on your `PATH` is runnable as `git reclaim`.
+
+> **Scope:** `git-reclaim` does one thing: reclaim disk space across local
+> clones. For multi-repo **status and sync** (branch, ahead/behind, batch
+> `git` commands), use [gita](https://github.com/nosarthur/gita). For anything
+> needing the **GitHub API** (bulk listing, health checks, topics, portfolio
+> sites), use [gh-toolkit](https://github.com/michael-borck/gh-toolkit) or
+> [`gh`](https://cli.github.com/). If you want one verb set across all of them,
+> use [gx](https://github.com/michael-borck/gx).
+
+## Install
+
+```bash
+uv tool install git-reclaim
+# or
+pipx install git-reclaim
+# or
+pip install git-reclaim
+```
+
+No dependencies beyond Python 3.10+ and `git`.
+
+## `git reclaim`
+
+```
+git reclaim [-p] [-g] [-r] [-d DIR]
+
+  (default)  dry run: report reclaimable cache space; deletes nothing
+  -p         purge the cache directories (any dir git tracks files inside is
+             skipped, never deleted)
+  -g         compact history: run `git gc` (and `git lfs prune` if installed)
+             in every repo and report the .git space reclaimed
+  -r         also list repos that are safe to delete (size + last commit + URL)
+  -d DIR     directory to scan (default: current directory)
+```
+
+Three ways to free space across a tree of clones:
+
+- **Purge regenerable caches.** It finds `node_modules`, `.venv`/`venv`,
+  `__pycache__`, `.pytest_cache`, `.ruff_cache`, `.mypy_cache`, `.next`, and
+  `target`. These rebuild on demand. So `git reclaim -p` recovers space without
+  touching your source, history, or uncommitted work. If a directory with one
+  of these names turns out to be git-tracked (a committed `target/`, say), the
+  purge detects that and skips it. `dist/` and `build/` are deliberately
+  excluded because they are occasionally committed. Re-run `npm install` or
+  `uv sync` next time you open a project.
+
+- **Compact `.git` itself.** `git reclaim -g` runs `git gc` (plus
+  `git lfs prune` when git-lfs is installed) in every repo and reports the
+  space recovered per repo. This is standard git maintenance: nothing reachable
+  is deleted, and lfs prune always retains unpushed objects.
+
+- **Find repos that are safe to delete.** `git reclaim -r` lists repos where
+  the remote already has everything: clean working tree, has a remote, no
+  unpushed commits on any local branch, no stashes, and no tags. Rows are sorted
+  by size, with each repo's last-commit date and re-clone URL. Anything not
+  fully synced is counted as "keep" and never listed as safe. Tags are treated
+  conservatively because a local tag ref can be lost even when its commit is on
+  the remote.
+
+### How discovery works
+
+It walks the tree but **prunes at repo boundaries**. The moment a directory
+contains a `.git` entry it is recorded as a repo and not descended into. So
+workspace folders are descended into to find their child repos, while a repo's
+own working tree (and its `node_modules`, `vendor`, submodules, etc.) is not
+re-scanned. `.git` is detected as a **file or directory**, so submodule and
+worktree clones are recognised too.
+
+### Examples
+
+```bash
+git reclaim              # what could I free from caches? (dry run)
+git reclaim -p           # actually purge the caches
+git reclaim -g           # repack every repo's .git (git gc)
+git reclaim -r           # caches report + list of repos safe to delete
+git reclaim -r -d ~/work # scan a different tree
+```
+
+> `git reclaim` only ever deletes **caches**, and only with `-p`; `-g` just
+> repacks history in place. It never deletes a repo. It just reports which are
+> safe, so you stay in control of removing whole clones. Pair it with the
+> re-clone URLs it prints.
+
+## Using it from `gita`
+
+If you manage your clones with `gita`, you can make `git-reclaim` feel native.
+gita loads a user command file from `~/.config/gita/cmds.json` and lets custom
+commands shadow the defaults. Add:
+
+```json
+{
+  "reclaim": {
+    "cmd": "git-reclaim -d .",
+    "disable_async": true,
+    "help": "reclaim caches / flag safe-to-delete clones"
+  }
+}
+```
+
+Now `gita reclaim` (or `gita reclaim <group>`) runs `git-reclaim` in each
+registered repo. No-config alternative:
+
+```bash
+gita shell 'git-reclaim -d .'
+```
+
+Note this runs it **per repo**, which suits the cache purge (`-p`) and
+`git gc` (`-g`) modes. For the cross-tree "what's safe to delete, biggest
+first" view (`-r`), run `git-reclaim` standalone against the parent folder
+(`git reclaim -r -d ~/projects`) so you get the single aggregate, size-sorted
+report.
+
+## Development
+
+```bash
+uv sync --group dev
+uv run pytest
+uv run ruff check src tests
+uv run ruff format --check src tests
+```
+
+CI runs the same checks on every push and pull request.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

git_reclaim-0.1.0/README.md

@@ -0,0 +1,135 @@
+# git-reclaim
+
+A small, dependency-free **disk-reclaim** helper for people who keep many git
+clones side by side. It finds space you can safely get back across a whole tree
+of repos, and flags clones that are safe to delete because the remote already
+has everything.
+
+`git-reclaim` is a [git custom subcommand](https://git-scm.com/book/en/v2/Git-Internals-Git-Internals):
+an executable named `git-reclaim` on your `PATH` is runnable as `git reclaim`.
+
+> **Scope:** `git-reclaim` does one thing: reclaim disk space across local
+> clones. For multi-repo **status and sync** (branch, ahead/behind, batch
+> `git` commands), use [gita](https://github.com/nosarthur/gita). For anything
+> needing the **GitHub API** (bulk listing, health checks, topics, portfolio
+> sites), use [gh-toolkit](https://github.com/michael-borck/gh-toolkit) or
+> [`gh`](https://cli.github.com/). If you want one verb set across all of them,
+> use [gx](https://github.com/michael-borck/gx).
+
+## Install
+
+```bash
+uv tool install git-reclaim
+# or
+pipx install git-reclaim
+# or
+pip install git-reclaim
+```
+
+No dependencies beyond Python 3.10+ and `git`.
+
+## `git reclaim`
+
+```
+git reclaim [-p] [-g] [-r] [-d DIR]
+
+  (default)  dry run: report reclaimable cache space; deletes nothing
+  -p         purge the cache directories (any dir git tracks files inside is
+             skipped, never deleted)
+  -g         compact history: run `git gc` (and `git lfs prune` if installed)
+             in every repo and report the .git space reclaimed
+  -r         also list repos that are safe to delete (size + last commit + URL)
+  -d DIR     directory to scan (default: current directory)
+```
+
+Three ways to free space across a tree of clones:
+
+- **Purge regenerable caches.** It finds `node_modules`, `.venv`/`venv`,
+  `__pycache__`, `.pytest_cache`, `.ruff_cache`, `.mypy_cache`, `.next`, and
+  `target`. These rebuild on demand. So `git reclaim -p` recovers space without
+  touching your source, history, or uncommitted work. If a directory with one
+  of these names turns out to be git-tracked (a committed `target/`, say), the
+  purge detects that and skips it. `dist/` and `build/` are deliberately
+  excluded because they are occasionally committed. Re-run `npm install` or
+  `uv sync` next time you open a project.
+
+- **Compact `.git` itself.** `git reclaim -g` runs `git gc` (plus
+  `git lfs prune` when git-lfs is installed) in every repo and reports the
+  space recovered per repo. This is standard git maintenance: nothing reachable
+  is deleted, and lfs prune always retains unpushed objects.
+
+- **Find repos that are safe to delete.** `git reclaim -r` lists repos where
+  the remote already has everything: clean working tree, has a remote, no
+  unpushed commits on any local branch, no stashes, and no tags. Rows are sorted
+  by size, with each repo's last-commit date and re-clone URL. Anything not
+  fully synced is counted as "keep" and never listed as safe. Tags are treated
+  conservatively because a local tag ref can be lost even when its commit is on
+  the remote.
+
+### How discovery works
+
+It walks the tree but **prunes at repo boundaries**. The moment a directory
+contains a `.git` entry it is recorded as a repo and not descended into. So
+workspace folders are descended into to find their child repos, while a repo's
+own working tree (and its `node_modules`, `vendor`, submodules, etc.) is not
+re-scanned. `.git` is detected as a **file or directory**, so submodule and
+worktree clones are recognised too.
+
+### Examples
+
+```bash
+git reclaim              # what could I free from caches? (dry run)
+git reclaim -p           # actually purge the caches
+git reclaim -g           # repack every repo's .git (git gc)
+git reclaim -r           # caches report + list of repos safe to delete
+git reclaim -r -d ~/work # scan a different tree
+```
+
+> `git reclaim` only ever deletes **caches**, and only with `-p`; `-g` just
+> repacks history in place. It never deletes a repo. It just reports which are
+> safe, so you stay in control of removing whole clones. Pair it with the
+> re-clone URLs it prints.
+
+## Using it from `gita`
+
+If you manage your clones with `gita`, you can make `git-reclaim` feel native.
+gita loads a user command file from `~/.config/gita/cmds.json` and lets custom
+commands shadow the defaults. Add:
+
+```json
+{
+  "reclaim": {
+    "cmd": "git-reclaim -d .",
+    "disable_async": true,
+    "help": "reclaim caches / flag safe-to-delete clones"
+  }
+}
+```
+
+Now `gita reclaim` (or `gita reclaim <group>`) runs `git-reclaim` in each
+registered repo. No-config alternative:
+
+```bash
+gita shell 'git-reclaim -d .'
+```
+
+Note this runs it **per repo**, which suits the cache purge (`-p`) and
+`git gc` (`-g`) modes. For the cross-tree "what's safe to delete, biggest
+first" view (`-r`), run `git-reclaim` standalone against the parent folder
+(`git reclaim -r -d ~/projects`) so you get the single aggregate, size-sorted
+report.
+
+## Development
+
+```bash
+uv sync --group dev
+uv run pytest
+uv run ruff check src tests
+uv run ruff format --check src tests
+```
+
+CI runs the same checks on every push and pull request.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

git_reclaim-0.1.0/pyproject.toml

@@ -0,0 +1,68 @@
+[project]
+name = "git-reclaim"
+version = "0.1.0"
+description = "Reclaim disk space across a tree of git repositories"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [
+    { name = "Michael Borck", email = "michael@borck.dev" },
+]
+keywords = ["git", "disk-space", "cleanup", "repository-management", "cli"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Version Control :: Git",
+    "Topic :: System :: Filesystems",
+    "Topic :: Utilities",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/michael-borck/git-reclaim"
+Repository = "https://github.com/michael-borck/git-reclaim"
+Issues = "https://github.com/michael-borck/git-reclaim/issues"
+
+[project.scripts]
+git-reclaim = "git_reclaim.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/git_reclaim"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 88
+
+[tool.ruff.lint]
+select = ["E", "W", "F", "I", "B", "C4", "UP"]
+ignore = ["E501", "B008"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"
+
+[tool.pytest.ini_options]
+minversion = "8.0"
+addopts = "-ra -q"
+testpaths = ["tests"]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0.0",
+    "ruff>=0.4.0",
+]

git_reclaim-0.1.0/src/git_reclaim/__init__.py

@@ -0,0 +1,3 @@
+"""Reclaim disk space across a tree of git repositories."""
+
+__version__ = "0.1.0"

git_reclaim-0.1.0/src/git_reclaim/cli.py

@@ -0,0 +1,353 @@
+"""Command-line entry point for git-reclaim.
+
+The tool is installed as ``git-reclaim``, so git runs it as ``git reclaim``.
+It has three independent jobs:
+
+* report and optionally purge regenerable cache directories
+* compact every repository's ``.git`` with ``git gc``
+* list clones that are safe to delete because the remote has everything
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+from git_reclaim import __version__
+
+# Directory names that are regenerable and never source. dist/ and build/ are
+# deliberately excluded because they are occasionally committed.
+CACHE_NAMES = frozenset(
+    {
+        "node_modules",
+        ".venv",
+        "venv",
+        "__pycache__",
+        ".pytest_cache",
+        ".ruff_cache",
+        ".mypy_cache",
+        ".next",
+        "target",
+    }
+)
+
+# Directories not worth descending into while looking for repos. A directory
+# that is itself a repo is detected before this list is applied.
+PRUNE_NAMES = CACHE_NAMES | {".tox", "vendor"}
+
+GIT_TIMEOUT = 60
+GC_TIMEOUT = 600
+
+
+@dataclass(frozen=True)
+class Style:
+    """ANSI colours, disabled when output is not a terminal."""
+
+    red: str = ""
+    green: str = ""
+    yellow: str = ""
+    grey: str = ""
+    bold: str = ""
+    reset: str = ""
+
+    @classmethod
+    def auto(cls) -> Style:
+        if not sys.stdout.isatty() or os.environ.get("NO_COLOR"):
+            return cls()
+        return cls(
+            red="\033[31m",
+            green="\033[32m",
+            yellow="\033[33m",
+            grey="\033[90m",
+            bold="\033[1m",
+            reset="\033[0m",
+        )
+
+
+def human(kb: int) -> str:
+    """Format a size in KiB the way the old shell version did."""
+    if kb >= 1024 * 1024:
+        return f"{kb / 1024 / 1024:.1f}G"
+    if kb >= 1024:
+        return f"{kb // 1024}M"
+    return f"{kb}K"
+
+
+def du_kb(path: Path) -> int:
+    """Return disk usage for a path in KiB, without following symlinks."""
+    total = 0
+    for root, dirs, files in os.walk(path, followlinks=False):
+        for name in [*dirs, *files]:
+            entry = Path(root) / name
+            if entry.is_symlink():
+                continue
+            try:
+                stat = entry.lstat()
+            except OSError:
+                continue
+            blocks = getattr(stat, "st_blocks", 0)
+            total += blocks * 512 if blocks else stat.st_size
+    return total // 1024
+
+
+def find_cache_dirs(root: Path) -> list[Path]:
+    """Find cache directories under root, without descending into them."""
+    found: list[Path] = []
+    for dirpath, dirnames, _ in os.walk(root, topdown=True, followlinks=False):
+        current = Path(dirpath)
+        keep: list[str] = []
+        for name in dirnames:
+            entry = current / name
+            if name == ".git" or entry.is_symlink():
+                continue
+            if name in CACHE_NAMES:
+                found.append(entry)
+                continue
+            keep.append(name)
+        dirnames[:] = keep
+    return found
+
+
+def find_repos(root: Path) -> list[Path]:
+    """Find git repositories under root, stopping at each repo boundary."""
+    repos: list[Path] = []
+    for dirpath, dirnames, _ in os.walk(root, topdown=True, followlinks=False):
+        current = Path(dirpath)
+        if (current / ".git").exists():
+            repos.append(current)
+            dirnames[:] = []
+            continue
+
+        keep: list[str] = []
+        for name in dirnames:
+            entry = current / name
+            if name in PRUNE_NAMES or entry.is_symlink():
+                continue
+            keep.append(name)
+        dirnames[:] = keep
+    return repos
+
+
+def git(
+    repo: Path, *args: str, timeout: int = GIT_TIMEOUT
+) -> subprocess.CompletedProcess[str]:
+    """Run git in a repository, capturing output."""
+    return subprocess.run(
+        ["git", "-C", str(repo), *args],
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+        check=False,
+    )
+
+
+def git_tracks_files(path: Path) -> bool:
+    """True when git tracks at least one file inside path."""
+    result = git(path, "ls-files")
+    return result.returncode == 0 and bool(result.stdout.strip())
+
+
+def report_caches(root: Path, style: Style, purge: bool) -> None:
+    """Report caches and optionally delete them."""
+    caches = find_cache_dirs(root)
+    sizes = sorted(((du_kb(path), path) for path in caches), reverse=True)
+
+    print(f"{style.bold}Regenerable caches under {root}{style.reset}")
+    if not sizes:
+        print(f"  {style.grey}none found{style.reset}")
+        return
+
+    for kb, path in sizes[:12]:
+        print(f"  {human(kb):<8} {style.grey}{path.relative_to(root)}{style.reset}")
+    if len(sizes) > 12:
+        print(f"  {style.grey}... and {len(sizes) - 12} more{style.reset}")
+
+    total = sum(kb for kb, _ in sizes)
+    print(
+        f"  {style.bold}{len(sizes)} cache dirs, {human(total)} reclaimable{style.reset}"
+    )
+
+    if not purge:
+        print(f"  {style.yellow}(dry run, pass -p to delete these){style.reset}")
+        return
+
+    before = shutil.disk_usage(root).free // 1024
+    purged = skipped = failed = 0
+    for _, path in sizes:
+        if git_tracks_files(path):
+            print(
+                f"  {style.yellow}skipped {path.relative_to(root)} "
+                f"(git tracks files inside it){style.reset}"
+            )
+            skipped += 1
+            continue
+        try:
+            shutil.rmtree(path)
+        except OSError:
+            failed += 1
+        else:
+            purged += 1
+
+    after = shutil.disk_usage(root).free // 1024
+    freed = max(0, after - before)
+    print(
+        f"  {style.green}-> purged {purged} of {len(sizes)} dirs, "
+        f"freed {human(freed)} (free: {human(before)} -> {human(after)}){style.reset}"
+    )
+    if failed:
+        print(f"  {style.red}-> {failed} dir(s) could not be removed{style.reset}")
+
+
+def report_gc(root: Path, style: Style) -> None:
+    """Run git gc, and git lfs prune when available, in every repo."""
+    print()
+    print(f"{style.bold}Compacting repo history (git gc){style.reset}")
+
+    have_lfs = shutil.which("git-lfs") is not None
+    count = before = after = 0
+
+    for repo in find_repos(root):
+        rev = git(repo, "rev-parse", "--absolute-git-dir")
+        if rev.returncode != 0:
+            continue
+        gitdir = Path(rev.stdout.strip())
+        size_before = du_kb(gitdir)
+        git(repo, "gc", "--quiet", timeout=GC_TIMEOUT)
+        if have_lfs:
+            git(repo, "lfs", "prune", timeout=GC_TIMEOUT)
+        size_after = du_kb(gitdir)
+
+        count += 1
+        before += size_before
+        after += size_after
+        if size_before > size_after:
+            print(
+                f"  -{human(size_before - size_after):<7} "
+                f"{style.grey}{repo.relative_to(root)}{style.reset}"
+            )
+
+    saved = max(0, before - after)
+    print(
+        f"  {style.bold}gc'd {count} repo(s): .git {human(before)} -> "
+        f"{human(after)} (saved {human(saved)}){style.reset}"
+    )
+
+
+def report_safe_repos(root: Path, style: Style) -> None:
+    """List clones where the remote already has everything."""
+    print()
+    print(
+        f"{style.bold}Repos safe to delete (remote has everything), "
+        f"biggest first{style.reset}"
+    )
+
+    rows: list[tuple[int, str, Path, str]] = []
+    keep = 0
+
+    for repo in find_repos(root):
+        remotes = git(repo, "remote").stdout.strip()
+        dirty = git(repo, "status", "--porcelain").stdout.strip()
+        unpushed = git(
+            repo, "log", "--branches", "--not", "--remotes", "--oneline"
+        ).stdout.strip()
+        stash = git(repo, "stash", "list").stdout.strip()
+        tags = git(repo, "tag").stdout.strip()
+
+        if not remotes or dirty or unpushed or stash or tags:
+            keep += 1
+            continue
+
+        size = du_kb(repo)
+        last = git(repo, "log", "-1", "--format=%cs").stdout.strip()
+        url_result = git(repo, "remote", "get-url", "origin")
+        url = url_result.stdout.strip() if url_result.returncode == 0 else "?"
+        rows.append((size, last, repo, url))
+
+    rows.sort(key=lambda row: row[0], reverse=True)
+    for size, last, repo, url in rows:
+        print(
+            f"  {human(size):<8} last:{last:<10} "
+            f"{str(repo.relative_to(root)):<44} {style.grey}{url}{style.reset}"
+        )
+
+    total = sum(size for size, _, _, _ in rows)
+    print(
+        f"{style.bold}{len(rows)} safe ({human(total)}) / {keep} keep{style.reset}  "
+        f"{style.grey}(keep = dirty, unpushed, stashed, tagged, or no remote)"
+        f"{style.reset}"
+    )
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="git reclaim",
+        description="Reclaim disk space across a tree of git repositories.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=(
+            "(default)  dry run: report reclaimable cache space; deletes nothing\n"
+            "-p         purge the cache directories (git-tracked dirs are skipped)\n"
+            "-g         run git gc (and git lfs prune) in every repo\n"
+            "-r         list repos that are safe to delete (size, last commit, URL)\n"
+            "-d DIR     directory to scan (default: current directory)"
+        ),
+    )
+    parser.add_argument(
+        "-p",
+        "--purge",
+        action="store_true",
+        help="delete the cache directories",
+    )
+    parser.add_argument(
+        "-g",
+        "--gc",
+        action="store_true",
+        help="compact every repository with git gc",
+    )
+    parser.add_argument(
+        "-r",
+        "--repos",
+        action="store_true",
+        help="list repositories that are safe to delete",
+    )
+    parser.add_argument(
+        "-d",
+        "--dir",
+        default=".",
+        metavar="DIR",
+        help="directory to scan (default: current directory)",
+    )
+    parser.add_argument(
+        "-V",
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    root = Path(args.dir).expanduser()
+
+    if not root.is_dir():
+        print(f"Cannot cd into {root}", file=sys.stderr)
+        return 1
+
+    root = root.resolve()
+    style = Style.auto()
+
+    report_caches(root, style, args.purge)
+    if args.gc:
+        report_gc(root, style)
+    if args.repos:
+        report_safe_repos(root, style)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

git_reclaim-0.1.0/tests/test_cli.py

@@ -0,0 +1,224 @@
+"""Tests for git-reclaim."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from git_reclaim.cli import (
+    du_kb,
+    find_cache_dirs,
+    find_repos,
+    main,
+)
+
+
+@pytest.fixture(autouse=True)
+def git_env(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Keep git hermetic and set an identity for test commits."""
+    monkeypatch.setenv("GIT_CONFIG_SYSTEM", "/dev/null")
+    monkeypatch.setenv("GIT_CONFIG_GLOBAL", "/dev/null")
+    monkeypatch.setenv("GIT_AUTHOR_NAME", "test")
+    monkeypatch.setenv("GIT_AUTHOR_EMAIL", "test@example.com")
+    monkeypatch.setenv("GIT_COMMITTER_NAME", "test")
+    monkeypatch.setenv("GIT_COMMITTER_EMAIL", "test@example.com")
+
+
+def run_git(path: Path, *args: str) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        ["git", "-C", str(path), *args],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+
+
+def make_repo(path: Path) -> Path:
+    path.mkdir(parents=True, exist_ok=True)
+    run_git(path, "init", "-q", "-b", "main")
+    run_git(path, "commit", "-q", "--allow-empty", "-m", "init")
+    return path
+
+
+def test_default_dry_run_lists_caches(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    repo = make_repo(tmp_path / "a")
+    (repo / "node_modules").mkdir()
+    (repo / "node_modules" / "f").write_text("x")
+
+    assert main(["-d", str(tmp_path)]) == 0
+
+    out = capsys.readouterr().out
+    assert "node_modules" in out
+    assert "dry run" in out
+    assert (repo / "node_modules").is_dir()
+
+
+def test_purge_removes_untracked_caches(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    repo = make_repo(tmp_path / "a")
+    (repo / "node_modules").mkdir()
+    (repo / "sub" / "target").mkdir(parents=True)
+
+    assert main(["-p", "-d", str(tmp_path)]) == 0
+
+    out = capsys.readouterr().out
+    assert not (repo / "node_modules").exists()
+    assert not (repo / "sub" / "target").exists()
+    assert "purged 2 of 2" in out
+
+
+def test_purge_skips_a_dir_git_tracks(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    repo = make_repo(tmp_path / "a")
+    (repo / "target").mkdir()
+    (repo / "target" / "tracked.txt").write_text("hello")
+    run_git(repo, "add", "target")
+    run_git(repo, "commit", "-q", "-m", "commit target dir")
+    (repo / "node_modules").mkdir()
+
+    assert main(["-p", "-d", str(tmp_path)]) == 0
+
+    out = capsys.readouterr().out
+    assert (repo / "target").is_dir()
+    assert (repo / "target" / "tracked.txt").is_file()
+    assert not (repo / "node_modules").exists()
+    assert "skipped" in out
+    assert "purged 1 of 2" in out
+
+
+def test_purge_never_touches_refs_inside_git(tmp_path: Path) -> None:
+    repo = make_repo(tmp_path / "a")
+    run_git(repo, "branch", "target/v2")
+    run_git(repo, "branch", "venv/x")
+    (repo / "node_modules").mkdir()
+
+    assert main(["-p", "-d", str(tmp_path)]) == 0
+
+    run_git(repo, "rev-parse", "--verify", "-q", "refs/heads/target/v2")
+    run_git(repo, "rev-parse", "--verify", "-q", "refs/heads/venv/x")
+    assert not (repo / "node_modules").exists()
+
+
+def test_purge_does_not_follow_symlinks(tmp_path: Path) -> None:
+    repo = make_repo(tmp_path / "a")
+    outside = tmp_path / "outside"
+    outside.mkdir()
+    (outside / "keep.txt").write_text("keep")
+    (repo / "node_modules").symlink_to(outside, target_is_directory=True)
+
+    assert main(["-p", "-d", str(tmp_path)]) == 0
+
+    assert (outside / "keep.txt").exists()
+
+
+def test_repos_lists_clean_pushed_clone(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    origin = make_repo(tmp_path / "origin")
+    subprocess.run(
+        ["git", "clone", "-q", str(origin), str(tmp_path / "pushed")], check=True
+    )
+    subprocess.run(
+        ["git", "clone", "-q", str(origin), str(tmp_path / "messy")], check=True
+    )
+    (tmp_path / "messy" / "uncommitted.txt").write_text("x")
+
+    assert main(["-r", "-d", str(tmp_path)]) == 0
+
+    out = capsys.readouterr().out
+    assert "pushed" in out
+    assert "messy" not in out
+    assert "1 safe" in out
+    assert "2 keep" in out
+
+
+def test_repos_counts_unpushed_commits_as_keep(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    origin = make_repo(tmp_path / "origin")
+    clone = tmp_path / "clone"
+    subprocess.run(["git", "clone", "-q", str(origin), str(clone)], check=True)
+    run_git(clone, "commit", "-q", "--allow-empty", "-m", "unpushed")
+
+    assert main(["-r", "-d", str(tmp_path)]) == 0
+
+    out = capsys.readouterr().out
+    assert "clone" not in out
+    assert "0 safe" in out
+
+
+def test_repos_keeps_tagged_clone(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    origin = make_repo(tmp_path / "origin")
+    tagged = tmp_path / "zeta"
+    subprocess.run(["git", "clone", "-q", str(origin), str(tagged)], check=True)
+    run_git(tagged, "tag", "local-only")
+
+    assert main(["-r", "-d", str(tmp_path)]) == 0
+
+    out = capsys.readouterr().out
+    assert "zeta" not in out
+    assert "0 safe" in out
+
+
+def test_gc_runs_across_repos(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    repo = make_repo(tmp_path / "a")
+    (repo / "big.txt").write_text("\n".join(str(i) for i in range(5000)))
+    run_git(repo, "add", "big.txt")
+    run_git(repo, "commit", "-q", "-m", "big")
+
+    assert main(["-g", "-d", str(tmp_path)]) == 0
+
+    out = capsys.readouterr().out
+    assert "gc'd 1 repo(s)" in out
+
+
+def test_find_repos_stops_at_repo_boundary(tmp_path: Path) -> None:
+    outer = make_repo(tmp_path / "outer")
+    make_repo(outer / "inner")
+
+    repos = find_repos(tmp_path)
+
+    assert repos == [outer]
+
+
+def test_find_cache_dirs_ignores_git_refs(tmp_path: Path) -> None:
+    repo = make_repo(tmp_path / "a")
+    run_git(repo, "branch", "target/v2")
+
+    caches = find_cache_dirs(tmp_path)
+
+    assert all(".git" not in path.parts for path in caches)
+
+
+def test_du_kb_counts_file_data(tmp_path: Path) -> None:
+    data = tmp_path / "data"
+    data.write_bytes(b"x" * (1024 * 1024))
+
+    assert du_kb(tmp_path) >= 1000
+
+
+def test_help_exits_zero(capsys: pytest.CaptureFixture[str]) -> None:
+    with pytest.raises(SystemExit) as exc:
+        main(["-h"])
+
+    assert exc.value.code == 0
+    assert "usage: git reclaim" in capsys.readouterr().out
+
+
+def test_missing_dir_returns_error(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    missing = tmp_path / "missing"
+
+    assert main(["-d", str(missing)]) == 1
+    assert "Cannot cd into" in capsys.readouterr().err

git_reclaim-0.1.0/uv.lock

@@ -0,0 +1,203 @@
+version = 1
+revision = 3
+requires-python = ">=3.10"
+
+[[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 = "exceptiongroup"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+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 = "git-reclaim"
+version = "0.1.0"
+source = { editable = "." }
+
+[package.dev-dependencies]
+dev = [
+    { name = "pytest" },
+    { name = "ruff" },
+]
+
+[package.metadata]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "pytest", specifier = ">=8.0.0" },
+    { name = "ruff", specifier = ">=0.4.0" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/e1/2069291243c926a2ff1cd706c7f3eeb9b62144bf60f77c9fb9ff2fb26bd3/iniconfig-2.3.1.tar.gz", hash = "sha256:67f4b9c50da0dedf52af349e7749a80a9057a5031199791b906c3bb3ae878960", size = 21209, upload-time = "2026-10-06T22:48:38.076Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/56/43/4ca9e49d27a1fcf6bece6f6aec0ea46bb9112489b93d4b688fb415457bdb/iniconfig-2.3.1-py3-none-any.whl", hash = "sha256:9121e2c1fdb355232495be3194c8dfe87ccc2d5dee45947b78e68f499790d7a7", size = 7552, upload-time = "2026-10-06T22:48:36.959Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/bf/db/7fc19e6f2dc92a966727031389fc2e08b558f0f25eb7403c1119ad4713cd/pluggy-1.7.0.tar.gz", hash = "sha256:d1eaa46ebb595891b860ab086b4d09c8588af65ebd4361b8e8f4bb8920b90ba8", size = 123304, upload-time = "2026-10-15T09:50:58.343Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/40/9e/2b38731e0fc536806f16490e1a12d7f0dc2a1235aa8cc07bcc75416a7daa/pluggy-1.7.0-py3-none-any.whl", hash = "sha256:7dd7b0d8832ba3cb632c306926ded123429211b83641b35dc5c41ad2d34f9bec", size = 27082, upload-time = "2026-10-15T09:50:56.808Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.21.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.2.0"
+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/79/42/bb4641652e58dedeac2ec51abc1f8cae4fee4ec63899a0999016229a0f2a/pytest-9.2.0.tar.gz", hash = "sha256:97c4f3b1f3c7414aa36465e09b8220f1d03627993bd51b1282e193753c80557b", size = 1797555, upload-time = "2026-10-27T21:30:20.728Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/51/39/1f5d8c8877a0fa327db959c19341d4be61660de1ab6b7391f9eb805bcd67/pytest-9.2.0-py3-none-any.whl", hash = "sha256:07acdcf88ec174f907dc01af70bf52d49b014bbab03faeeade31c96b18c2e588", size = 411776, upload-time = "2026-10-27T21:30:19.131Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.17.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/59/73/81f140c4edd9cc323de5478e6bbd3bbcfae9a82692df1a258de8cec6a6d2/ruff-0.17.3.tar.gz", hash = "sha256:a57049c8addb3662073859bb55a7ad35aa54f8a7c9ed268911d1333c5aadaaa9", size = 5339444, upload-time = "2026-10-27T00:34:05.914Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/8c/083365310c4e79c842f25bf5a842facbd9b0c0ec336f96dffa5074fe723d/ruff-0.17.3-py3-none-linux_armv6l.whl", hash = "sha256:ab86b84cd9d05e56d329742c0cabdcbe2d1d56c98f4a04aab9b5b66196febfb4", size = 10216522, upload-time = "2026-10-27T00:33:29.822Z" },
+    { url = "https://files.pythonhosted.org/packages/72/26/4b2edf31cfebe9605d8f6ed8f1d6f376d3a53d4c9a123e62661c64c440f0/ruff-0.17.3-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:e407b4a6852853a9a2cdce96963e94ad9775578bb44e7561a0f2829f3cc04b11", size = 10217786, upload-time = "2026-10-27T00:33:33.949Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/7e/537aba4b7f54397a374d2f6a6fc93e9c8015e18553f31a4a7b7dbced48b5/ruff-0.17.3-py3-none-macosx_11_0_arm64.whl", hash = "sha256:b75cc113b3aca388933d8296b667b1ac401a80317ea3074c9b0a66541199da29", size = 9440362, upload-time = "2026-10-27T00:33:35.784Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/66/283e39734f66c8a5ebaa93c22eb7b7515779a0b1d5a5c0ad20e05c0edb41/ruff-0.17.3-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ab5fa7ed5ce18554ea69d850ad162cbaa0c85fc47c08d83a569f806681c9a6ad", size = 10094281, upload-time = "2026-10-27T00:33:38.216Z" },
+    { url = "https://files.pythonhosted.org/packages/21/4c/1ffc768497bd025a32c72152771e40c0b99bddc5cc6e4f50c7949a395346/ruff-0.17.3-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c673c170e27834d1262e3a9c1e97bdc9b9c3b180c63d89173ce69747232474c1", size = 10022543, upload-time = "2026-10-27T00:33:40.181Z" },
+    { url = "https://files.pythonhosted.org/packages/73/c3/f90db547301080fcb82c92abf914c8bd57b89911d9b65a6c4cc6b52d0635/ruff-0.17.3-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6a754c0341bc9ca151b7b335988b3263921c08859f84ca219b70cee825571b6f", size = 10683921, upload-time = "2026-10-27T00:33:42.182Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/98/92d4a8a26c6c96cf1a5b34dd59036d8a71e52d650aab065c58867e964e63/ruff-0.17.3-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4590b9d86c0b1543ebb09094254e191cd43fe8edaf330baa035aab03da251532", size = 11373408, upload-time = "2026-10-27T00:33:44.19Z" },
+    { url = "https://files.pythonhosted.org/packages/43/02/1f24d2e3064c9753926deeb901afa57777b37ee46799b09ddd7aee6e5145/ruff-0.17.3-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bbde18beccd98c29a227c63c99022e3443b99258e08326df6425dfe0443705ef", size = 10977469, upload-time = "2026-10-27T00:33:46.179Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/20/fecedea2209f574ab92033b344e01a7f0c2dc76c6d6d19a14c9f8141173f/ruff-0.17.3-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7fa4b0f931cdbcb8a52044f370a3eb429fb42eb88807b0e800fcaa98dd42b24e", size = 10577491, upload-time = "2026-10-27T00:33:48.233Z" },
+    { url = "https://files.pythonhosted.org/packages/33/36/b93fdf0bc6f84f0cd487aadfb0354deb40013669ea35ac3d26855de1e959/ruff-0.17.3-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:39405f341deec934b4289634324ad695f72df2970f9121582872eaf5b722f0f5", size = 10608748, upload-time = "2026-10-27T00:33:50.284Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/b7/7d3f5f14145daead1efb0b9a8289ed1daa100f419d60774375951723ce00/ruff-0.17.3-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:68074094f55ca3d29ab19491f640282f7a84061c4c7977aa5094b968ca457e9a", size = 10075057, upload-time = "2026-10-27T00:33:52.074Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/ed/93ff7a5909ee56e2bd4b982deae9e0efb2724417874a90c9e41ad66c6dd7/ruff-0.17.3-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:27bb571ac78fef178fe5118d2827df95c2aae74a48fff2b15f6acd03af5ff5bb", size = 10022431, upload-time = "2026-10-27T00:33:54.061Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/07/a83b9eeec8c1c3c0e4eda15f06c3a91001bfd2687ea2f07b750719bf9712/ruff-0.17.3-py3-none-musllinux_1_2_i686.whl", hash = "sha256:029c37cbd3de48ca37aa12117bead2d065f15da17d66bf84e0d4274013705db2", size = 10394903, upload-time = "2026-10-27T00:33:56.158Z" },
+    { url = "https://files.pythonhosted.org/packages/af/b2/05c39857c2526fcbebe46ad93a8dc97424656dfef14d3ef933abe1ffd331/ruff-0.17.3-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:692fdb46d0fd9c71e380947dc5fc72f2c3f881073bc1f739e4579376231affbe", size = 10799780, upload-time = "2026-10-27T00:33:58.204Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/d9/47171a16739eb7a353936b31c20cf54340531e68c9af7d72fd7a784e235d/ruff-0.17.3-py3-none-win32.whl", hash = "sha256:46539cb031b01fd29ae0a02142483c46640b233ee12bb1c1b690bffa1555d5ca", size = 9908481, upload-time = "2026-10-27T00:34:00.087Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/a0/f08c1631bfd81faa6a90eaf70c37c786c11bed2046302b56bb506c25e1a0/ruff-0.17.3-py3-none-win_amd64.whl", hash = "sha256:56b8ffb3f3b3cbccb8b76b71b38261b7ed982ef5d20f5b447b1b61a7f4949b24", size = 10341333, upload-time = "2026-10-27T00:34:02.099Z" },
+    { url = "https://files.pythonhosted.org/packages/99/d5/4ad4ed31413c301430918e70d3d38ae6f097af0766cb9ab8c9d502b2a4d6/ruff-0.17.3-py3-none-win_arm64.whl", hash = "sha256:81fce74bcd6be0e9da7c67c7553fd0f1f12964a2052cd728ef917b937a5ca1d9", size = 9854332, upload-time = "2026-10-27T00:34:03.847Z" },
+]
+
+[[package]]
+name = "tomli"
+version = "2.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/78/9ad63712633ed3ab5cc1a648d863d7e7da371e9425e209555a0fe711b695/tomli-2.5.0.tar.gz", hash = "sha256:264507556cd8b8c8e7c6ee037cdf443a463f03f4c958e57195e3d369711b8ff6", size = 17662, upload-time = "2026-10-07T12:23:37.892Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/22/a6/ab99b60ee52acd949684febabc3005d0045d0f66bebd9cdebd67372d26dd/tomli-2.5.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c4dc1c1781f2f716de763d1e9a7b34c6a894e167e291c7c5d16c72f7a9538545", size = 163901, upload-time = "2026-10-07T12:22:15.601Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/00/ee01b7ed4579180fff07142d290257f25ba786f23f3ec6005f620933c2f5/tomli-2.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:eff8babca5a7999bc137acbc7482a8b7e17ffca5075ab41f5d770ab408c7bfef", size = 163756, upload-time = "2026-10-07T12:22:16.957Z" },
+    { url = "https://files.pythonhosted.org/packages/72/c2/4efebf65372f6583185f79799312109dddb61102d47e5c33dcfd1a297aca/tomli-2.5.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:86665cee9c4835b7a7f1e8ec2c719b5258d4dc782887aded5a8ae7352a96843b", size = 268038, upload-time = "2026-10-07T12:22:18.135Z" },
+    { url = "https://files.pythonhosted.org/packages/53/07/5850468e925d898abb36038666f9c333a94d2a223e802a8ba5b6d319d23f/tomli-2.5.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7e369fd63331746182360977b1892bfc215476a30d61612d732425311639f56", size = 276422, upload-time = "2026-10-07T12:22:19.567Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/87/f293984cdcf83c054196d4fd3dad44fc68ae55b4b8c44bc76cef360c3150/tomli-2.5.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7ad1ea345759240d6463efa0ed1c704402752e49aa21476620738d74d72d8aa1", size = 272616, upload-time = "2026-10-07T12:22:20.794Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/ce/db582886b3c1219d3fec93ebd669332482e5aee7a91e0f7838d84f2d1759/tomli-2.5.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:96243987194634bd411066ce40c952e108f86af04db533ecd8ac3ff2a85b1885", size = 276593, upload-time = "2026-10-07T12:22:22.12Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/72/7619b87dea4261fc27dd7b54c4461c129c1f7d9bb7ba3aec89c797a431b8/tomli-2.5.0-cp311-cp311-win32.whl", hash = "sha256:610b27d99f28ec5f191c7064a48f3ddb179a1fe6ca73d571483ae859f57b605e", size = 101830, upload-time = "2026-10-07T12:22:23.651Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/74/220106da34502304b6751a2a9b8a9fbca6c3fd47e737a2e2e3da7c61c9db/tomli-2.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:c804ae44fe7b4bab5da295e4f980a1ff04670bca9d23fe0a4e887e08ebd741a8", size = 112742, upload-time = "2026-10-07T12:22:24.972Z" },
+    { url = "https://files.pythonhosted.org/packages/27/99/7d9c8b41837a7773613e169504147375c157a290167aa59ad74a085f521f/tomli-2.5.0-cp311-cp311-win_arm64.whl", hash = "sha256:cfac177ebd6236003846ea339981f71457cb6eb748f23381eb257e45092e3980", size = 109332, upload-time = "2026-10-07T12:22:26.117Z" },
+    { url = "https://files.pythonhosted.org/packages/52/ed/7baa86f87493646a594de388c7c1c40a39dd0461f7e9c0359cbeefc91fe8/tomli-2.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:1f4a40d03fb9f63424f0979855bdeaf44dd7696b8d59501822c10ed30ba532df", size = 164854, upload-time = "2026-10-07T12:22:27.444Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/b1/44c0341f2224397855723c7a8a39f718ea6fcbcc3dacc66e5aeca0f334e3/tomli-2.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9ebf8d19b17bd0daeb7b7dec81a946a439b753942fd0210d6e96c532249eea6b", size = 164074, upload-time = "2026-10-07T12:22:28.679Z" },
+    { url = "https://files.pythonhosted.org/packages/23/04/e2d5b7d3fba47adedb23de616c16d428ea076c79a3d8e1d95d649ffe197e/tomli-2.5.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf0b5e8e0f68ebb494356e577c06c139161efd8d3b9050f93b39b7c26cc54ff0", size = 274274, upload-time = "2026-10-07T12:22:29.804Z" },
+    { url = "https://files.pythonhosted.org/packages/43/90/6090e706ff27a6f89f4a40578e3324b95c3cd8c4150868aabf33a8f414c3/tomli-2.5.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6cf74416bdc94ae458b14e37286c1073081850ac8459a00d0c5efef5d44294c6", size = 286435, upload-time = "2026-10-07T12:22:31.297Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/9e/a2c40768df16c408f22430afb0a73e9d7e5f79c950884954649d1146b74d/tomli-2.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:61ea1ebe1e55a34ea8199cc8dbff398d35027b82271c8ac4802fd3a1fd5b1bcc", size = 278119, upload-time = "2026-10-07T12:22:32.601Z" },
+    { url = "https://files.pythonhosted.org/packages/12/25/3c0cb485b98e9cfac495629b1c93c87ccf0b72fbe9d2689fd8fe62c6d5a3/tomli-2.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ed53f7e89bb04f6d9e8e7799112360b0c4d5cbff067de0814c98c37c39b920f7", size = 286177, upload-time = "2026-10-07T12:22:33.745Z" },
+    { url = "https://files.pythonhosted.org/packages/77/8b/0144c65f0e37e51c18d04ae15c21b19431c165002d0131fe9aa8b0b8b1e8/tomli-2.5.0-cp312-cp312-win32.whl", hash = "sha256:e7ad033e27a516a233bea839cdb77b80146facb3b4f40bf02cd0cac165cdd5c2", size = 102760, upload-time = "2026-10-07T12:22:34.887Z" },
+    { url = "https://files.pythonhosted.org/packages/de/32/5d6d8f42fc9a05fce69354e00ff256484192f5f2fc9a2165718fa0de61ec/tomli-2.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:bd05de8c1698f8413dd7d869492693a0bf2211543b787ac78cd5e7536af1a6d7", size = 112722, upload-time = "2026-10-07T12:22:36.162Z" },
+    { url = "https://files.pythonhosted.org/packages/30/65/df18032218db0fb9b769fb23c8039a051f15c811993995ea04c350273a32/tomli-2.5.0-cp312-cp312-win_arm64.whl", hash = "sha256:069435bd5480429b98c5e5afb02ab21c219b6f0064680671c6dc0d46817346ea", size = 109534, upload-time = "2026-10-07T12:22:37.296Z" },
+    { url = "https://files.pythonhosted.org/packages/42/e5/51736d70da209350969e15aca5c5ab6e2ce1ea87a0a892a6c13aec172a86/tomli-2.5.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:943276cf269e0071948d9ff697159c1735e623c1151d88abb09b74659ef0cbea", size = 163328, upload-time = "2026-10-07T12:22:38.373Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/55/086f80dab4ab497602644274e6dea7ec5dd0b4e262e443a8ad3bb7edee2d/tomli-2.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:463b16086865b97facd8d0b3fb4cb7c544e3f58d2a69dc3113d6db9653fdb043", size = 162246, upload-time = "2026-10-07T12:22:39.673Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/eb/3ecc94459f3635c92321f4e7bde571323fdb2267c50e19e3188a281eae3b/tomli-2.5.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1245a6638fc4bb0a60af38a7d45413db34a13842027c77597c712c998c62fdf0", size = 272655, upload-time = "2026-10-07T12:22:41.08Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/d7/494fd1f0c37a621f1ad9975c2efadb523e8101f144ed6edb2e7fe64738f2/tomli-2.5.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5d8bac3d603c97e6854424e5b2b5b741bdbde387e09f162fb0446812b4a8362b", size = 283595, upload-time = "2026-10-07T12:22:42.222Z" },
+    { url = "https://files.pythonhosted.org/packages/70/51/bb8d62b1317e6640866f6949b2d5855e5300f2c99d46de1cd245570bba65/tomli-2.5.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:21e4cae4114aba25aa0d4f85cdf486d290fb35c0954d7bba536248da64d43066", size = 276253, upload-time = "2026-10-07T12:22:43.625Z" },
+    { url = "https://files.pythonhosted.org/packages/66/f4/f46bd7f0763cd47de2db697dca9257c6a4adfd1a93b018cc75c8190ed5a8/tomli-2.5.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:bbaefc84548d754be821bba7c4141c4787dda182f9e77f2f87b71213529efa7b", size = 283582, upload-time = "2026-10-07T12:22:44.983Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/03/70f2bcb2923a6db37818d917e124270a7f4cfd38ea576f5aa753a91c0ef5/tomli-2.5.0-cp313-cp313-win32.whl", hash = "sha256:abdbf6313b8d9efe157edeb7ab6eae4de064b1300ad31abf73755154b30abe68", size = 102628, upload-time = "2026-10-07T12:22:46.508Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/98/d52024bb5b0ff68b4f0d276d867f634c84a67319a7e9f6b7708a37742333/tomli-2.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:fd4dc129784e0c5335bd4e61dfcc4487499a013419e655cf2da1d091b7e0efdc", size = 113301, upload-time = "2026-10-07T12:22:47.647Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/f2/540db3a70572a8c23a28aba3e9c358ce0ffffbafc990905c1343aa265b31/tomli-2.5.0-cp313-cp313-win_arm64.whl", hash = "sha256:69491c143d2fe063046e0301e62a810bed338fa4d1ce0fd870c27dc1e09b0d84", size = 109744, upload-time = "2026-10-07T12:22:48.925Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/49/caf6b307766eb9567664a8707e9d6be5fcc0e8903f18781c6677a60d80c7/tomli-2.5.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d3182ee2d887e507bd67319a0a61105d1dd33facc111329559a233b772c1a105", size = 162899, upload-time = "2026-10-07T12:22:50.088Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/c8/68cfce773a2733a49c74f99d627fb461bd990756860099eac25617889585/tomli-2.5.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:521345fd1f19d45b8df87657aaa38b6f2ca3800059fadf428e7ebf479a383646", size = 162080, upload-time = "2026-10-07T12:22:51.558Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/b2/e5bb8651fdad593f670501a7d718b1a7f73f064d44dea15e04c04dfef45d/tomli-2.5.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e95c7614e705bfe2b04b27aa124adec59752d15813df37e2156747cab3a006b", size = 273380, upload-time = "2026-10-07T12:22:52.918Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/d2/9e2d7f8b1dfe0e2b34c245986ebd55c4c553ea4ce6c47c443b332673253f/tomli-2.5.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7ac2027d37c3afbdf4bdd377f2676f6f1d2122a5be1f1137b49dced590b37e75", size = 283228, upload-time = "2026-10-07T12:22:54.173Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/df/ec7b876b7b1a2718bd74a3743c076fff565b04029ba33e8f61fac262739f/tomli-2.5.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c414be4ed9d3cac80c42e348fa5a956117d1a48227f48026e31f59cb4a7671eb", size = 277189, upload-time = "2026-10-07T12:22:55.342Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/7b/e192d9eed0b9cb80da799f4d77052297fb9a2c3cc9b19f571f56ea88add6/tomli-2.5.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9b03d7dc168353b4132965bde20feceabaa470e570c6f59660dfae59b1f9eeb3", size = 283632, upload-time = "2026-10-07T12:22:56.735Z" },
+    { url = "https://files.pythonhosted.org/packages/84/50/ff94454e75461d75623e47401ed323d65c10aab8fe9033242c20cd2fdf32/tomli-2.5.0-cp314-cp314-win32.whl", hash = "sha256:6f041843c4d3a37245c0c056fd955b186bf8b1fb85690cbe40b81230891dc34b", size = 103535, upload-time = "2026-10-07T12:22:58.084Z" },
+    { url = "https://files.pythonhosted.org/packages/54/0b/bdacf05f963bd6026ebf6eeb0beda847d1d60e03e440725c64a4e08a0afd/tomli-2.5.0-cp314-cp314-win_amd64.whl", hash = "sha256:f4b653094e18f9031102d3a1da5c729c8f222d85225b18037dac621695e46e1a", size = 114621, upload-time = "2026-10-07T12:22:59.2Z" },
+    { url = "https://files.pythonhosted.org/packages/61/99/53f438fa6ae4f9d4ed0ddde3e7242b3bdc34b48c8f9948b72b9e9b127676/tomli-2.5.0-cp314-cp314-win_arm64.whl", hash = "sha256:3f89d10c1ff6a38d992c27fc8a4816af71a909e08a40ec66934240b1e74347c3", size = 111572, upload-time = "2026-10-07T12:23:00.479Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/20/1f88f19427d380a40e90a770e087489eaafe4aeee070ae88ed2bbec00acd/tomli-2.5.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:e9e15b4a6c7dd6b85b5fbab29488a73f1f70de516942308daa266bf0e0aeb0d4", size = 171814, upload-time = "2026-10-07T12:23:01.914Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/56/cbe5079c9f9a54b9b3e27fc82f08f3cb36edee75561679f53d2380c801d6/tomli-2.5.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e12bbcd32897272fb05929110362ae9ff4c1b9bb26bd9e971e71dcd3275b4c3d", size = 171324, upload-time = "2026-10-07T12:23:03.18Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/30/1d53fd3b0f1cb3ba542e345ec32c26aefdddc4e829e4f3429af8a4f27782/tomli-2.5.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:20aa36de8f2cf87237143bc1fa1aae8d6612c09118f4da21c6a684db5dd1f6f9", size = 297441, upload-time = "2026-10-07T12:23:04.345Z" },
+    { url = "https://files.pythonhosted.org/packages/66/d9/0800acb6a111686f764c1b91ef15cc42a20a66a46013bb42220f1d2c61c1/tomli-2.5.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:22185fad8a1e622f064e78008018a0dd3323550dcb479cb7a1d296888d74024f", size = 307476, upload-time = "2026-10-07T12:23:05.671Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/63/30a8f3cd51b5bec37f04744bad0b0dc6160df84aad4f27b0e9283d66f221/tomli-2.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:984012f71908165449a951de2050d52f276bfe3aa5d5f570f63ddad814370374", size = 296113, upload-time = "2026-10-07T12:23:07.202Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/18/0b9ffc597e69c5a1e20a7823cb60d54b39a9f54e91edcb8574f022186758/tomli-2.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f79203b3965b4000e91808aaa7c040206093f2b8bf86f455982f2274c9ccf442", size = 307725, upload-time = "2026-10-07T12:23:08.508Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/c7/18f8baae0b5607a60e8e19b4a7fedee43a8ff6458e3896dcbbadeeac9c22/tomli-2.5.0-cp314-cp314t-win32.whl", hash = "sha256:91294a9fb94a75542f6e46e4a2ae709bd8d9b51134098cae5cf3bea5478b6d03", size = 108546, upload-time = "2026-10-07T12:23:09.956Z" },
+    { url = "https://files.pythonhosted.org/packages/72/34/4cca9739254130627bde87500b3f2b512154fe2f278efa7e2a5e10ad4bcb/tomli-2.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:f15e3e0b835a6d68b10c86bf80a3149780498d6911c93c3ffd1861d19f9200f1", size = 117814, upload-time = "2026-10-07T12:23:11.486Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/fb/afa530d47dd80a78fce43beac6bc6e00f84558eafcffbc6f37b21e80d056/tomli-2.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:6664b7ae7af7294256c53960a6103077f4914cec8ff98479c352f622c6f6b2f0", size = 115188, upload-time = "2026-10-07T12:23:12.728Z" },
+    { url = "https://files.pythonhosted.org/packages/66/98/316fdc00f8c0939e6fe50461dd343c162d3ad51d1286eb25b7db54361d50/tomli-2.5.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:a525685c2f97da40762b8695eb7aa0af4c8344ca1905c73e4e29cb04d34607dc", size = 162775, upload-time = "2026-10-07T12:23:13.941Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/22/7b10fa5bb01c9539f53f69b619361b19350acc73657772ea7ac70ba309a8/tomli-2.5.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:9dbb18c1cfb2f6517942fc9314437f66aa06d94436ffb1f06102ef3572f35276", size = 161406, upload-time = "2026-10-07T12:23:15.215Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/e7/1a069d86dfd20f1f84f71c63faed9f83c1d890bc06c27d82dc7d888fb573/tomli-2.5.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:752e8b1aa6a4367ef8bf6a1a1e005540f7ed055ba36d7193796812ca5404eb52", size = 273855, upload-time = "2026-10-07T12:23:16.471Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/83/d1ef43d1687d092ab9c235455c76e6e709483b346b056f086095c7c263a5/tomli-2.5.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c47300f9bf791808f77d82747691c4bb09cb14bdf3060cca99b42cdc4361d5a7", size = 284910, upload-time = "2026-10-07T12:23:18.166Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/05/f4d9cf7de61822ece0c3873f30d291e324911c71a378b8bfe5ced13fd9f5/tomli-2.5.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:19b0dd8749f4ea2f112c5fcfb3c5248390c899d7e2e173f1d91abee1fa0ff391", size = 277723, upload-time = "2026-10-07T12:23:19.355Z" },
+    { url = "https://files.pythonhosted.org/packages/42/28/78262493141fa543151cf005760c3cb01d09fc28a11f993c05109902cb8c/tomli-2.5.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:57b1c3b01fab802e2899bc3d168dca320e14165e2fd9fd584760fb4ca5826859", size = 285115, upload-time = "2026-10-07T12:23:20.698Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/b9/e1dab9a30bcb677b5cc5cee810609cfd64f24306a3055767dd3fda00b1e0/tomli-2.5.0-cp315-cp315-win32.whl", hash = "sha256:667e521b37a6c5ccaa044202c235b530f90177ffe2cd4a64ecc213c7dd535feb", size = 103475, upload-time = "2026-10-07T12:23:21.941Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/bd/31a3790c11d6ea95fcf5e6022ac0f8d0543c9b61120b730fc481bd43d3b4/tomli-2.5.0-cp315-cp315-win_amd64.whl", hash = "sha256:d747252933c8a65ef6bd8da0fbb7ce28a90eb6119d8cd00772cd528aa07b68d5", size = 114589, upload-time = "2026-10-07T12:23:23.098Z" },
+    { url = "https://files.pythonhosted.org/packages/47/a2/4f6310fa699364f0e3af7ee3af88dddd9af066d33e716a0265bbe2b3ea84/tomli-2.5.0-cp315-cp315-win_arm64.whl", hash = "sha256:75dbcde8751b0a960aa3de173aa5e894d590755c6d7758b7e774c06f1dc3cbdd", size = 111493, upload-time = "2026-10-07T12:23:24.233Z" },
+    { url = "https://files.pythonhosted.org/packages/68/14/00853f0b396d8971107ae1921bb5b322fdee1650d2f16bf06c20adb532e5/tomli-2.5.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:2419c2a189551987b59d80e63ec355671283336f41c6b9b89462df679c7d0c57", size = 171380, upload-time = "2026-10-07T12:23:25.512Z" },
+    { url = "https://files.pythonhosted.org/packages/89/ad/fa6949321dadee46b27363974fb197b94c911c3b0f7a5fd26d7dc18fc2a0/tomli-2.5.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:0dc598040da8d42cf20f0be588ed7004f46db12a0ac6c32e03a59dccedaaadcd", size = 170553, upload-time = "2026-10-07T12:23:26.855Z" },
+    { url = "https://files.pythonhosted.org/packages/53/aa/3056c919eb3e084df3752b2cf5f865dcc04af0b27dba2f66d7b28af4633a/tomli-2.5.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49096930c8d886c9bbdab62d2d0d17ce823ddeea522309a190b36245d5b49e01", size = 294428, upload-time = "2026-10-07T12:23:28.132Z" },
+    { url = "https://files.pythonhosted.org/packages/96/b2/faeeb5d8769ea3832021d73e892c8391eae7b4b4f8b55a789127bd8b18a9/tomli-2.5.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8ade5023067f99fe72b88accd30d0ea05a158e9e32a11f124e731ea9695313f", size = 304909, upload-time = "2026-10-07T12:23:29.381Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/52/f094c09e73fb654b621716d019acb5d29bdfd1be01df80c281d552bda48d/tomli-2.5.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:b69564772b5c8f22ea5f498dff08cfa825045b4d4c4400529000bdf818aa3b2a", size = 293220, upload-time = "2026-10-07T12:23:30.608Z" },
+    { url = "https://files.pythonhosted.org/packages/86/f5/0c30541078ca4b505ce3bd76ed931facbfec524dd018535d691d1af0a6d2/tomli-2.5.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:8ff3a2ca028c7eee0c777f9a092038d0a594a9fa04e215f929a22c329e2cb142", size = 305705, upload-time = "2026-10-07T12:23:32.181Z" },
+    { url = "https://files.pythonhosted.org/packages/05/74/590e7d19d6a118fc5cc5704ff358e21d95b8573f6b9443b1519f29ca8825/tomli-2.5.0-cp315-cp315t-win32.whl", hash = "sha256:62fc1bc8eb03e3a9cadfca713d65614ed8e09d974a283295ffe3a831976b4dc5", size = 108432, upload-time = "2026-10-07T12:23:33.496Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/b8/63a75cfb27a17c38550e44025d3a6e7be64516fd8608a3b75703bf37d81b/tomli-2.5.0-cp315-cp315t-win_amd64.whl", hash = "sha256:f3fcbc57b1791fa6cbe5d8434179d51de12be1a4811469529f47f6e7487a2571", size = 117281, upload-time = "2026-10-07T12:23:34.648Z" },
+    { url = "https://files.pythonhosted.org/packages/72/01/e8c1debb2173973372934c68fc8e46170ab60ef23ed4592dff4dec6e8993/tomli-2.5.0-cp315-cp315t-win_arm64.whl", hash = "sha256:d2ba24db8a9376921b5e87b4762b9adb0f3f1deaea68f2b8b0bb2c11efb9c3e7", size = 115069, upload-time = "2026-10-07T12:23:35.77Z" },
+    { url = "https://files.pythonhosted.org/packages/60/3f/3e3f8fd0919249b0200c80fbc4f9a1e70be19f9883da71dfb7f8b9ab8aca/tomli-2.5.0-py3-none-any.whl", hash = "sha256:32a7b79ac57a2e83670ce329ccf675798bc5a2094783a63676866b70503f2e2b", size = 14765, upload-time = "2026-10-07T12:23:36.875Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" },
+]