paradigx-cli-core 0.1.0__py3-none-any.whl

paradigx_cli_core/__init__.py

@@ -0,0 +1,63 @@
+"""paradigx-cli-core — shared core for Paradigx product CLIs.
+
+Provides OAuth device-flow login, a shared `~/.paradigx/auth.json` token
+cache, automatic JWT refresh, an HTTP client, and `--json` output helpers.
+Product CLIs (botu, tokenroute, ...) depend on this and keep only their
+command layer. See docs/specs/cli-phase-b.md.
+"""
+from .client import ApiError, exit_code_for, request, with_trailing_slash
+from .config import (
+    Credentials,
+    clear_credentials,
+    default_config_dir,
+    import_legacy,
+    load_credentials,
+    save_credentials,
+)
+from .auth import NeedLogin, do_login, refresh, valid_access_token
+from .device_flow import (
+    DeviceCodeResponse,
+    DiscoveryInfo,
+    fetch_discovery,
+    open_browser,
+    poll_for_token,
+    request_device_code,
+)
+from .output import emit, error, info, is_json_mode, set_json_mode, success
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "__version__",
+    # client
+    "ApiError",
+    "exit_code_for",
+    "request",
+    "with_trailing_slash",
+    # config
+    "Credentials",
+    "clear_credentials",
+    "default_config_dir",
+    "import_legacy",
+    "load_credentials",
+    "save_credentials",
+    # auth
+    "NeedLogin",
+    "do_login",
+    "refresh",
+    "valid_access_token",
+    # device_flow
+    "DeviceCodeResponse",
+    "DiscoveryInfo",
+    "fetch_discovery",
+    "open_browser",
+    "poll_for_token",
+    "request_device_code",
+    # output
+    "emit",
+    "error",
+    "info",
+    "is_json_mode",
+    "set_json_mode",
+    "success",
+]

paradigx_cli_core/auth.py

@@ -0,0 +1,113 @@
+"""Login orchestration + automatic token refresh.
+
+`do_login` runs the full device-flow and persists credentials.
+`valid_access_token` is what command code calls before every API request:
+it returns a non-expired access token, transparently refreshing via the
+stored refresh_token when needed.
+"""
+from __future__ import annotations
+
+import time
+from dataclasses import replace
+
+import httpx
+
+from .config import Credentials, load_credentials, save_credentials
+from .device_flow import fetch_discovery, poll_for_token, request_device_code
+
+# Refresh when fewer than this many seconds of validity remain.
+_REFRESH_SKEW_SECONDS = 60
+
+
+class NeedLogin(RuntimeError):
+    """Raised when there's no usable credential and the user must log in."""
+
+    def __init__(self, message: str = "not logged in — run `login` first"):
+        super().__init__(message)
+
+
+def _token_endpoint(creds: Credentials) -> str | None:
+    """Resolve the OIDC token endpoint for a credential.
+
+    New logins store `token_endpoint` directly. Pre-Phase-B / legacy-imported
+    entries only have `issuer`; derive from it (botu issuer ends with `/oidc`,
+    tokenroute issuer doesn't).
+    """
+    if creds.token_endpoint:
+        return creds.token_endpoint
+    iss = (creds.issuer or "").rstrip("/")
+    if not iss:
+        return None
+    return f"{iss}/token" if iss.endswith("/oidc") else f"{iss}/oidc/token"
+
+
+def refresh(creds: Credentials) -> Credentials:
+    """Exchange the stored refresh_token for a fresh access token.
+
+    Raises NeedLogin if the credential can't be refreshed (no refresh_token,
+    endpoint unknown, or the IdP rejects it).
+    """
+    endpoint = _token_endpoint(creds)
+    if not creds.refresh_token or not creds.client_id or not endpoint:
+        raise NeedLogin("session expired — run `login` again")
+    data = {
+        "grant_type": "refresh_token",
+        "refresh_token": creds.refresh_token,
+        "client_id": creds.client_id,
+    }
+    if creds.resource:
+        data["resource"] = creds.resource
+    try:
+        with httpx.Client(timeout=15.0) as c:
+            r = c.post(endpoint, data=data)
+    except httpx.RequestError as e:
+        raise NeedLogin(f"could not reach auth server to refresh: {e}") from e
+    if not r.is_success:
+        raise NeedLogin("session expired — run `login` again")
+    tok = r.json()
+    return replace(
+        creds,
+        access_token=tok["access_token"],
+        refresh_token=tok.get("refresh_token") or creds.refresh_token,
+        expires_at=int(time.time()) + int(tok.get("expires_in", 3600)),
+    )
+
+
+def valid_access_token(api_url: str) -> str:
+    """Return a non-expired access token for `api_url`.
+
+    Auto-refreshes (and persists) when the cached token is within the skew
+    window of expiry. Raises NeedLogin if there's nothing usable.
+    """
+    creds = load_credentials(api_url)
+    if creds is None or not creds.access_token:
+        raise NeedLogin()
+    if creds.expires_at and creds.expires_at - time.time() < _REFRESH_SKEW_SECONDS:
+        creds = refresh(creds)
+        save_credentials(creds)
+    return creds.access_token
+
+
+def do_login(discovery_url: str, api_url: str, *, on_code=None) -> Credentials:
+    """Run the full OAuth device-flow and persist the result.
+
+    `on_code(DeviceCodeResponse)` is invoked once the user code is known —
+    the CLI uses it to print the verification URL and open a browser.
+    """
+    disc = fetch_discovery(discovery_url)
+    code = request_device_code(disc)
+    if on_code is not None:
+        on_code(code)
+    tok = poll_for_token(disc, code)
+    creds = Credentials(
+        access_token=tok["access_token"],
+        refresh_token=tok.get("refresh_token"),
+        expires_at=int(time.time()) + int(tok.get("expires_in", 3600)),
+        issuer=disc.issuer,
+        client_id=disc.client_id,
+        resource=disc.resource,
+        api_url=api_url,
+        token_endpoint=disc.token_endpoint,
+    )
+    save_credentials(creds)
+    return creds

paradigx_cli_core/client.py

@@ -0,0 +1,86 @@
+"""Thin HTTP client for Paradigx product APIs.
+
+`request()` is product-agnostic: the caller passes the base URL, the bearer
+token, and whether the API needs trailing slashes (botu-web is a Next.js
+app with `trailingSlash: true`; the tokenroute FastAPI gateway is not).
+"""
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+
+class ApiError(RuntimeError):
+    def __init__(self, status: int, message: str, body: Any = None):
+        super().__init__(f"HTTP {status}: {message}")
+        self.status = status
+        self.message = message
+        self.body = body
+
+
+def exit_code_for(err: ApiError) -> int:
+    """Map an ApiError onto a CLI exit code: 1 user / 2 network / 3 server."""
+    if err.status == 0:
+        return 2
+    return 1 if err.status < 500 else 3
+
+
+def with_trailing_slash(path: str) -> str:
+    """Ensure a `/` before any query string — for `trailingSlash: true` APIs."""
+    base, sep, query = path.partition("?")
+    if not base.endswith("/"):
+        base += "/"
+    return f"{base}{sep}{query}"
+
+
+def _raise(resp: httpx.Response) -> None:
+    if resp.is_success:
+        return
+    try:
+        body = resp.json()
+    except (ValueError, httpx.DecodingError):
+        body = resp.text
+    if isinstance(body, dict):
+        err = body.get("error")
+        if isinstance(err, dict):  # {"error": {"message": ...}}
+            msg = err.get("message") or resp.reason_phrase
+        else:  # {"error": "...", "detail"?: "..."}
+            msg = err or body.get("detail") or body.get("message") or resp.reason_phrase
+            if err and body.get("detail"):
+                msg = f"{err} ({body['detail']})"
+    else:
+        msg = resp.reason_phrase
+    raise ApiError(resp.status_code, str(msg), body)
+
+
+def request(
+    method: str,
+    base_url: str,
+    path: str,
+    *,
+    token: str,
+    json_body: Any | None = None,
+    timeout: float = 30.0,
+    trailing_slash: bool = False,
+    follow_redirects: bool = True,
+    user_agent: str = "paradigx-cli-core",
+) -> Any:
+    """Call a product API endpoint with a bearer token. Returns parsed JSON."""
+    if trailing_slash:
+        path = with_trailing_slash(path)
+    headers = {
+        "User-Agent": user_agent,
+        "Accept": "application/json",
+        "Authorization": f"Bearer {token}",
+    }
+    url = f"{base_url.rstrip('/')}{path}"
+    try:
+        with httpx.Client(timeout=timeout, follow_redirects=follow_redirects) as client:
+            resp = client.request(method, url, json=json_body, headers=headers)
+    except httpx.RequestError as e:
+        raise ApiError(0, f"network error: {e}") from e
+    _raise(resp)
+    if resp.status_code == 204 or not resp.content:
+        return None
+    return resp.json()

paradigx_cli_core/config.py

@@ -0,0 +1,160 @@
+"""Shared credential storage for Paradigx product CLIs.
+
+Tokens live in ``~/.paradigx/auth.json`` — shared across every Paradigx
+CLI (botu, tokenroute, ...). They all authenticate against the same Logto,
+so a single login is reused. Entries are keyed by Logto resource indicator
+(so multiple products / envs coexist); retrieval picks the entry whose
+``api_url`` matches the current target.
+
+auth.json shape::
+
+    { "version": 1,
+      "tokens": {
+        "<resource>": { access_token, refresh_token, expires_at, issuer,
+                        client_id, resource, api_url, token_endpoint } } }
+"""
+from __future__ import annotations
+
+import json
+import os
+import stat
+from dataclasses import dataclass
+from pathlib import Path
+
+_CRED_FIELDS = (
+    "access_token",
+    "refresh_token",
+    "expires_at",
+    "issuer",
+    "client_id",
+    "resource",
+    "api_url",
+    "token_endpoint",
+)
+
+
+def default_config_dir() -> Path:
+    return Path.home() / ".paradigx"
+
+
+def _auth_path() -> Path:
+    return default_config_dir() / "auth.json"
+
+
+@dataclass
+class Credentials:
+    access_token: str
+    refresh_token: str | None = None
+    expires_at: int | None = None  # unix seconds
+    issuer: str | None = None
+    client_id: str | None = None
+    resource: str | None = None
+    api_url: str | None = None
+    token_endpoint: str | None = None  # OIDC token endpoint, for refresh
+
+
+def _read_store() -> dict:
+    p = _auth_path()
+    if not p.exists():
+        return {"version": 1, "tokens": {}}
+    try:
+        data = json.loads(p.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return {"version": 1, "tokens": {}}
+    if not isinstance(data, dict):
+        return {"version": 1, "tokens": {}}
+    if not isinstance(data.get("tokens"), dict):
+        data["tokens"] = {}
+    data.setdefault("version", 1)
+    return data
+
+
+def _write_store(store: dict) -> None:
+    d = default_config_dir()
+    d.mkdir(parents=True, exist_ok=True)
+    p = _auth_path()
+    p.write_text(json.dumps(store, indent=2), encoding="utf-8")
+    # Owner-only on POSIX; near no-op on Windows but doesn't error.
+    try:
+        os.chmod(p, stat.S_IRUSR | stat.S_IWUSR)
+    except OSError:
+        pass
+
+
+def save_credentials(creds: Credentials) -> Path:
+    store = _read_store()
+    key = creds.resource or creds.api_url or "default"
+    store["tokens"][key] = {f: getattr(creds, f) for f in _CRED_FIELDS}
+    _write_store(store)
+    return _auth_path()
+
+
+def load_credentials(api_url: str) -> Credentials | None:
+    """Return the stored credential whose ``api_url`` matches."""
+    store = _read_store()
+    matches = [
+        v for v in store["tokens"].values() if isinstance(v, dict) and v.get("api_url") == api_url
+    ]
+    if not matches:
+        return None
+    best = max(matches, key=lambda v: v.get("expires_at") or 0)
+    return Credentials(**{f: best.get(f) for f in _CRED_FIELDS})
+
+
+def clear_credentials(api_url: str) -> bool:
+    """Drop credential(s) for ``api_url``. True if anything was removed."""
+    store = _read_store()
+    kept = {
+        k: v
+        for k, v in store["tokens"].items()
+        if not (isinstance(v, dict) and v.get("api_url") == api_url)
+    }
+    if len(kept) == len(store["tokens"]):
+        return False
+    store["tokens"] = kept
+    _write_store(store)
+    return True
+
+
+def import_legacy(
+    legacy_path: Path,
+    api_url: str,
+    *,
+    token_endpoint: str | None = None,
+    resource: str | None = None,
+) -> bool:
+    """Migrate a pre-Phase-B single-credential file into the shared store.
+
+    Used by tokenroute 0.2.0 to pull ``~/.tokenroute/credentials.json`` into
+    ``~/.paradigx/auth.json``. No-op if the legacy file is absent or this
+    api_url already has an entry. The legacy file is left in place (so a
+    downgrade to 0.1.0 still works).
+
+    `resource` is a fallback for legacy files that predate the field — it's
+    required for the OIDC token endpoint to mint JWT (not opaque) access
+    tokens on refresh, so the caller must supply its product's resource
+    indicator when the legacy file may lack one.
+    """
+    if not legacy_path.exists():
+        return False
+    if load_credentials(api_url) is not None:
+        return False
+    try:
+        data = json.loads(legacy_path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return False
+    if not isinstance(data, dict) or not data.get("access_token"):
+        return False
+    save_credentials(
+        Credentials(
+            access_token=data.get("access_token", ""),
+            refresh_token=data.get("refresh_token"),
+            expires_at=data.get("expires_at"),
+            issuer=data.get("issuer"),
+            client_id=data.get("client_id"),
+            resource=data.get("resource") or resource,
+            api_url=api_url,
+            token_endpoint=token_endpoint,
+        )
+    )
+    return True

paradigx_cli_core/device_flow.py

@@ -0,0 +1,129 @@
+"""OIDC device-flow client — talks directly to Logto.
+
+The product CLI passes its discovery URL (a product endpoint that returns
+``{issuer, client_id, resource, scopes, device_authorization_endpoint,
+token_endpoint}``). The CLI never hardcodes a Logto URL. This is the
+OIDC-standard pattern: the client connects to the IdP, the resource server
+only validates tokens.
+"""
+from __future__ import annotations
+
+import time
+import webbrowser
+from dataclasses import dataclass
+
+import httpx
+
+# Per RFC 8628 §3.5 we honour the server's `interval`; this is a sane floor.
+_MIN_POLL_INTERVAL_SECONDS = 5
+
+
+@dataclass
+class DiscoveryInfo:
+    issuer: str
+    client_id: str
+    resource: str
+    scopes: list[str]
+    device_authorization_endpoint: str
+    token_endpoint: str
+
+
+@dataclass
+class DeviceCodeResponse:
+    device_code: str
+    user_code: str
+    verification_uri: str
+    verification_uri_complete: str
+    expires_in: int
+    interval: int
+
+
+def fetch_discovery(discovery_url: str) -> DiscoveryInfo:
+    """GET the product's auth-discovery endpoint."""
+    with httpx.Client(timeout=10.0, follow_redirects=True) as c:
+        r = c.get(discovery_url)
+    r.raise_for_status()
+    data = r.json()
+    return DiscoveryInfo(
+        issuer=data["issuer"],
+        client_id=data["client_id"],
+        resource=data["resource"],
+        scopes=data["scopes"],
+        device_authorization_endpoint=data["device_authorization_endpoint"],
+        token_endpoint=data["token_endpoint"],
+    )
+
+
+def request_device_code(disc: DiscoveryInfo) -> DeviceCodeResponse:
+    """POST {device_authorization_endpoint} → device_code + user_code."""
+    with httpx.Client(timeout=10.0) as c:
+        r = c.post(
+            disc.device_authorization_endpoint,
+            data={
+                "client_id": disc.client_id,
+                "scope": " ".join(disc.scopes),
+                "resource": disc.resource,
+            },
+        )
+    r.raise_for_status()
+    body = r.json()
+    return DeviceCodeResponse(
+        device_code=body["device_code"],
+        user_code=body["user_code"],
+        verification_uri=body["verification_uri"],
+        verification_uri_complete=body.get(
+            "verification_uri_complete", body["verification_uri"]
+        ),
+        expires_in=body["expires_in"],
+        interval=max(body.get("interval", 5), _MIN_POLL_INTERVAL_SECONDS),
+    )
+
+
+def open_browser(url: str) -> bool:
+    """Best-effort. False on headless environments with no display."""
+    try:
+        return webbrowser.open(url)
+    except webbrowser.Error:
+        return False
+
+
+def poll_for_token(disc: DiscoveryInfo, code: DeviceCodeResponse, *, on_pending=None) -> dict:
+    """Poll {token_endpoint} until success / expired / denied.
+
+    Returns the raw token response dict. Raises RuntimeError with a
+    human-readable message on failure.
+    """
+    deadline = time.time() + code.expires_in
+    interval = code.interval
+    with httpx.Client(timeout=10.0) as client:
+        while time.time() < deadline:
+            time.sleep(interval)
+            r = client.post(
+                disc.token_endpoint,
+                data={
+                    "client_id": disc.client_id,
+                    "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+                    "device_code": code.device_code,
+                    "resource": disc.resource,
+                },
+            )
+            if r.is_success:
+                return r.json()
+            err = (
+                r.json().get("error")
+                if r.headers.get("content-type", "").startswith("application/json")
+                else None
+            )
+            if err == "authorization_pending":
+                if on_pending is not None:
+                    on_pending()
+                continue
+            if err == "slow_down":
+                interval += 5
+                continue
+            if err == "expired_token":
+                raise RuntimeError("device code expired — log in again")
+            if err == "access_denied":
+                raise RuntimeError("login denied by user")
+            raise RuntimeError(f"token exchange failed ({r.status_code}): {r.text}")
+    raise RuntimeError("device code expired before user completed login")

paradigx_cli_core/output.py

@@ -0,0 +1,76 @@
+"""Output helpers — toggle between human-friendly rich tables and --json.
+
+JSON mode is process-global, set by the product CLI's Typer callback via
+`set_json_mode()` and read everywhere via `is_json_mode()`.
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+from typing import Any
+
+from rich.console import Console
+from rich.table import Table
+
+_JSON_ENV = "_PARADIGX_CLI_JSON"
+_console = Console()
+_err_console = Console(stderr=True)
+
+
+def set_json_mode(enabled: bool) -> None:
+    if enabled:
+        os.environ[_JSON_ENV] = "1"
+    else:
+        os.environ.pop(_JSON_ENV, None)
+
+
+def is_json_mode() -> bool:
+    return os.environ.get(_JSON_ENV) == "1"
+
+
+def emit(payload: Any, *, table_columns: list[tuple[str, str]] | None = None) -> None:
+    """Print `payload` as JSON (agent mode) or a rich table / kv list (human).
+
+    `table_columns` is a list of `(header, dict_key)` pairs used when payload
+    is a list. Single dicts render as a key/value list.
+    """
+    if is_json_mode():
+        print(json.dumps(payload, indent=2, default=str))
+        return
+
+    if isinstance(payload, list) and table_columns:
+        table = Table(show_header=True, header_style="bold")
+        for header, _ in table_columns:
+            table.add_column(header)
+        for row in payload:
+            table.add_row(*[str(row.get(k, "")) for _, k in table_columns])
+        _console.print(table)
+        return
+
+    if isinstance(payload, dict):
+        for k, v in payload.items():
+            _console.print(f"[bold]{k}[/bold]: {v}")
+        return
+
+    _console.print(payload)
+
+
+def info(msg: str) -> None:
+    if not is_json_mode():
+        _console.print(msg)
+
+
+def success(msg: str) -> None:
+    if not is_json_mode():
+        # ASCII-safe marker — Windows legacy GBK consoles can't encode U+2713.
+        _console.print(f"[green]OK[/green] {msg}")
+
+
+def error(msg: str, *, code: int = 1) -> None:
+    """Print an error and exit. code: 1 user / 2 network / 3 server."""
+    if is_json_mode():
+        print(json.dumps({"error": msg}, indent=2))
+    else:
+        _err_console.print(f"[red]error[/red]: {msg}")
+    sys.exit(code)

paradigx_cli_core-0.1.0.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: paradigx-cli-core
+Version: 0.1.0
+Summary: Shared core for Paradigx product CLIs — OAuth device-flow, token cache, HTTP client
+Project-URL: Homepage, https://github.com/jiangjin11/paradigx-workspace
+Author: Paradigx Pte Ltd
+License: MIT
+Keywords: agent,cli,device-flow,oauth,paradigx
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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 :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.28
+Requires-Dist: rich>=13.0
+Provides-Extra: dev
+Requires-Dist: pytest-mock>=3.14; extra == 'dev'
+Requires-Dist: pytest>=8.3; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# paradigx-cli-core
+
+Shared core for [Paradigx](https://github.com/jiangjin11/paradigx-workspace)
+product CLIs (`botu`, `tokenroute`, ...).
+
+This is a **library, not a CLI** — it has no command entry point. Product
+CLIs depend on it and keep only their command layer.
+
+## What it provides
+
+- **OAuth device-flow** login against Logto (`auth`, `device_flow`)
+- **Shared token cache** at `~/.paradigx/auth.json`, keyed by API URL, so
+  one login is reused across every Paradigx CLI (`config`)
+- **Automatic JWT refresh** — cached tokens are transparently renewed via
+  the stored refresh token (`auth.valid_access_token`)
+- **HTTP client** with per-product trailing-slash / redirect handling
+  (`client`)
+- **`--json` output helpers** — rich tables for humans, JSON for agents
+  (`output`)
+
+## Usage (by a product CLI)
+
+```python
+from paradigx_cli_core import do_login, valid_access_token, request
+
+# login
+do_login("https://botu.io/api/auth/discovery/", "https://botu.io",
+         on_code=lambda c: print("visit", c.verification_uri_complete))
+
+# authenticated call (auto-refreshes the token)
+token = valid_access_token("https://botu.io")
+sites = request("GET", "https://botu.io", "/api/sites",
+                token=token, trailing_slash=True)
+```
+
+See `docs/specs/cli-phase-b.md` in the workspace repo for the design.
+
+---
+
+© 2026 Paradigx. All Rights Reserved.

paradigx_cli_core-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+paradigx_cli_core/__init__.py,sha256=hICpsmMPWyeVyuksNVRAyeGOBIyj2rjJJOgGbBjvKuM,1508
+paradigx_cli_core/auth.py,sha256=IyuPeinzfva_ktVQcB2gJHphV3gimnzojVUfJ6tPPYM,3974
+paradigx_cli_core/client.py,sha256=Kpmr5dg2Fd9hTntkXy8kTVeEYhIWohaUtz20Q0Wr2Mw,2729
+paradigx_cli_core/config.py,sha256=3qKf9V1N6YDNAOvgtE9PYJeEf1LgKSC91TUdYxCVimk,4894
+paradigx_cli_core/device_flow.py,sha256=2t5lqKS7OuJnoXNoQFL5s94MP6Q1n2EoyAF8p3PT7XQ,4252
+paradigx_cli_core/output.py,sha256=KraSThVAe-fxv7VZhLkdMdLswbditYuSc7pV9OOR-GU,2153
+paradigx_cli_core-0.1.0.dist-info/METADATA,sha256=4CYZtJsNGs4FiigU5RC-Km21DC79HEqqWjapysID-K8,2412
+paradigx_cli_core-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+paradigx_cli_core-0.1.0.dist-info/RECORD,,

paradigx_cli_core-0.1.0.dist-info/WHEEL

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