bashrun 0.1.0__tar.gz

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

@@ -0,0 +1,51 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+
+      - uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+
+      - name: Lint
+        run: uv run ruff check .
+
+      - name: Format
+        run: uv run ruff format --check .
+
+      - name: Type check
+        run: uv run basedpyright
+
+      - name: Test
+        run: uv run pytest
+
+  publish:
+    needs: check
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      id-token: write
+    steps:
+      - uses: actions/checkout@v5
+
+      # Workaround: fetch-tags is broken with shallow clones
+      - run: git fetch --tags origin
+
+      - uses: astral-sh/setup-uv@v7
+
+      - name: Publish
+        run: uvx --from git+https://github.com/outernet-foundation/pubpkg.git@ea2ecf35a93a3c6405b9430a651d2a7b3d2faa6c publish-packages --config publish-config.json

bashrun-0.1.0/.gitignore

@@ -0,0 +1,12 @@
+**/__pycache__
+**/*.pyc
+**/*.pyo
+**/*.pyd
+**/.venv/
+**/*.egg-info
+**/build/
+dist/
+.pytest_cache
+.ruff_cache
+.env
+bookmark.md

bashrun-0.1.0/.python-version

@@ -0,0 +1 @@
+3.13

bashrun-0.1.0/AGENTS.md

@@ -0,0 +1,42 @@
+# bashrun
+
+## What this is
+
+`bashrun` is a zero-dependency Python wrapper around `subprocess` that closes the sharp edges a plain `subprocess.run` leaves open: quoted arguments are `shlex`-parsed so `bash_output("echo 'hello world'")` behaves the way it reads; shell operators (`|`, `||`, `&&`, `;`, `&`, `<`, `>`, backtick) are rejected in single-command helpers so a caller can't silently rely on shell expansion that isn't happening; `KeyboardInterrupt` waits up to five seconds for the child to exit before killing it, so Ctrl+C isn't swallowed and children aren't orphaned; failure paths raise `CalledProcessError` with `stdout` and `stderr` attached rather than a bare non-zero return code; and on Windows, `PATH` resolution happens up front so a missing executable fails with `FileNotFoundError` instead of the platform's `WinError 2`.
+
+The package is `bashrun` (src-layout under `src/bashrun/`); consumer repos declare it as a registry dependency (`bashrun>=0.1.0`) once published, and a git source pin only in scratch branches testing unreleased changes.
+
+## Shape
+
+- `bash.py` — all seven helpers, one file. Each is one shape of "run a command":
+  - `bash(command)` — streams stdout/stderr live; raises on non-zero. The default when the caller doesn't need the output. Accepts `log_path=` to tee both streams to a file instead of the terminal.
+  - `bash_output(command)` — captures stdout as a `str` and returns it; stderr is buffered and, on failure, printed to the parent's stderr and attached to the raised `CalledProcessError` alongside the partial stdout.
+  - `bash_check(command)` — runs silently; returns `True`/`False`. For idempotency probes ("is this already done?") where the failure mode is expected and no output should surface.
+  - `bash_check_stream(command)` — like `bash_check`, but streams output. For probes whose progress the caller *does* want to see.
+  - `bash_no_raise(command)` — streams output; never raises regardless of exit code. The rare shape for fire-and-continue.
+  - `bash_pipe(cmd1, cmd2, ...)` — runs a real shell pipeline by chaining child processes' stdio in Python; each intermediate's stderr is discarded, the final's is preserved. This is why `bash`/`bash_output` reject `|`: pipelines have their own helper.
+  - `bash_handoff(command)` — `os.execvpe`s into the child (Windows falls back to `subprocess.run` + `sys.exit`). The current process is replaced; no return.
+  - `first_stderr_line(error)` — the first non-empty stderr line of a `CalledProcessError`, falling back to `str(error)` when stderr is absent. The one-liner shape for surfacing "why did it fail" in a verdict row or problem message without dumping full stderr.
+- `__init__.py` — re-exports the seven helper names plus `CalledProcessError` (the type `bash`/`bash_output` raise on failure), so consumers can catch the wrapper's own failure shape without importing `subprocess` themselves; the re-export is routed through `bash.py`, so the `# ruff: noqa: S404` boundary stays that one file.
+
+## Constraints
+
+**Zero runtime dependencies.** The whole point is that consumers can git-reference `bashrun` from any repo, sandbox, or CI job without dragging a dependency graph in behind it. Adding a runtime dependency negates the reason this package exists as its own repo. Standard-library-only is a hard rule.
+
+**Every command goes through `_check_no_shell_operator` and `_resolve_args` (except `bash_pipe`).** `_check_no_shell_operator` strips quoted segments and rejects any remaining character in `[|;&<>\`]` — pipe, logical-OR/AND, sequence, background, redirection, and backtick command substitution. bash's helpers run without a shell, so any of those operators would be passed as a literal argument rather than interpreted; rejecting them surfaces the mismatch at the caller instead of silently doing the wrong thing. `bash_pipe` is the one sanctioned shell-pipeline surface; everything else refuses `|` and points the caller at either splitting into separate calls or using `bash_pipe`. Shell fallback patterns like `cmd || echo default` are refused by design: the caller should probe with `bash_check` and branch in Python, not lean on shell short-circuit. `_resolve_args` uses `shlex.split` with `posix=(os.name != "nt")` so quoted arguments parse the way they read, and on Windows also resolves `argv[0]` against `PATH` via `shutil.which` up front — `subprocess.Popen` on Windows won't do that for you and returns `WinError 2` when it can't find the binary. Skipping either guard defeats the reason a caller reached for this package instead of raw `subprocess`.
+
+**`env=` overlays the inherited environment; it does not replace it.** Every helper takes an optional `env=` mapping. It is merged *onto* the process environment (`{**os.environ, **env}`) into a fresh dict, so the child sees the extra or overridden vars while everything else (`PATH`, `HOME`, …) is still inherited, and this process's `os.environ` is never mutated. This is deliberately unlike `subprocess`'s own `env=`, which replaces the environment wholesale: callers here almost always want "add a couple of vars for this one child," and the pattern this replaces — mutating the global `os.environ` so a child inherits a var — leaks that var into every later subprocess in the process. Passing `env=None` (the default) inherits unchanged.
+
+**`KeyboardInterrupt` handling is load-bearing, not incidental.** Each helper's `except KeyboardInterrupt` waits up to five seconds for the child to exit cleanly, then kills, then re-raises. Naive `subprocess.run` doesn't propagate Ctrl+C to a long-running child in a way that lets the child clean up; the wait-then-kill dance is why callers can trust that Ctrl+C in the parent actually reaches (and eventually terminates) the child.
+
+**Wheel must ship `py.typed`.** The package is typed and consumers expect strict-mode-friendly imports. A real hatch-built wheel omits non-Python files unless `[tool.hatch.build.targets.wheel] include` names them; drop the `py.typed` entry from `pyproject.toml` and downstream basedpyright/mypy silently treat the package as untyped.
+
+**The module-level `# ruff: noqa: S404, S603` in `bash.py` stays.** This package *is* the subprocess wrapper — importing and calling `subprocess` unsafely is its whole job. The suppression is the wrapper boundary (case 1 in the shared "fix warnings; suppress only under a wrapped or tracked exception" rule): every `subprocess` usage lives inside this one file, and the header declares it as the sanctioned suppression site so audits don't have to reason about each call individually.
+
+## Release flow
+
+Publishing rides `ci.yml`'s `publish` job on every push to `main` (gated on the check job): pubpkg — invoked uvx-isolated from a pinned git ref, never a project dependency (bashrun sits inside pubpkg's own dependency graph; a project-level pubpkg edge is a resolver cycle) — computes the plan from the tag ledger and path-diff, patches the version ephemerally, and publishes to PyPI under OIDC trusted publishing (pending publisher bound to `ci.yml`, no environment). The committed `pyproject.toml` version is permanently the `0.0.0.dev0` sentinel; the `bashrun-v*` tags are the version ledger (first release `0.1.0`, patch-auto thereafter). API-breaking changes ship with a manually bumped version — patch-auto assumes additive changes.
+
+## See also
+
+- `README.md` — human-facing setup and usage.

bashrun-0.1.0/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

bashrun-0.1.0/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1.  Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+2.  Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+3.  Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+4.  Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+    Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+    stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+    that You distribute, all copyright, patent, trademark, and
+    attribution notices from the Source form of the Work,
+    excluding those notices that do not pertain to any part of
+    the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+    distribution, then any Derivative Works that You distribute must
+    include a readable copy of the attribution notices contained
+    within such NOTICE file, excluding those notices that do not
+    pertain to any part of the Derivative Works, in at least one
+    of the following places: within a NOTICE text file distributed
+    as part of the Derivative Works; within the Source form or
+    documentation, if provided along with the Derivative Works; or,
+    within a display generated by the Derivative Works, if and
+    wherever such third-party notices normally appear. The contents
+    of the NOTICE file are for informational purposes only and
+    do not modify the License. You may add Your own attribution
+    notices within Derivative Works that You distribute, alongside
+    or as an addendum to the NOTICE text from the Work, provided
+    that such additional attribution notices cannot be construed
+    as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+5.  Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+6.  Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+7.  Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+8.  Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+9.  Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

bashrun-0.1.0/NOTICE

@@ -0,0 +1 @@
+Copyright 2026 Tyler Hatch

bashrun-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.5
+Name: bashrun
+Version: 0.1.0
+Summary: Guardrailed shell-exec helpers for Python
+License-File: LICENSE
+License-File: NOTICE
+Requires-Python: >=3.13

bashrun-0.1.0/README.md

@@ -0,0 +1,45 @@
+# bashrun
+
+Guardrailed shell-exec helpers for Python. A thin, zero-dependency layer over `subprocess` that closes the sharp edges: quoted arguments are parsed with `shlex`, shell operators like `|`, `||`, `&&`, `;`, `&`, `<`, `>`, and backtick command substitution are rejected in single-command helpers (a separate `bash_pipe()` handles real pipelines), `KeyboardInterrupt` waits for the child to exit cleanly instead of leaving it orphaned, and failure paths raise `CalledProcessError` with `stdout` and `stderr` attached rather than a bare non-zero return code. On Windows, executables are resolved against `PATH` up front so a missing binary fails with a clear `FileNotFoundError`, not `WinError 2`.
+
+The helpers form one small vocabulary — `bash`, `bash_output`, `bash_check`, `bash_check_stream`, `bash_no_raise`, `bash_pipe`, `bash_handoff` — each covering a specific failure-and-output shape, with `CalledProcessError` re-exported for consumers that need to catch the failure type. See the module docstring conventions in [`AGENTS.md`](./AGENTS.md) for which helper to reach for.
+
+## Setup
+
+Requires Python 3.13+ and [uv](https://docs.astral.sh/uv/).
+
+```bash
+uv sync
+```
+
+## Usage
+
+```python
+from bashrun import bash, bash_check, bash_output
+
+bash("docker compose up -d")  # streams to stdout/stderr; raises on failure
+text = bash_output("git rev-parse HEAD")  # captures stdout; raises on failure
+if bash_check("test -f .env"):  # silent boolean; never raises
+    ...
+bash("make", env={"CC": "clang"})  # env overlays the inherited environment for this child only
+```
+
+## Consuming from another repo
+
+Install from PyPI:
+
+```toml
+[project]
+dependencies = ["bashrun>=0.1.0"]
+```
+
+To test an unreleased change, pin the repo at a git ref in a scratch branch instead (`bashrun = { git = "https://github.com/outernet-foundation/bashrun.git", rev = "<sha>" }` under `[tool.uv.sources]`) and drop the pin when the release lands.
+
+## Development
+
+```bash
+uv run ruff check .
+uv run ruff format --check .
+uv run basedpyright
+uv run pytest
+```

bashrun-0.1.0/publish-config.json

@@ -0,0 +1,11 @@
+{
+  "packages": [
+    {
+      "name": "bashrun",
+      "path": ".",
+      "feeds": { "pypi": "bashrun" }
+    }
+  ],
+  "ci_workflow": "ci.yml",
+  "mirror_prefix": "ghcr.io/outernet-foundation/mirror"
+}

bashrun-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[project]
+name = "bashrun"
+version = "0.1.0"
+description = "Guardrailed shell-exec helpers for Python"
+requires-python = ">=3.13"
+dependencies = []
+
+[dependency-groups]
+dev = ["basedpyright>=1.39.10", "ruff>=0.14.11", "pytest>=8.0.0"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/bashrun"]
+include = ["src/bashrun/py.typed"]
+
+[tool.basedpyright]
+venvPath = "."
+venv = ".venv"
+typeCheckingMode = "strict"
+include = ["src", "tests"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

bashrun-0.1.0/ruff.toml

@@ -0,0 +1,57 @@
+target-version = "py313"
+line-length = 120
+preview = true
+
+[lint]
+select = ["ALL"]
+ignore = [
+    # Type annotations — basedpyright strict mode handles this
+    "ANN",
+    # No docstrings, no copyright headers
+    "D",
+    "DOC",
+    "CPY",
+    # TODO/FIXME comment formatting
+    "TD",
+    "FIX",
+    # Exception message ergonomics — literal-indirection and custom-class churn without benefit
+    "EM101",
+    "EM102",
+    "TRY003",
+    # Class attribute names never conflict with builtins via self.x
+    "A003",
+    # Function-size counters — C901 already covers structural complexity
+    "PLR0911",
+    "PLR0912",
+    "PLR0913",
+    "PLR0914",
+    "PLR0915",
+    "PLR0917",
+    # Boolean parameters read fine as keyword-only flags here
+    "FBT001",
+    "FBT002",
+    "FBT003",
+    # Relative imports are the intra-package convention
+    "TID252",
+    # Formatter-owned; enforced by `ruff format`
+    "COM812",
+    "I001",
+    # Magic values in comparisons are readable here
+    "PLR2004",
+    # The formatter owns wrapping; long string literals and URLs stay on one line
+    "E501",
+    # src-layout tests need no __init__.py
+    "INP001",
+    # Runtime-used typing imports stay at module level
+    "TC001",
+    "TC002",
+    "TC003",
+    # Small literal tuples read fine in membership tests
+    "PLR6201",
+]
+
+[lint.per-file-ignores]
+"tests/**" = ["S101", "PLR6301"]
+
+[lint.flake8-builtins]
+ignorelist = ["id", "map"]

bashrun-0.1.0/src/bashrun/__init__.py

@@ -0,0 +1,23 @@
+from .bash import (
+    CalledProcessError,
+    bash,
+    bash_check,
+    bash_check_stream,
+    bash_handoff,
+    bash_no_raise,
+    bash_output,
+    bash_pipe,
+    first_stderr_line,
+)
+
+__all__ = [
+    "CalledProcessError",
+    "bash",
+    "bash_check",
+    "bash_check_stream",
+    "bash_handoff",
+    "bash_no_raise",
+    "bash_output",
+    "bash_pipe",
+    "first_stderr_line",
+]

bashrun-0.1.0/src/bashrun/bash.py

@@ -0,0 +1,196 @@
+# ruff: noqa: S404, S603, S606, T201, PLW0717, PLW1510 — this module is the project's subprocess wrapper
+import os
+import re
+import shlex
+import shutil
+import subprocess
+import sys
+from contextlib import ExitStack
+from pathlib import Path
+from subprocess import CalledProcessError, Popen, TimeoutExpired
+from typing import NoReturn
+
+
+_SHELL_OPERATOR_PATTERN = re.compile(r"[|;&<>`]")
+
+
+def _check_no_shell_operator(command: str) -> None:
+    stripped = re.sub(r'"[^"]*"', "", re.sub(r"'[^']*'", "", command))
+    match = _SHELL_OPERATOR_PATTERN.search(stripped)
+    if match is not None:
+        msg = (
+            f"Command contains shell operator {match.group()!r}: {command!r}. "
+            "bash() runs without a shell, so the operator would be passed as a literal argument. "
+            "Split into separate bash() calls, or use bash_pipe() for pipelines."
+        )
+        raise ValueError(msg)
+
+
+def _resolve_args(command: str) -> list[str]:
+    args = shlex.split(command, posix=(os.name != "nt"))
+    if os.name == "nt" and args:
+        resolved = shutil.which(args[0])
+        if resolved is None:
+            msg = f"Executable not found on PATH: {args[0]!r}"
+            raise FileNotFoundError(msg)
+        args[0] = resolved
+    return args
+
+
+def _merge_env(env: dict[str, str] | None) -> dict[str, str] | None:
+    # env overlays the inherited process environment rather than replacing it, and is built into a
+    # fresh dict so the child sees the extra vars without mutating this process's os.environ.
+    return {**os.environ, **env} if env else None
+
+
+def bash_output(
+    command: str, *, cwd: Path | None = None, stdin_text: str | None = None, env: dict[str, str] | None = None
+) -> str:
+    _check_no_shell_operator(command)
+    args = _resolve_args(command)
+
+    with Popen(
+        args,
+        cwd=str(cwd) if cwd else None,
+        env=_merge_env(env),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        stdin=subprocess.PIPE if stdin_text else None,
+        text=True,
+    ) as process:
+        try:
+            stdout, stderr = process.communicate(input=stdin_text)
+        except KeyboardInterrupt:
+            try:
+                process.wait(timeout=5)
+            except TimeoutExpired:
+                process.kill()
+            raise
+
+        if process.returncode != 0:
+            if stderr:
+                print(stderr, file=sys.stderr, end="")
+            raise CalledProcessError(process.returncode, command, output=stdout, stderr=stderr)
+
+        return stdout or ""
+
+
+def bash(
+    command: str,
+    *,
+    cwd: Path | None = None,
+    stdin_text: str | None = None,
+    log_path: Path | None = None,
+    env: dict[str, str] | None = None,
+) -> None:
+    _check_no_shell_operator(command)
+    args = _resolve_args(command)
+
+    with ExitStack() as stack:
+        if log_path:
+            log_path.parent.mkdir(parents=True, exist_ok=True)
+            log = stack.enter_context(log_path.open("a"))
+            stdout, stderr = log, log
+        else:
+            stdout, stderr = sys.stdout, sys.stderr
+
+        process = stack.enter_context(
+            Popen(
+                args,
+                cwd=str(cwd) if cwd else None,
+                env=_merge_env(env),
+                stdout=stdout,
+                stderr=stderr,
+                stdin=subprocess.PIPE if stdin_text else None,
+                text=True,
+            )
+        )
+
+        try:
+            process.communicate(input=stdin_text)
+        except KeyboardInterrupt:
+            try:
+                process.wait(timeout=5)
+            except TimeoutExpired:
+                process.kill()
+            raise
+
+        if process.returncode != 0:
+            raise CalledProcessError(process.returncode, command)
+
+
+def bash_pipe(*commands: str, cwd: Path | None = None, env: dict[str, str] | None = None) -> None:
+    if len(commands) < 2:
+        msg = "bash_pipe requires at least 2 commands"
+        raise ValueError(msg)
+
+    merged_env = _merge_env(env)
+    processes: list[Popen[bytes]] = []
+    try:
+        for i, command in enumerate(commands):
+            args = _resolve_args(command)
+            stdin = processes[-1].stdout if i > 0 else None
+            stdout = subprocess.PIPE if i < len(commands) - 1 else sys.stdout
+            stderr = sys.stderr if i == len(commands) - 1 else subprocess.DEVNULL
+            processes.append(
+                Popen(args, stdin=stdin, stdout=stdout, stderr=stderr, cwd=str(cwd) if cwd else None, env=merged_env)
+            )
+            if i > 0 and processes[-2].stdout:
+                processes[-2].stdout.close()
+
+        for process in processes:
+            process.wait()
+    except KeyboardInterrupt:
+        for process in processes:
+            try:
+                process.wait(timeout=5)
+            except TimeoutExpired:
+                process.kill()
+        raise
+
+    for process in processes:
+        if process.returncode != 0:
+            raise CalledProcessError(process.returncode, process.args)
+
+
+def bash_check(command: str, *, cwd: Path | None = None, env: dict[str, str] | None = None) -> bool:
+    _check_no_shell_operator(command)
+    args = _resolve_args(command)
+    result = subprocess.run(args, cwd=str(cwd) if cwd else None, env=_merge_env(env), capture_output=True)
+    return result.returncode == 0
+
+
+def bash_check_stream(command: str, *, cwd: Path | None = None, env: dict[str, str] | None = None) -> bool:
+    _check_no_shell_operator(command)
+    args = _resolve_args(command)
+    result = subprocess.run(args, cwd=str(cwd) if cwd else None, env=_merge_env(env))
+    return result.returncode == 0
+
+
+def bash_no_raise(command: str, *, cwd: Path | None = None, env: dict[str, str] | None = None) -> None:
+    _check_no_shell_operator(command)
+    args = _resolve_args(command)
+    subprocess.run(args, cwd=str(cwd) if cwd else None, env=_merge_env(env))
+
+
+def bash_handoff(command: str, *, cwd: Path | None = None, env: dict[str, str] | None = None) -> NoReturn:
+    _check_no_shell_operator(command)
+    args = _resolve_args(command)
+
+    if cwd:
+        os.chdir(cwd)
+
+    merged_env = _merge_env(env)
+
+    if sys.platform != "win32":
+        os.execvpe(args[0], args, merged_env if merged_env is not None else os.environ)
+    else:
+        try:
+            subprocess.run(args, check=True, env=merged_env)
+        except subprocess.CalledProcessError as error:
+            sys.exit(error.returncode)
+        sys.exit(0)
+
+
+def first_stderr_line(error: CalledProcessError) -> str:
+    return next((line.strip() for line in (error.stderr or "").splitlines() if line.strip()), str(error))

bashrun-0.1.0/tests/test_bash.py

@@ -0,0 +1,257 @@
+# ruff: noqa: S404, S603, PLW1510, PLC1901 — tests for the subprocess wrapper
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+import pytest
+from bashrun import (
+    CalledProcessError,
+    bash,
+    bash_check,
+    bash_check_stream,
+    bash_no_raise,
+    bash_output,
+    first_stderr_line,
+)
+
+
+class TestBashOutput:
+    def test_captures_stdout(self):
+        assert bash_output("echo hello") == "hello\n"
+
+    def test_returns_empty_string_on_no_output(self):
+        assert bash_output("true") == ""
+
+    def test_raises_on_failure(self):
+        with pytest.raises(subprocess.CalledProcessError):
+            bash_output("false")
+
+    def test_attaches_stderr_to_exception(self):
+        with pytest.raises(subprocess.CalledProcessError) as exc_info:
+            bash_output("sh -c 'echo oops >&2; exit 1'")
+        assert "oops" in (exc_info.value.stderr or "")
+
+    def test_attaches_stdout_to_exception(self):
+        with pytest.raises(subprocess.CalledProcessError) as exc_info:
+            bash_output("sh -c 'echo partial; exit 1'")
+        assert "partial" in (exc_info.value.stdout or "")
+
+    def test_respects_cwd(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            result = bash_output("pwd", cwd=Path(tmpdir))
+            assert result.strip() == tmpdir
+
+    def test_passes_stdin_text(self):
+        assert bash_output("cat", stdin_text="hello world") == "hello world"
+
+    def test_handles_quoted_arguments(self):
+        assert bash_output("echo 'hello world'") == "hello world\n"
+
+
+class TestBash:
+    def test_no_raise_on_success(self):
+        bash("true")
+
+    def test_raises_on_failure(self):
+        with pytest.raises(subprocess.CalledProcessError):
+            bash("false")
+
+    def test_returns_none(self):
+        assert bash("true") is None
+
+    def test_respects_cwd(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    "-c",
+                    f"from pathlib import Path; from bashrun import bash; bash('pwd', cwd=Path('{tmpdir}'))",
+                ],
+                capture_output=True,
+                text=True,
+            )
+            assert tmpdir in result.stdout
+
+    def test_passes_stdin_text(self):
+        result = subprocess.run(
+            [sys.executable, "-c", "from bashrun import bash; bash('cat', stdin_text='streamed input')"],
+            capture_output=True,
+            text=True,
+        )
+        assert "streamed input" in result.stdout
+
+
+class TestBashCheck:
+    def test_returns_true_on_success(self):
+        assert bash_check("true") is True
+
+    def test_returns_false_on_failure(self):
+        assert bash_check("false") is False
+
+    def test_no_raise_on_failure(self):
+        bash_check("false")
+
+    def test_respects_cwd(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            assert bash_check(f"test -d {tmpdir}") is True
+
+    def test_suppresses_all_output(self, capsys: pytest.CaptureFixture[str]):
+        bash_check("echo should_not_appear")
+        captured = capsys.readouterr()
+        assert "should_not_appear" not in captured.out
+        assert "should_not_appear" not in captured.err
+
+
+class TestBashCheckStream:
+    def test_returns_true_on_success(self):
+        assert bash_check_stream("true") is True
+
+    def test_returns_false_on_failure(self):
+        assert bash_check_stream("false") is False
+
+    def test_no_raise_on_failure(self):
+        bash_check_stream("false")
+
+    def test_respects_cwd(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            assert bash_check_stream(f"test -d {tmpdir}") is True
+
+
+class TestBashNoRaise:
+    def test_no_raise_on_success(self):
+        bash_no_raise("true")
+
+    def test_no_raise_on_failure(self):
+        bash_no_raise("false")
+
+    def test_returns_none(self):
+        assert bash_no_raise("true") is None
+
+    def test_respects_cwd(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            bash_no_raise(f"test -d {tmpdir}")
+
+
+class TestBashHandoff:
+    def test_stdout_contains_output(self):
+        result = subprocess.run(
+            [sys.executable, "-c", "from bashrun import bash_handoff; bash_handoff('echo handoff_test')"],
+            capture_output=True,
+            text=True,
+        )
+        assert "handoff_test" in result.stdout
+
+    def test_exit_code_matches(self):
+        result = subprocess.run(
+            [sys.executable, "-c", "from bashrun import bash_handoff; bash_handoff('sh -c \"exit 42\"')"],
+            capture_output=True,
+            text=True,
+        )
+        assert result.returncode == 42
+
+    def test_respects_cwd(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    "-c",
+                    f"from pathlib import Path; from bashrun import bash_handoff; bash_handoff('pwd', cwd=Path('{tmpdir}'))",
+                ],
+                capture_output=True,
+                text=True,
+            )
+            assert tmpdir in result.stdout
+
+
+class TestEnv:
+    def test_env_var_reaches_child(self):
+        assert bash_output("printenv OVERLAY_VAR", env={"OVERLAY_VAR": "hello"}) == "hello\n"
+
+    def test_env_overlays_rather_than_replaces(self, monkeypatch: pytest.MonkeyPatch):
+        # an inherited var stays visible alongside the caller's overlay
+        monkeypatch.setenv("INHERITED_VAR", "base")
+        assert bash_output("printenv INHERITED_VAR", env={"OTHER_VAR": "x"}) == "base\n"
+
+    def test_env_does_not_mutate_parent_environ(self):
+        bash_output("true", env={"SHOULD_NOT_LEAK": "1"})
+        assert "SHOULD_NOT_LEAK" not in os.environ
+
+    def test_env_overrides_inherited_value(self, monkeypatch: pytest.MonkeyPatch):
+        monkeypatch.setenv("COLLIDE_VAR", "old")
+        assert bash_output("printenv COLLIDE_VAR", env={"COLLIDE_VAR": "new"}) == "new\n"
+
+
+class TestShellOperatorRejection:
+    def test_accepts_plain_command(self):
+        assert bash_check("true")
+
+    def test_rejects_logical_and(self):
+        with pytest.raises(ValueError, match="shell operator"):
+            bash_check("true && false")
+
+    def test_rejects_logical_or(self):
+        with pytest.raises(ValueError, match="shell operator"):
+            bash_check("false || true")
+
+    def test_rejects_pipe(self):
+        with pytest.raises(ValueError, match="shell operator"):
+            bash_check("true | false")
+
+    def test_rejects_sequence(self):
+        with pytest.raises(ValueError, match="shell operator"):
+            bash_check("true ; false")
+
+    def test_rejects_background_ampersand(self):
+        with pytest.raises(ValueError, match="shell operator"):
+            bash_check("true &")
+
+    def test_rejects_input_redirection(self):
+        with pytest.raises(ValueError, match="shell operator"):
+            bash_check("true < /dev/null")
+
+    def test_rejects_output_redirection(self):
+        with pytest.raises(ValueError, match="shell operator"):
+            bash_check("true > /dev/null")
+
+    def test_rejects_backtick_substitution(self):
+        with pytest.raises(ValueError, match="shell operator"):
+            bash_check("true `echo arg`")
+
+    def test_ignores_operator_inside_single_quotes(self):
+        assert bash_check("true 'a && b'")
+
+    def test_ignores_operator_inside_double_quotes(self):
+        assert bash_check('true "a && b"')
+
+    def test_rejects_operator_outside_quotes_when_quotes_also_present(self):
+        with pytest.raises(ValueError, match="shell operator"):
+            bash_check('true "safe" && rm -rf /')
+
+
+class TestReExports:
+    def test_called_process_error_is_the_subprocess_exception(self):
+        assert CalledProcessError is subprocess.CalledProcessError
+
+    def test_raised_errors_are_catchable_via_the_re_export(self):
+        with pytest.raises(CalledProcessError):
+            bash_output("false")
+
+
+class TestFirstStderrLine:
+    def test_returns_first_non_empty_line(self):
+        error = CalledProcessError(1, "git fetch", stderr="hint: update your remote\nfatal: not found\n")
+        assert first_stderr_line(error) == "hint: update your remote"
+
+    def test_strips_surrounding_whitespace(self):
+        error = CalledProcessError(1, "git fetch", stderr="  fatal: boom  \n")
+        assert first_stderr_line(error) == "fatal: boom"
+
+    def test_falls_back_to_exception_text_without_stderr(self):
+        error = CalledProcessError(1, "git fetch")
+        assert first_stderr_line(error) == str(error)
+
+    def test_falls_back_when_stderr_is_whitespace_only(self):
+        error = CalledProcessError(1, "git fetch", stderr=" \n \n")
+        assert first_stderr_line(error) == str(error)

bashrun-0.1.0/uv.lock

@@ -0,0 +1,138 @@
+version = 1
+revision = 3
+requires-python = ">=3.13"
+
+[[package]]
+name = "basedpyright"
+version = "1.39.10"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nodejs-wheel-binaries" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/68/43/ad2999f3b09eb2b1e59931d88fac0f7bcc9c17fc18c903268779bd10cc97/basedpyright-1.39.10.tar.gz", hash = "sha256:c8eaf5302f3265e275c7df4fba194d7afa7c1cb53fbfd448e90098360aca2c2e", size = 24740347, upload-time = "2026-08-13T17:09:02.51Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/be/2a/a224054d75a58786c482f63b8ff2a09fc3362268bd1ebd0a61fb3f982153/basedpyright-1.39.10-py3-none-any.whl", hash = "sha256:cbd75d83c0be841329bcfef2d2f1182f152a6d975b8eb199e75cf5b8e9a3de78", size = 13482322, upload-time = "2026-08-13T17:08:59.074Z" },
+]
+
+[[package]]
+name = "bashrun"
+version = "0.0.0.dev0"
+source = { editable = "." }
+
+[package.dev-dependencies]
+dev = [
+    { name = "basedpyright" },
+    { name = "pytest" },
+    { name = "ruff" },
+]
+
+[package.metadata]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "basedpyright", specifier = ">=1.39.10" },
+    { name = "pytest", specifier = ">=8.0.0" },
+    { name = "ruff", specifier = ">=0.14.11" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "nodejs-wheel-binaries"
+version = "24.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a3/22/2a5beb4e21417c73233d9f65cf6f3e96e891b80d2f550a8f630ebc6b88c6/nodejs_wheel_binaries-24.16.0.tar.gz", hash = "sha256:c973cb69dc5fd16e6f6dc6e579e2c3d5534e2a1f57619dddf5ba070efa7dde37", size = 8056, upload-time = "2026-05-30T16:52:09.807Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/83/d1/68b43b53cd0fa83ae6fd406705023ca988d9e0ca41c724d82e66fbeb2ef6/nodejs_wheel_binaries-24.16.0-py2.py3-none-macosx_13_0_arm64.whl", hash = "sha256:d9f8f677dcf30e37ac244f07869726abe043f01eb0f45722b1df31cc2af7093c", size = 55666374, upload-time = "2026-05-30T16:51:39.588Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/b2/40a989159599080da485de966c4c2d207e852ac7aa7864702626d96c8bf5/nodejs_wheel_binaries-24.16.0-py2.py3-none-macosx_13_0_x86_64.whl", hash = "sha256:3d0370fe7120ce9697a4f60d40480d2bd8808d9f30131458d5afc0040d4e5a51", size = 55838487, upload-time = "2026-05-30T16:51:43.383Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/a7/cd42174fb5ff6faff7fa8d326a18914d8f232098ab5de055b57c16fa13ca/nodejs_wheel_binaries-24.16.0-py2.py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:85dc92bbb79c851569c5925dcc2a4c915a034efab375f99e4e7e6bbe9cca8342", size = 60179540, upload-time = "2026-05-30T16:51:47.036Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/95/c8a1f9ae140aa28df8744d984d01d4b3af7cdd6555af12127f40ceb45a7d/nodejs_wheel_binaries-24.16.0-py2.py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:2f3036292811514ba847b3708492644764f88a833ac425c5f55007014308ddfd", size = 60716262, upload-time = "2026-05-30T16:51:50.711Z" },
+    { url = "https://files.pythonhosted.org/packages/64/c9/7c35b3737f59e36d0249c265397b7bff570519b95301d6e16ea361e904ad/nodejs_wheel_binaries-24.16.0-py2.py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:db8a8a76ebd2b28ecbfc9ad464baa3707241b9e050a30e2efdf6f60c0f886502", size = 62230592, upload-time = "2026-05-30T16:51:55Z" },
+    { url = "https://files.pythonhosted.org/packages/04/96/d931255cf9d11a84d6b54d882dba7434646467d568ccf070ea3418638df3/nodejs_wheel_binaries-24.16.0-py2.py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:f1a3d8f7b4491cbbd023ba3fc4e901fcca2d9fb80d57f24ba3890de8b1dbac03", size = 62841759, upload-time = "2026-05-30T16:51:59.407Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/7b/8b7a3f41bc255411be30b6d7d288aab8ffd9ea2055db8555ced3548007b9/nodejs_wheel_binaries-24.16.0-py2.py3-none-win_amd64.whl", hash = "sha256:bb136be9944f0662dcf1120f45193a6b75b13fac378971a95cc42c9f879a81aa", size = 42027734, upload-time = "2026-05-30T16:52:03.348Z" },
+    { url = "https://files.pythonhosted.org/packages/17/66/1ed71f1f529b8ca727d42c7ceb9db0bef145ce4a13dfc86fb50aa44f3be6/nodejs_wheel_binaries-24.16.0-py2.py3-none-win_arm64.whl", hash = "sha256:8308940b5edd0a50dc5267ea36ba21c9f668e83fe0d9f293937174d3a7e31c36", size = 39714528, upload-time = "2026-05-30T16:52:06.421Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/f1/e7a6dd94a8d4a5626c03e4e99c87f241ba9e350cd9e6d75123f992427270/packaging-26.2.tar.gz", hash = "sha256:ff452ff5a3e828ce110190feff1178bb1f2ea2281fa2075aadb987c2fb221661", size = 228134, upload-time = "2026-04-24T20:15:23.917Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.15.21"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0f/36/6f65aa9989acdec45d417192d8f4e7921931d8a6cf87ac74bce3eed98a8e/ruff-0.15.21.tar.gz", hash = "sha256:d0cfc841c572283c36548f82664a54ce6565567f1b0d5b4cf2caac693d8b7500", size = 4769401, upload-time = "2026-07-09T20:01:34.005Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d0/c6/ede15cac6839f3dbce52565c8f5164a8210e669c7bc4decb03e5bdf47d0d/ruff-0.15.21-py3-none-linux_armv6l.whl", hash = "sha256:63ea0e965e5d73c90e95b2434beeafc70820536717f561b32ab6e777cb9bdf5d", size = 10854342, upload-time = "2026-07-09T20:00:53.998Z" },
+    { url = "https://files.pythonhosted.org/packages/28/9d/d825b07ee7ea9e2d61df92a860033c94e06e7300d50a1c2653aac27d24fe/ruff-0.15.21-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:0f212c5d7d54c01bbfe6dcab02b724a39300f3e34ed7acbe995ccb320a2c58bd", size = 11139539, upload-time = "2026-07-09T20:00:57.809Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/de/3b107712e642f063c7a9e0887c427b22cb44097de5aab36c05f2e280670c/ruff-0.15.21-py3-none-macosx_11_0_arm64.whl", hash = "sha256:e6312e41bc96791299614995ea3a977c5857c3b5662b1ecef6755b02b87cb646", size = 10595437, upload-time = "2026-07-09T20:01:00.006Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/6f/b4523cc90ba239ede441447a19d0c968846a3012e5a0b0c5b62831a3d5e3/ruff-0.15.21-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:01d65b4831c6b2a4ba8ee6faa84049d44d982b7a706e622c4094c509e51673be", size = 10990053, upload-time = "2026-07-09T20:01:02.187Z" },
+    { url = "https://files.pythonhosted.org/packages/92/cc/c6a9872a5375f0628875481cf2f66b13d7d865bf3ca2e57f91c7e762d976/ruff-0.15.21-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2c5a913a589120ce67933d5d05fd6ddbcc2481c6a054980ee767f7414c72b4fd", size = 10666096, upload-time = "2026-07-09T20:01:04.299Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/97/c621f7a17e097f1790fa3af6374138823b330b2d03fc38337945daca212c/ruff-0.15.21-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5ef04b681d02ad4dc9620f00f83ac5c22f652d0e9a9cfe431d219b16ad5ccc41", size = 11537011, upload-time = "2026-07-09T20:01:06.771Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/51/d928727e476e25ccc57c6f449ffd80241a651a973ad949d39cfb2a771d28/ruff-0.15.21-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:16d090c0740916594157e75b80d666eab8e78083b39b3b0e1d698f4670a17b86", size = 12347101, upload-time = "2026-07-09T20:01:08.859Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/88/8cd62026802b16018ad06931d87997cf795ba2a6239ab659606c87d96bf0/ruff-0.15.21-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3a10e74757dd65004d779b73e2f3c5210156d9980b41224d50d2ebcf1db51e67", size = 11572001, upload-time = "2026-07-09T20:01:11.092Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/97/f63084cf55444fc110e8cb985ebfcc592af47f597d44453d778cb81bc156/ruff-0.15.21-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bab0905d2f29e0d9fbc3c373ed23db0095edaa3f71f1f4f519ec15134d9e85c8", size = 11549239, upload-time = "2026-07-09T20:01:13.27Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/77/f107da4a2874b7715914b03f09ba9c54424de3ff8a1cc5d015d3ee2ce0ac/ruff-0.15.21-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:00eca240af5789fec6fe7df74c088cc1f9644ed83027113468efba7c92b94075", size = 11535340, upload-time = "2026-07-09T20:01:15.206Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/e9/601deb322d3303a7bf212b0100ead6f2ee3f6a044d89c30f2f92bf83c731/ruff-0.15.21-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:262ab31557a75141325e32d3357f3597645a7f084e732b6b054dde428ecd9341", size = 10964048, upload-time = "2026-07-09T20:01:17.723Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/2e/0f2176d1e99c15192caea19c8c3a0a955246b4cb4de795042eeb616345cd/ruff-0.15.21-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:659c4e7a4212f83306045ec7c5e5a356d16d9a6ef4ae0c7a4d872914fc655d9d", size = 10667055, upload-time = "2026-07-09T20:01:19.73Z" },
+    { url = "https://files.pythonhosted.org/packages/48/60/abd74a02e0c4214f12a68becfd30af7165cfdcb0e661ecdc60bbb949c09a/ruff-0.15.21-py3-none-musllinux_1_2_i686.whl", hash = "sha256:9e866eab611a5f959d36df2d10e446973a3610bc42b0c15b31dc27977d59c233", size = 11242043, upload-time = "2026-07-09T20:01:21.947Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/c6/583075d8ccabb4b229345edcaf1545eb3d8d6be90f686a479d7e94088bbf/ruff-0.15.21-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e89bc93c0d3803ba870b55c29671bad9dc6d94bb1eb181b056b52eb05b52854f", size = 11648064, upload-time = "2026-07-09T20:01:24.023Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/3c/37d0ecb729a7cc2d393ea7dce316fc585680f35d93b8d62139d7d0a3700c/ruff-0.15.21-py3-none-win32.whl", hash = "sha256:01f8d5be84823c172b389e123174f781f9daf86d6c58719d603f941932195cdd", size = 10896555, upload-time = "2026-07-09T20:01:26.941Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/b8/e43466b2a6067ce91e669068f6e28d6c719a920f014b070d5c8731725de3/ruff-0.15.21-py3-none-win_amd64.whl", hash = "sha256:d4b8d9a2f0f12b816b50447f6eccb9f4bb01a6b82c86b50fb3b5354b458dc6d3", size = 12038772, upload-time = "2026-07-09T20:01:29.497Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/75/e90ab9aeece218a9fc5a5bc3ec97d0ee6bb3c4ff95869463c1de58e29a1c/ruff-0.15.21-py3-none-win_arm64.whl", hash = "sha256:6e83115d4b9377c1cbc13abf0e051f069fab0ef815ea0504a8a008cee24dd0a8", size = 11375265, upload-time = "2026-07-09T20:01:31.772Z" },
+]