ohbin 0.2.2__py3-none-any.whl

ohbin/_manifest.py

@@ -0,0 +1,107 @@
+"""Locate and parse the `[tool.ohbin.tools.*]` manifest from a project's pyproject."""
+
+from __future__ import annotations
+
+import os
+import tomllib
+from pathlib import Path
+from typing import Any
+
+from ohbin._errors import OhbinError
+from ohbin._types import AssetEntry, ToolConfig
+
+
+class ManifestError(OhbinError):
+    """Raised when the manifest is missing or a tool entry is malformed."""
+
+
+def _read(path: Path) -> dict[str, Any]:
+    with path.open("rb") as fh:
+        return tomllib.load(fh)
+
+
+def _has_ohbin(path: Path) -> bool:
+    data = _read(path)
+    tool = data.get("tool")
+    return isinstance(tool, dict) and "ohbin" in tool
+
+
+def find_pyproject(start: Path | None = None) -> Path:
+    """Find the nearest pyproject.toml carrying `[tool.ohbin]`, walking up from CWD.
+
+    `OHBIN_PYPROJECT` overrides discovery (handy for CI / in-process callers
+    that run from an unrelated CWD).
+    """
+    override = os.environ.get("OHBIN_PYPROJECT")
+    if override:
+        p = Path(override)
+        if not p.is_file():
+            msg = f"OHBIN_PYPROJECT points to a missing file: {p}"
+            raise ManifestError(msg)
+        return p
+
+    current = (start or Path.cwd()).resolve()
+    for directory in (current, *current.parents):
+        candidate = directory / "pyproject.toml"
+        if candidate.is_file() and _has_ohbin(candidate):
+            return candidate
+
+    msg = "no pyproject.toml with [tool.ohbin] found (set OHBIN_PYPROJECT to override)"
+    raise ManifestError(msg)
+
+
+def _parse_asset(tool: str, key: str, raw: object) -> AssetEntry:
+    if not isinstance(raw, dict) or "url" not in raw or "sha256" not in raw:
+        msg = f"tool {tool!r}: asset {key!r} must define both 'url' and 'sha256'"
+        raise ManifestError(msg)
+    entry = AssetEntry(url=str(raw["url"]), sha256=str(raw["sha256"]))
+    if "binary_sha256" in raw:
+        entry["binary_sha256"] = str(raw["binary_sha256"])
+    return entry
+
+
+def _parse_tool(name: str, raw: object) -> ToolConfig:
+    if not isinstance(raw, dict):
+        msg = f"tool {name!r} must be a table"
+        raise ManifestError(msg)
+    for required in ("repo", "version"):
+        if required not in raw:
+            msg = f"tool {name!r} is missing required key {required!r}"
+            raise ManifestError(msg)
+    raw_assets = raw.get("assets", {})
+    if not isinstance(raw_assets, dict):
+        msg = f"tool {name!r}: 'assets' must be a table"
+        raise ManifestError(msg)
+    assets = {str(k): _parse_asset(name, str(k), v) for k, v in raw_assets.items()}
+    cfg = ToolConfig(
+        repo=str(raw["repo"]),
+        version=str(raw["version"]),
+        binary=str(raw.get("binary", name)),
+        assets=assets,
+    )
+    if raw.get("encrypted"):
+        cfg["encrypted"] = True
+    if "password" in raw:
+        cfg["password"] = str(raw["password"])
+    if raw.get("password_committed_ok"):
+        cfg["password_committed_ok"] = True
+    return cfg
+
+
+def load_tools(pyproject: Path | None = None) -> dict[str, ToolConfig]:
+    path = pyproject or find_pyproject()
+    data = _read(path)
+    raw_tools = data.get("tool", {}).get("ohbin", {}).get("tools", {})
+    if not isinstance(raw_tools, dict):
+        msg = "[tool.ohbin.tools] must be a table"
+        raise ManifestError(msg)
+    return {str(name): _parse_tool(str(name), raw) for name, raw in raw_tools.items()}
+
+
+def load_tool(name: str, pyproject: Path | None = None) -> ToolConfig:
+    tools = load_tools(pyproject)
+    if name not in tools:
+        declared = ", ".join(sorted(tools)) or "none"
+        msg = f"tool {name!r} not declared in [tool.ohbin.tools] (declared: {declared})"
+        raise ManifestError(msg)
+    return tools[name]

ohbin/_platform.py

@@ -0,0 +1,83 @@
+"""Current-platform detection + the OS/arch token aliases used to match assets."""
+
+from __future__ import annotations
+
+import platform
+from typing import NamedTuple
+
+from ohbin._errors import OhbinError
+
+
+class UnsupportedPlatformError(OhbinError):
+    """Raised when a tool declares no asset for the current OS/arch."""
+
+
+class Platform(NamedTuple):
+    os: str  # "linux" | "darwin" | "windows"
+    arch: str  # "x86_64" | "aarch64" | "arm64"
+
+    @property
+    def key(self) -> str:
+        return f"{self.os}-{self.arch}"
+
+
+def _normalized_arch(machine: str, os_name: str) -> str:
+    m = machine.lower()
+    if m in {"x86_64", "amd64", "x64"}:
+        return "x86_64"
+    if m in {"aarch64", "arm64"}:
+        # Apple Silicon reports "arm64"; Linux reports "aarch64". Keep each OS
+        # family's canonical spelling so the platform key matches what `add`
+        # wrote (which uses the same TARGET_PLATFORMS below).
+        return "arm64" if os_name == "darwin" else "aarch64"
+    return m
+
+
+def current_platform() -> Platform:
+    os_name = platform.system().lower()
+    return Platform(os=os_name, arch=_normalized_arch(platform.machine(), os_name))
+
+
+# The platforms `add` tries to resolve assets for, with their canonical keys.
+TARGET_PLATFORMS: tuple[Platform, ...] = (
+    Platform("linux", "x86_64"),
+    Platform("linux", "aarch64"),
+    Platform("darwin", "x86_64"),
+    Platform("darwin", "arm64"),
+)
+
+# Token aliases for fuzzy-matching release asset filenames during `add`.
+_OS_ALIASES: dict[str, tuple[str, ...]] = {
+    "linux": ("linux",),
+    "darwin": ("darwin", "macos", "apple", "osx"),
+    "windows": ("windows", "win"),
+}
+_ARCH_ALIASES: dict[str, tuple[str, ...]] = {
+    "x86_64": ("x86_64", "amd64", "x64"),
+    "aarch64": ("aarch64", "arm64"),
+    "arm64": ("arm64", "aarch64"),
+}
+# Every arch token we know — used to detect "universal" assets (an OS match
+# carrying no arch token at all, e.g. a `*_darwin_universal.tar.gz`).
+ALL_ARCH_TOKENS: tuple[str, ...] = (
+    "x86_64",
+    "amd64",
+    "x64",
+    "aarch64",
+    "arm64",
+    "i386",
+    "i686",
+    "armv7",
+    "armv6",
+    "s390x",
+    "ppc64le",
+    "riscv64",
+)
+
+
+def os_tokens(p: Platform) -> tuple[str, ...]:
+    return _OS_ALIASES[p.os]
+
+
+def arch_tokens(p: Platform) -> tuple[str, ...]:
+    return _ARCH_ALIASES[p.arch]

ohbin/_retry.py

@@ -0,0 +1,56 @@
+"""Tiny retry-with-backoff for transient network failures.
+
+Shared by `_github` (release resolution) and `_engine` (asset download). Both
+classify failures into *permanent* (404, bad checksum — surfaced immediately)
+and *transient* (network blip, timeout, rate-limit, 5xx — retried here).
+"""
+
+from __future__ import annotations
+
+import sys
+import time
+from collections.abc import Callable
+from typing import TypeVar
+
+T = TypeVar("T")
+
+ATTEMPTS = 4
+BASE_DELAY = 0.5  # exponential backoff base → sleeps of 0.5s, 1s, 2s between tries
+
+
+def retryable_http_status(code: int) -> bool:
+    """True for HTTP statuses worth retrying (rate-limit / request-timeout / 5xx)."""
+    return code in (403, 408, 425, 429) or code >= 500
+
+
+def _warn_stderr(message: str) -> None:
+    print(message, file=sys.stderr)
+
+
+def retry(
+    fn: Callable[[], T],
+    *,
+    op: str,
+    retry_on: tuple[type[BaseException], ...],
+    attempts: int = ATTEMPTS,
+    base_delay: float = BASE_DELAY,
+    sleep: Callable[[float], None] = time.sleep,
+    warn: Callable[[str], None] | None = _warn_stderr,
+) -> T:
+    """Call `fn`, retrying with exponential backoff on `retry_on` exceptions.
+
+    Re-raises the last exception after `attempts` tries. `op` labels the action
+    in the retry notice. `sleep`/`warn` are injectable for tests (pass
+    `warn=None` to silence).
+    """
+    for attempt in range(1, attempts + 1):
+        try:
+            return fn()
+        except retry_on as exc:
+            if attempt == attempts:
+                raise
+            delay = base_delay * 2 ** (attempt - 1)
+            if warn is not None:
+                warn(f"ohbin: {op} failed (attempt {attempt}/{attempts}): {exc}; retrying in {delay:.1f}s")
+            sleep(delay)
+    raise RuntimeError(f"retry({op}): exhausted without result")  # pragma: no cover

ohbin/_types.py

@@ -0,0 +1,40 @@
+"""Typed shapes for the manifest boundary (`[tool.ohbin.tools.*]`)."""
+
+from __future__ import annotations
+
+from typing import NotRequired, TypedDict
+
+
+class AssetEntry(TypedDict):
+    """A single resolved release asset for one platform: where to get it + its hash.
+
+    `sha256` is the hash of the *downloaded* file (verified before any decryption,
+    so a tampered gist is caught early). For encrypted tools the downloaded file is
+    the ciphertext; `binary_sha256` then pins the *decrypted* executable, which also
+    doubles as a wrong-password / corruption check.
+    """
+
+    url: str
+    sha256: str
+    binary_sha256: NotRequired[str]
+
+
+class ToolConfig(TypedDict):
+    """One tool as declared under `[tool.ohbin.tools.<name>]`.
+
+    `binary` is the executable's filename *inside* the archive (defaults to the
+    tool's command name). `assets` is keyed by `"<os>-<arch>"` platform keys.
+
+    Encrypted tools (`encrypted = true`) ship a gzip+AES-CBC+base64 blob per
+    platform; ohbin decrypts on first use with a password from `--password` or the
+    `password` field. `password_committed_ok` silences the warning emitted when the
+    password is read from the (typically committed) manifest.
+    """
+
+    repo: str
+    version: str
+    binary: str
+    assets: dict[str, AssetEntry]
+    encrypted: NotRequired[bool]
+    password: NotRequired[str]
+    password_committed_ok: NotRequired[bool]

ohbin/cli.py

@@ -0,0 +1,175 @@
+"""Command-line interface: `ohbin run | add | which | list | publish-gist | add-gist`."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+from ohbin import ensure
+from ohbin._add import add_tool, local_pyproject
+from ohbin._errors import OhbinError
+from ohbin._gist import add_gist_tool, publish_gist
+from ohbin._manifest import find_pyproject, load_tools
+
+
+def _resolved_pyproject(explicit: Path | None, *, write: bool) -> Path:
+    """Resolve the manifest a command will use and announce it (to stderr).
+
+    Reading discovers upward; writing stays CWD-local. Either way we print the
+    fully-resolved realpath so it's never a mystery which pyproject ohbin touched.
+    """
+    path = local_pyproject(explicit) if write else (explicit or find_pyproject())
+    real = path.resolve()
+    print(f"[ohbin] resolved pyproject as {real}", file=sys.stderr)
+    return real
+
+
+def _cmd_run(ns: argparse.Namespace) -> int:
+    rest: list[str] = list(ns.args)
+    if rest and rest[0] == "--":  # tolerate `ohbin run tool -- <args>`
+        rest = rest[1:]
+    pyproject = _resolved_pyproject(ns.pyproject_file, write=False)
+    binary = ensure(ns.tool, pyproject=pyproject, password=ns.password)
+    # execv replaces this process so signals + exit codes forward transparently.
+    os.execv(str(binary), [ns.tool, *rest])
+    return 0  # unreachable
+
+
+def _cmd_add(ns: argparse.Namespace) -> int:
+    pyproject = _resolved_pyproject(ns.pyproject_file, write=True)
+    print(f"resolving {ns.repo}{f'@{ns.version}' if ns.version else ' (latest)'} ...")
+    name, target = add_tool(
+        repo=ns.repo,
+        version=ns.version,
+        name=ns.name,
+        binary=ns.binary,
+        pyproject=pyproject,
+    )
+    print(f"\nwrote [tool.ohbin.tools.{name}] to {target}")
+    print(f"run it with:  uv run ohbin run {name} -- <args>")
+    return 0
+
+
+def _cmd_publish_gist(ns: argparse.Namespace) -> int:
+    name = ns.name or Path(ns.path).name
+    url = publish_gist(
+        name=name,
+        binary=ns.binary or name,
+        binary_path=Path(ns.path),
+        password=ns.password,
+        platform_key=ns.platform,
+        gist_ref=ns.gist,
+        description=ns.desc or f"ohbin: encrypted {name}",
+    )
+    print(f"published {name} ({ns.platform or 'current platform'}) to {url}")
+    print(f"add it with:  uv run ohbin add-gist {url}")
+    return 0
+
+
+def _cmd_add_gist(ns: argparse.Namespace) -> int:
+    pyproject = _resolved_pyproject(ns.pyproject_file, write=True)
+    name, target = add_gist_tool(
+        gist_ref=ns.gist,
+        name=ns.name,
+        password=ns.password,
+        pyproject=pyproject,
+    )
+    print(f"wrote [tool.ohbin.tools.{name}] (encrypted) to {target}")
+    print(f"run it with:  uv run ohbin run --password <pw> {name} -- <args>")
+    return 0
+
+
+def _cmd_which(ns: argparse.Namespace) -> int:
+    pyproject = _resolved_pyproject(ns.pyproject_file, write=False)
+    print(ensure(ns.tool, pyproject=pyproject, password=ns.password))
+    return 0
+
+
+def _cmd_list(ns: argparse.Namespace) -> int:
+    pyproject = _resolved_pyproject(ns.pyproject_file, write=False)
+    tools = load_tools(pyproject)
+    if not tools:
+        print("no tools declared in [tool.ohbin.tools]")
+        return 0
+    width = max(len(n) for n in tools)
+    for name, cfg in sorted(tools.items()):
+        platforms = ", ".join(sorted(cfg["assets"]))
+        print(f"{name:{width}}  {cfg['repo']}@{cfg['version']}  [{platforms}]")
+    return 0
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="ohbin", description=__doc__)
+
+    # Shared across every subcommand: which manifest to read/write. Default None
+    # keeps walk-up discovery (find_pyproject) + the OHBIN_PYPROJECT override; an
+    # explicit path wins over both.
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument(
+        "--pyproject-file",
+        dest="pyproject_file",
+        default=None,
+        type=Path,
+        metavar="PATH",
+        help="manifest to read/write (default: nearest pyproject.toml with [tool.ohbin], or $OHBIN_PYPROJECT)",
+    )
+
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_run = sub.add_parser("run", parents=[common], help="download (if needed) and exec a declared tool")
+    p_run.add_argument("tool")
+    p_run.add_argument("--password", default=None, help="decrypt password for an encrypted tool")
+    p_run.add_argument("args", nargs=argparse.REMAINDER, help="args forwarded to the tool")
+    p_run.set_defaults(func=_cmd_run)
+
+    p_add = sub.add_parser("add", parents=[common], help="resolve a GitHub release and write it into pyproject")
+    p_add.add_argument("repo", help="GitHub repo as owner/name")
+    p_add.add_argument("--version", default=None, help="release version/tag (default: latest)")
+    p_add.add_argument("--name", default=None, help="command name (default: repo name)")
+    p_add.add_argument("--binary", default=None, help="binary name in archive (default: cmd name)")
+    p_add.set_defaults(func=_cmd_add)
+
+    p_pub = sub.add_parser("publish-gist", help="encrypt a binary and upload it to a secret gist for one platform")
+    p_pub.add_argument("path", help="path to the binary to encrypt + publish")
+    p_pub.add_argument("--password", required=True, help="encryption password (keep it out of the gist)")
+    p_pub.add_argument("--name", default=None, help="command name (default: binary filename)")
+    p_pub.add_argument("--binary", default=None, help="executable name to run (default: command name)")
+    p_pub.add_argument("--platform", default=None, help="platform key, e.g. linux-x86_64 (default: current)")
+    p_pub.add_argument("--gist", default=None, help="existing gist id/url to add this platform to")
+    p_pub.add_argument("--desc", default=None, help="gist description")
+    p_pub.set_defaults(func=_cmd_publish_gist)
+
+    p_addg = sub.add_parser("add-gist", parents=[common], help="resolve a published gist and write it into pyproject")
+    p_addg.add_argument("gist", help="gist id or url produced by publish-gist")
+    p_addg.add_argument("--name", default=None, help="command name (default: from the gist index)")
+    p_addg.add_argument(
+        "--password",
+        default=None,
+        help="store this decrypt password in pyproject (omit to pass --password at run time)",
+    )
+    p_addg.set_defaults(func=_cmd_add_gist)
+
+    p_which = sub.add_parser("which", parents=[common], help="print the cached binary path (downloads if needed)")
+    p_which.add_argument("tool")
+    p_which.add_argument("--password", default=None, help="decrypt password for an encrypted tool")
+    p_which.set_defaults(func=_cmd_which)
+
+    p_list = sub.add_parser("list", parents=[common], help="list declared tools")
+    p_list.set_defaults(func=_cmd_list)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    ns = _build_parser().parse_args(argv)
+    try:
+        return ns.func(ns)
+    except OhbinError as exc:  # expected, user-facing failures — no stack trace
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ohbin-0.2.2.dist-info/METADATA

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: ohbin
+Version: 0.2.2
+Summary: Declarative GitHub-release binaries for uv projects — declare a tool in pyproject, `ohbin run <tool>` downloads, SHA256-verifies, caches, and execs it. POSIX only (uses flock).
+Author: prostomarkeloff
+Author-email: prostomarkeloff <prostomarkeloff@ohreally.me>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: tomlkit>=0.13
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# ohbin
+
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+ohbin runs the binaries your project needs but can't `pip install`. You know the ones:
+`ripgrep` ([or… can you?](https://pypi.org/project/ripgrep/)), [`find-dup-defs`](https://github.com/prostomarkeloff/find-dup-defs), [`oasdiff`](https://github.com/oasdiff/oasdiff), some linter
+written in Rust that only ships as a GitHub release. uv
+installs Python packages, and those aren't Python packages, so normally you're stuck either
+telling everyone to install them by hand and watching the versions drift, or writing a little
+download-and-verify wrapper package and copying it into every repo.
+
+With ohbin you just write the tool down in your `pyproject.toml`. The first time you run it,
+ohbin downloads it, checks it against a SHA256 you pinned, caches it, and runs it. One
+dev-dependency, as many tools as you want.
+
+It's a small thing on purpose, built for people who already live in uv. Your binaries get
+pinned right next to your Python deps, in the same file, and run through the same flow.
+
+What it gives you:
+
+* binaries pinned to a version, pulled from GitHub releases
+* a SHA256 per platform, checked before anything gets unpacked
+* one dev-dependency, however many tools you declare
+* a per-host cache that's safe to hit from parallel CI
+* mostly stdlib (it shells out to `gh` and `openssl` only for the private-gist part)
+
+## Installation
+
+It's a dev dependency, so with uv:
+
+```sh
+uv add --dev git+https://github.com/prostomarkeloff/ohbin.git
+```
+
+## How to?
+
+Say you want ripgrep. Point ohbin at the repo:
+
+```sh
+uv run ohbin add BurntSushi/ripgrep --version 14.1.1 --name rg --binary rg
+```
+
+This goes and looks at the release, finds the right asset for each platform, pins the SHA256s,
+and writes a little table into your `pyproject.toml`. Your comments and formatting stay where
+they are:
+
+```toml
+[tool.ohbin.tools.rg]
+repo = "BurntSushi/ripgrep"
+version = "14.1.1"
+binary = "rg"
+# add writes one [..assets.<os>-<arch>] table per platform under here, checksums and all
+```
+
+`--name` is what you'll type when it's different from the repo name (ripgrep becomes rg), and
+`--binary` is the actual executable inside the archive. If add guesses an asset wrong, don't
+fight it, the table is the source of truth, just fix the line.
+
+Then run it:
+
+```sh
+uv run ohbin run rg -- --files     # first time: downloads, checks, caches, runs
+uv run ohbin run rg -- TODO src/   # after that it just runs
+```
+
+ohbin hands the process straight over with execv, so the tool itself gets stdin, stdout,
+signals and the exit code, exactly like you'd run it yourself. In a Makefile I usually hide
+the prefix behind a variable:
+
+```make
+RG := uv run ohbin run rg --
+search:; $(RG) TODO src/
+```
+
+`ohbin which fd` prints the cached path (and downloads it first if it has to), and `ohbin list`
+shows what you've declared.
+
+### Private binaries
+
+Sometimes the binary isn't on a public release page. Maybe you built it yourself and you don't
+want it in a repo at all. ohbin can ship it through a secret gist instead, encrypted with a
+password:
+
+```sh
+uv run ohbin publish-gist ./dist/mytool --password "$PW"
+```
+
+That gzips it, encrypts it, and drops one gist file per platform plus a small index. Run it
+from each platform's own machine, passing `--gist <id>` to add to the same gist. After that
+it's just another tool:
+
+```sh
+uv run ohbin add-gist https://gist.github.com/you/ab12… --name mytool
+uv run ohbin run --password "$PW" mytool -- --help
+```
+
+Why a gist and not a private repo? Because a gist isn't tied to a repo, and that's the whole
+point. You don't commit the binary anywhere, you don't hand out repo access and tokens to
+everyone who needs it, you just give them a link and a password. The link is unlisted and the
+bytes are AES-256-CBC, so a leaked link on its own is nothing without the password. The
+password goes to openssl over a file descriptor, never on the command line. To take access
+away, delete the gist or change the password.
+
+### From Python
+
+If you want the path instead of running the thing:
+
+```python
+from ohbin import ensure
+
+path = ensure("rg")   # a Path, downloaded and checked the first time
+```
+
+It finds your `pyproject.toml` by walking up from wherever you are. Set `OHBIN_PYPROJECT` if
+you need to point it at a specific file, like in CI.
+
+## How it works
+
+Nothing clever. On `ohbin run rg`, it reads the rg table, works out your os and arch, and looks
+for `~/.cache/ohbin/rg/14.1.1/rg`. If it's there, it runs it. If not, it downloads under a lock
+(so two parallel runs don't race), checks the SHA256 before unpacking anything, extracts, and
+runs. The version is in the cache path, so bumping it is just a fresh download that doesn't step
+on the old one. Downloads retry with backoff, and a real 404 doesn't get mistaken for a flaky
+network.
+
+## Limitations
+
+POSIX only for now, the locking uses `fcntl` so it won't even import on Windows. add
+auto-resolves four platforms (linux and macOS, x86_64 and arm64); anything else (windows, musl,
+riscv) you add to the table by hand and the engine runs it fine. Asset matching is just looking
+at the os/arch words in the filename and preferring `.tar.gz`, so a weird naming scheme might
+cost you a one-line fix.
+
+## Development
+
+```sh
+git clone https://github.com/prostomarkeloff/ohbin
+cd ohbin && uv sync
+
+make lint-heavy   # ruff format + check + pyright
+make test-full    # the network-free test suite
+```
+
+## License
+
+MIT, see [LICENSE](LICENSE).
+
+Made with 📦 by [prostomarkeloff](https://github.com/prostomarkeloff) and contributors.

ohbin-0.2.2.dist-info/RECORD

@@ -0,0 +1,18 @@
+ohbin/__init__.py,sha256=1e031f7476d21bfd7919cacf8f275ef0de6986b8bed9fe4bef09c27ba2ca94f4,3104
+ohbin/__main__.py,sha256=915476282041b2503b2deeecc4cf70e5b8d5444cb340536c4f84b38511168ba4,156
+ohbin/_add.py,sha256=76ee03705b8028e555ae9cdf1bbeca698a03da0ef8aca1bee1c1e385bc5e8016,8677
+ohbin/_crypto.py,sha256=8ff07d75607e85ebed4491fb249e437f4738a15a6a0a3bff62397af078a1bb49,3829
+ohbin/_engine.py,sha256=6f938571253f2b029d3ea46fdae17a7f75a26b32cd6808ea2a4da4e7ad15cf99,8849
+ohbin/_errors.py,sha256=bf801a5ed91fc44a8bf34f53174d7d96e50c0f4d46f869d8e2ba402bf387c464,470
+ohbin/_gist.py,sha256=72309401b5699262dc5912e797b36b4fbc72f05644fd130243f83fa9fc6f7002,7893
+ohbin/_github.py,sha256=a08b702d70f725c2a14be74a26ee21c589a75eec377942207b28110cfffe6415,4388
+ohbin/_manifest.py,sha256=67b19720d7b4868e2baf737aba2bb96e53733f99f10878861600cfac6bac8722,3697
+ohbin/_platform.py,sha256=b7e6977af9e5bf9bfa564ce10ca9603040b18b6aecb88955e0b2b0b59c0c7016,2322
+ohbin/_retry.py,sha256=aa420f728d2efa33e8f5b5fa47c94961f03a297c38a0cc5fa4357f8f012d87d1,1829
+ohbin/_types.py,sha256=74129064d74de26d9e34e995dfcfde4c73595ee60cdee7a47e3b931e822b5e8c,1404
+ohbin/cli.py,sha256=78df9de58b14af23d4d69c8c9c8fbf134f4fe86e9ac0808f7d3e739693169401,7177
+ohbin-0.2.2.dist-info/licenses/LICENSE,sha256=901a5290e212a2d5df3eecf82c9476c0193d7b11c481c0bb06c647ec96fbdccf,1072
+ohbin-0.2.2.dist-info/WHEEL,sha256=3b15e9d349224e1d7f45954c2fa08db3621d4900601519e7501bb24397da80f8,78
+ohbin-0.2.2.dist-info/entry_points.txt,sha256=45ce01a96e87f712abce59fb3c26a2c32180403e90ab00e8946cb262bca17b35,42
+ohbin-0.2.2.dist-info/METADATA,sha256=bde4b686c7df117c52d718a071853fd27f54c5c16843f36ee899ed05917c73b8,6203
+ohbin-0.2.2.dist-info/RECORD,,

ohbin-0.2.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.8.1
+Root-Is-Purelib: true
+Tag: py3-none-any

ohbin-0.2.2.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+ohbin = ohbin.cli:main
+

ohbin-0.2.2.dist-info/licenses/LICENSE

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