whispy-client 1.0.0__tar.gz

whispy_client-1.0.0/.gitignore

@@ -0,0 +1,46 @@
+# Python
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+.Python
+*.egg
+*.egg-info/
+dist/
+build/
+.eggs/
+.env
+.venv
+env/
+venv/
+
+# Whispy
+cache/
+*.zip
+
+# Testing
+.pytest_cache/
+.coverage
+coverage.xml
+htmlcov/
+
+# Editors
+.idea/
+.vscode/
+*.swp
+*.swo
+.DS_Store
+
+# Docker
+.dockerignore
+
+# Cloudflare
+.wrangler/
+node_modules/
+
+# Secrets
+.env.local
+secrets.json
+
+
+.ruff_cache/

whispy_client-1.0.0/PKG-INFO

@@ -0,0 +1,231 @@
+Metadata-Version: 2.4
+Name: whispy-client
+Version: 1.0.0
+Summary: Stream Python packages at runtime — the PyPI CDN client
+Project-URL: Homepage, https://whispy.dev
+Project-URL: Repository, https://github.com/Dark-Avenger-Reborn/Whispy
+Project-URL: Documentation, https://whispy.dev/docs
+Project-URL: Bug Tracker, https://github.com/Dark-Avenger-Reborn/Whispy/issues
+License: MIT
+Keywords: cdn,dynamic-import,packages,pypi,runtime
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+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
+Classifier: Topic :: System :: Installation/Setup
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# 🌀 Whispy — The Python Package CDN
+
+> Stream Python packages at runtime. No `pip install`, no virtual envs, no environment setup.
+> **The PyPI equivalent of unpkg.com / jsDelivr.**
+
+```python
+from whispy_client import remote
+
+requests = remote("requests")
+numpy    = remote("numpy==1.26.4")
+bs4      = remote("beautifulsoup4", module="bs4", deps=True)
+
+print(requests.get("https://httpbin.org/get").status_code)  # 200
+```
+
+**Packages are streamed from PyPI through the Whispy CDN, SHA-256 verified, extracted to a
+temporary directory, and imported at runtime. Nothing is permanently installed. Everything
+disappears when your process exits.**
+
+---
+
+## Architecture
+
+```
+┌─────────────┐    HTTPS    ┌──────────────────┐    ┌──────────────┐
+│ Your Script │ ──────────► │ Cloudflare Edge  │ ──►│ Whispy       │
+│ (client)    │             │ (CDN cache)       │    │ Origin Server│
+└─────────────┘             └──────────────────┘    └──────┬───────┘
+                                                           │
+                                                    ┌──────▼───────┐
+                                                    │  PyPI API    │
+                                                    └──────────────┘
+```
+
+- **Client** (`whispy_client`) — Zero-dependency installable. Computes PEP 425 tags, fetches the right wheel, extracts to tmpdir, imports.
+- **CDN Edge** (Cloudflare Worker) — Caches versioned package zips with 1-year immutable TTL. Adds security headers, validates inputs.
+- **Origin Server** (`server/app.py`) — Resolves packages, fetches from PyPI, verifies SHA-256, zips for serving, maintains disk cache.
+
+---
+
+## Repository Structure
+
+```
+whispy/
+├── server/                  # Whispy CDN origin server
+│   ├── app.py               # Flask application
+│   ├── requirements.txt
+│   └── Dockerfile
+│
+├── client/                  # whispy-client Python package
+│   ├── whispy_client/
+│   │   ├── __init__.py      # Public API: remote(), configure()
+│   │   └── core.py          # Zero-dep implementation
+│   └── pyproject.toml
+│
+├── docs/                    # whispy.dev documentation site
+│   └── index.html
+│
+├── deploy/                  # Infrastructure configs
+│   ├── docker-compose.yml
+│   ├── cloudflare-worker.js # Cloudflare CDN edge layer
+│   └── wrangler.toml
+│
+└── .github/
+    └── workflows/
+        └── ci.yml           # CI: test → build → publish → deploy
+```
+
+---
+
+## Quick Start
+
+### Use the hosted CDN
+
+```bash
+pip install whispy-client
+```
+
+```python
+from whispy_client import remote, configure
+
+# Optional: enable dep resolution and verbose logging
+configure(deps=True, verbose=True)
+
+requests = remote("requests")
+print(requests.get("https://httpbin.org/get").status_code)
+```
+
+### Self-host
+
+```bash
+# Clone
+git clone https://github.com/Dark-Avenger-Reborn/Whispy
+cd Whispy
+
+# Run with Docker Compose
+docker compose -f deploy/docker-compose.yml up -d
+
+# Point your client at it
+WHISPY_HOST=http://localhost:8000 python my_script.py
+```
+
+### Run server locally (dev)
+
+```bash
+cd server
+pip install -r requirements.txt
+python app.py --debug
+```
+
+---
+
+## Client API
+
+### `remote(package, *, module=None, version=None, deps=False, host=None)`
+
+| Param | Description |
+|-------|-------------|
+| `package` | PyPI name, optionally with `==version` e.g. `"requests==2.31.0"` |
+| `module` | Import name if different from package name (e.g. `module="bs4"`) |
+| `version` | Explicit version, overrides embedded spec |
+| `deps` | If `True`, resolve and fetch transitive dependencies |
+| `host` | Per-call CDN URL override |
+
+**Common name mismatches:**
+```python
+bs4      = remote("beautifulsoup4", module="bs4")
+PIL      = remote("pillow",         module="PIL")
+yaml     = remote("pyyaml",         module="yaml")
+dateutil = remote("python-dateutil",module="dateutil")
+cv2      = remote("opencv-python",  module="cv2")
+```
+
+### `configure(*, host=None, deps=None, verbose=None)`
+
+Set global defaults. Can also use `WHISPY_HOST` env var.
+
+---
+
+## Server API
+
+| Endpoint | Description |
+|----------|-------------|
+| `GET /get_package?name=X&tags=...&version=Y&deps=1` | Download package zip |
+| `GET /metadata/<package>` | Package metadata without download |
+| `GET /health` | Health check + cache stats |
+| `GET /stats` | Cache statistics |
+
+---
+
+## Security
+
+- **SHA-256 verification** — Every file verified against PyPI digests before serving
+- **Blocklist** — Known typosquatted packages are rejected
+- **Input validation** — Package names validated against `[A-Za-z0-9_.-]+`
+- **Rate limiting** — 60 req/min per IP on `/get_package`
+- **HTTPS enforced** — Cloudflare handles TLS termination
+- **Immutable URLs** — Versioned package URLs are `Cache-Control: immutable`
+- **Server never imports packages** — Only proxies/caches them
+
+---
+
+## Deployment
+
+### CI/CD (GitHub Actions)
+
+The `.github/workflows/ci.yml` pipeline:
+
+1. **Test** — server tests + client across Python 3.8–3.13, Linux/macOS/Windows
+2. **Lint** — ruff
+3. **Docker** — builds and pushes to GHCR on every `main` push
+4. **PyPI** — publishes `whispy-client` on version tags (`v*`)
+5. **Cloudflare** — deploys the Worker on `main`
+
+### Required secrets
+
+| Secret | Description |
+|--------|-------------|
+| `CF_API_TOKEN` | Cloudflare API token with Workers:Edit permission |
+
+### Environment vars (server)
+
+| Var | Default | Description |
+|-----|---------|-------------|
+| `WHISPY_CACHE_DIR` | `./cache` | Disk cache directory |
+| `WHISPY_MAX_CACHE_MB` | `2048` | Max cache size in MB |
+| `REDIS_URL` | `memory://` | Redis URL for distributed rate limiting |
+
+---
+
+## Roadmap
+
+- [ ] Conflict-aware dependency resolver (full PubGrub/resolvelib integration)
+- [ ] `whispy lock` CLI — generate a lockfile for reproducible scripts
+- [ ] Browser / Pyodide support
+- [ ] Package usage analytics dashboard
+- [ ] Webhook notifications for new package versions
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+> Packages are sourced from [PyPI](https://pypi.org) and served under their original licenses.
+> Whispy does not host or redistribute package source code — it proxies directly from PyPI's CDN.

whispy_client-1.0.0/README.md

@@ -0,0 +1,206 @@
+# 🌀 Whispy — The Python Package CDN
+
+> Stream Python packages at runtime. No `pip install`, no virtual envs, no environment setup.
+> **The PyPI equivalent of unpkg.com / jsDelivr.**
+
+```python
+from whispy_client import remote
+
+requests = remote("requests")
+numpy    = remote("numpy==1.26.4")
+bs4      = remote("beautifulsoup4", module="bs4", deps=True)
+
+print(requests.get("https://httpbin.org/get").status_code)  # 200
+```
+
+**Packages are streamed from PyPI through the Whispy CDN, SHA-256 verified, extracted to a
+temporary directory, and imported at runtime. Nothing is permanently installed. Everything
+disappears when your process exits.**
+
+---
+
+## Architecture
+
+```
+┌─────────────┐    HTTPS    ┌──────────────────┐    ┌──────────────┐
+│ Your Script │ ──────────► │ Cloudflare Edge  │ ──►│ Whispy       │
+│ (client)    │             │ (CDN cache)       │    │ Origin Server│
+└─────────────┘             └──────────────────┘    └──────┬───────┘
+                                                           │
+                                                    ┌──────▼───────┐
+                                                    │  PyPI API    │
+                                                    └──────────────┘
+```
+
+- **Client** (`whispy_client`) — Zero-dependency installable. Computes PEP 425 tags, fetches the right wheel, extracts to tmpdir, imports.
+- **CDN Edge** (Cloudflare Worker) — Caches versioned package zips with 1-year immutable TTL. Adds security headers, validates inputs.
+- **Origin Server** (`server/app.py`) — Resolves packages, fetches from PyPI, verifies SHA-256, zips for serving, maintains disk cache.
+
+---
+
+## Repository Structure
+
+```
+whispy/
+├── server/                  # Whispy CDN origin server
+│   ├── app.py               # Flask application
+│   ├── requirements.txt
+│   └── Dockerfile
+│
+├── client/                  # whispy-client Python package
+│   ├── whispy_client/
+│   │   ├── __init__.py      # Public API: remote(), configure()
+│   │   └── core.py          # Zero-dep implementation
+│   └── pyproject.toml
+│
+├── docs/                    # whispy.dev documentation site
+│   └── index.html
+│
+├── deploy/                  # Infrastructure configs
+│   ├── docker-compose.yml
+│   ├── cloudflare-worker.js # Cloudflare CDN edge layer
+│   └── wrangler.toml
+│
+└── .github/
+    └── workflows/
+        └── ci.yml           # CI: test → build → publish → deploy
+```
+
+---
+
+## Quick Start
+
+### Use the hosted CDN
+
+```bash
+pip install whispy-client
+```
+
+```python
+from whispy_client import remote, configure
+
+# Optional: enable dep resolution and verbose logging
+configure(deps=True, verbose=True)
+
+requests = remote("requests")
+print(requests.get("https://httpbin.org/get").status_code)
+```
+
+### Self-host
+
+```bash
+# Clone
+git clone https://github.com/Dark-Avenger-Reborn/Whispy
+cd Whispy
+
+# Run with Docker Compose
+docker compose -f deploy/docker-compose.yml up -d
+
+# Point your client at it
+WHISPY_HOST=http://localhost:8000 python my_script.py
+```
+
+### Run server locally (dev)
+
+```bash
+cd server
+pip install -r requirements.txt
+python app.py --debug
+```
+
+---
+
+## Client API
+
+### `remote(package, *, module=None, version=None, deps=False, host=None)`
+
+| Param | Description |
+|-------|-------------|
+| `package` | PyPI name, optionally with `==version` e.g. `"requests==2.31.0"` |
+| `module` | Import name if different from package name (e.g. `module="bs4"`) |
+| `version` | Explicit version, overrides embedded spec |
+| `deps` | If `True`, resolve and fetch transitive dependencies |
+| `host` | Per-call CDN URL override |
+
+**Common name mismatches:**
+```python
+bs4      = remote("beautifulsoup4", module="bs4")
+PIL      = remote("pillow",         module="PIL")
+yaml     = remote("pyyaml",         module="yaml")
+dateutil = remote("python-dateutil",module="dateutil")
+cv2      = remote("opencv-python",  module="cv2")
+```
+
+### `configure(*, host=None, deps=None, verbose=None)`
+
+Set global defaults. Can also use `WHISPY_HOST` env var.
+
+---
+
+## Server API
+
+| Endpoint | Description |
+|----------|-------------|
+| `GET /get_package?name=X&tags=...&version=Y&deps=1` | Download package zip |
+| `GET /metadata/<package>` | Package metadata without download |
+| `GET /health` | Health check + cache stats |
+| `GET /stats` | Cache statistics |
+
+---
+
+## Security
+
+- **SHA-256 verification** — Every file verified against PyPI digests before serving
+- **Blocklist** — Known typosquatted packages are rejected
+- **Input validation** — Package names validated against `[A-Za-z0-9_.-]+`
+- **Rate limiting** — 60 req/min per IP on `/get_package`
+- **HTTPS enforced** — Cloudflare handles TLS termination
+- **Immutable URLs** — Versioned package URLs are `Cache-Control: immutable`
+- **Server never imports packages** — Only proxies/caches them
+
+---
+
+## Deployment
+
+### CI/CD (GitHub Actions)
+
+The `.github/workflows/ci.yml` pipeline:
+
+1. **Test** — server tests + client across Python 3.8–3.13, Linux/macOS/Windows
+2. **Lint** — ruff
+3. **Docker** — builds and pushes to GHCR on every `main` push
+4. **PyPI** — publishes `whispy-client` on version tags (`v*`)
+5. **Cloudflare** — deploys the Worker on `main`
+
+### Required secrets
+
+| Secret | Description |
+|--------|-------------|
+| `CF_API_TOKEN` | Cloudflare API token with Workers:Edit permission |
+
+### Environment vars (server)
+
+| Var | Default | Description |
+|-----|---------|-------------|
+| `WHISPY_CACHE_DIR` | `./cache` | Disk cache directory |
+| `WHISPY_MAX_CACHE_MB` | `2048` | Max cache size in MB |
+| `REDIS_URL` | `memory://` | Redis URL for distributed rate limiting |
+
+---
+
+## Roadmap
+
+- [ ] Conflict-aware dependency resolver (full PubGrub/resolvelib integration)
+- [ ] `whispy lock` CLI — generate a lockfile for reproducible scripts
+- [ ] Browser / Pyodide support
+- [ ] Package usage analytics dashboard
+- [ ] Webhook notifications for new package versions
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+> Packages are sourced from [PyPI](https://pypi.org) and served under their original licenses.
+> Whispy does not host or redistribute package source code — it proxies directly from PyPI's CDN.

whispy_client-1.0.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "whispy-client"
+version = "1.0.0"
+description = "Stream Python packages at runtime — the PyPI CDN client"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.8"
+dependencies = []   # zero runtime dependencies — intentional
+
+keywords = ["cdn", "packages", "dynamic-import", "pypi", "runtime"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: System :: Installation/Setup",
+]
+
+[project.urls]
+Homepage = "https://whispy.dev"
+Repository = "https://github.com/Dark-Avenger-Reborn/Whispy"
+Documentation = "https://whispy.dev/docs"
+"Bug Tracker" = "https://github.com/Dark-Avenger-Reborn/Whispy/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["whispy_client"]

whispy_client-1.0.0/whispy_client/__init__.py

@@ -0,0 +1,12 @@
+"""
+whispy_client — Stream Python packages at runtime, no pip install required.
+
+    from whispy_client import remote
+
+    requests = remote("requests")
+    numpy    = remote("numpy==1.26.4")
+    bs4      = remote("beautifulsoup4", module="bs4", deps=True)
+"""
+from .core import remote, configure, WhispyError, __version__
+
+__all__ = ["remote", "configure", "WhispyError", "__version__"]

whispy_client-1.0.0/whispy_client/core.py

@@ -0,0 +1,305 @@
+"""
+whispy_client — Zero-dependency Python client for the Whispy CDN.
+
+Usage:
+    from whispy_client import remote
+
+    requests = remote("requests")
+    numpy = remote("numpy==1.26.4")
+    bs4 = remote("beautifulsoup4", module="bs4", deps=True)
+"""
+
+from __future__ import annotations
+
+import importlib
+import io
+import json
+import platform
+import re
+import sys
+import tempfile
+import urllib.error
+import urllib.request
+import zipfile
+from typing import Optional
+
+__version__ = "1.0.0"
+__all__ = ["remote", "configure", "WhispyError"]
+
+# ---------------------------------------------------------------------------
+# Default CDN host — users can override via configure() or WHISPY_HOST env var
+# ---------------------------------------------------------------------------
+import os as _os
+_DEFAULT_HOST = _os.environ.get("WHISPY_HOST", "https://cdn.whispy.dev")
+
+_config = {
+    "host": _DEFAULT_HOST,
+    "deps": False,
+    "verbose": False,
+}
+
+# Tracks live TemporaryDirectory objects so they stay alive for the process
+_live_tmpdirs: list[tempfile.TemporaryDirectory] = []
+
+
+class WhispyError(RuntimeError):
+    pass
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def configure(
+    *,
+    host: Optional[str] = None,
+    deps: Optional[bool] = None,
+    verbose: Optional[bool] = None,
+) -> None:
+    """
+    Configure Whispy globally.
+
+    Args:
+        host:    CDN base URL, e.g. "http://localhost:5000" for local dev.
+        deps:    If True, automatically fetch dependencies alongside packages.
+        verbose: If True, print progress messages.
+    """
+    if host is not None:
+        _config["host"] = host.rstrip("/")
+    if deps is not None:
+        _config["deps"] = deps
+    if verbose is not None:
+        _config["verbose"] = verbose
+
+
+def remote(
+    package: str,
+    *,
+    module: Optional[str] = None,
+    version: Optional[str] = None,
+    deps: Optional[bool] = None,
+    host: Optional[str] = None,
+) -> object:
+    """
+    Import a package from the Whispy CDN at runtime.
+
+    Args:
+        package: Package name as on PyPI, optionally with version spec
+                 e.g. "requests" or "requests==2.31.0" or "requests>=2.28"
+        module:  Import name if different from package name.
+                 e.g. remote("beautifulsoup4", module="bs4")
+        version: Explicit version string, overrides any spec in package name.
+        deps:    Fetch dependencies too. Overrides global configure() setting.
+        host:    CDN host override for this call only.
+
+    Returns:
+        The imported module object.
+
+    Example:
+        requests = remote("requests")
+        print(requests.get("https://httpbin.org/get").status_code)
+    """
+    pkg_name, pkg_version = _parse_package_spec(package)
+    resolved_version = version or pkg_version
+    resolved_module = module or pkg_name
+    resolved_host = (host or _config["host"]).rstrip("/")
+    resolved_deps = _config["deps"] if deps is None else deps
+    verbose = _config["verbose"]
+
+    # Return from sys.modules if already loaded
+    if resolved_module in sys.modules:
+        return sys.modules[resolved_module]
+
+    if verbose:
+        print(f"🌀 Whispy: fetching {pkg_name}" + (f"=={resolved_version}" if resolved_version else ""))
+
+    tags = _compute_tags()
+    params = {
+        "name": pkg_name,
+        "tags": ",".join(tags),
+        "deps": "1" if resolved_deps else "0",
+    }
+    if resolved_version:
+        params["version"] = resolved_version
+
+    url = f"{resolved_host}/get_package?" + urllib.parse.urlencode(params)
+
+    try:
+        data = _fetch_bytes(url, verbose=verbose)
+    except urllib.error.HTTPError as e:
+        body = e.read().decode(errors="replace")
+        try:
+            msg = json.loads(body).get("error", body)
+        except Exception:
+            msg = body
+        raise WhispyError(f"Whispy CDN error for '{pkg_name}': {msg}") from e
+    except Exception as e:
+        raise WhispyError(f"Could not reach Whispy CDN at {resolved_host}: {e}") from e
+
+    # Extract into a TemporaryDirectory that lives for the process lifetime
+    tmpdir = tempfile.TemporaryDirectory(prefix="whispy_")
+    _live_tmpdirs.append(tmpdir)
+
+    with zipfile.ZipFile(io.BytesIO(data)) as zf:
+        zf.extractall(tmpdir.name)
+
+    if tmpdir.name not in sys.path:
+        sys.path.insert(0, tmpdir.name)
+
+    if verbose:
+        print(f"✅ Whispy: imported {resolved_module} from {tmpdir.name}")
+
+    try:
+        return importlib.import_module(resolved_module)
+    except ModuleNotFoundError as e:
+        raise WhispyError(
+            f"Package '{pkg_name}' was downloaded but module '{resolved_module}' could not be imported. "
+            f"Try setting module= explicitly. Original error: {e}"
+        ) from e
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+def _parse_package_spec(spec: str) -> tuple[str, Optional[str]]:
+    """
+    Parse "requests==2.31.0" → ("requests", "2.31.0")
+    Parse "requests>=2.28"   → ("requests", None)   (range specs unsupported client-side)
+    Parse "requests"         → ("requests", None)
+    """
+    m = re.match(r'^([A-Za-z0-9_.\-]+)==([A-Za-z0-9._]+)$', spec.strip())
+    if m:
+        return m.group(1), m.group(2)
+    m = re.match(r'^([A-Za-z0-9_.\-]+)', spec.strip())
+    if m:
+        return m.group(1), None
+    raise WhispyError(f"Cannot parse package spec: '{spec}'")
+
+
+def _fetch_bytes(url: str, verbose: bool = False) -> bytes:
+    if verbose:
+        print(f"  → GET {url}")
+    req = urllib.request.Request(
+        url,
+        headers={"User-Agent": f"whispy-client/{__version__} Python/{sys.version.split()[0]}"},
+    )
+    with urllib.request.urlopen(req, timeout=120) as resp:
+        return resp.read()
+
+
+def _compute_tags() -> list[str]:
+    """
+    Generate the ordered list of PEP 425 compatibility tags for this interpreter.
+    Most-specific first (matching pip's own ordering).
+    No external dependencies — pure stdlib.
+    """
+    impl = platform.python_implementation()
+    vi = sys.version_info
+    machine = platform.machine().lower()
+    system = platform.system()
+
+    if impl == "CPython":
+        interp_base = f"cp{vi.major}{vi.minor}"
+        abi_base = f"cp{vi.major}{vi.minor}"
+        abi_tags = [abi_base, "abi3", "none"]
+        interp_tags = [interp_base, f"cp{vi.major}", "py3", f"py{vi.major}{vi.minor}"]
+    elif impl == "PyPy":
+        interp_base = f"pp{vi.major}{vi.minor}"
+        abi_base = f"pypy{vi.major}{vi.minor}"
+        abi_tags = [abi_base, "none"]
+        interp_tags = [interp_base, "py3"]
+    else:
+        interp_base = f"cp{vi.major}{vi.minor}"
+        abi_tags = ["none"]
+        interp_tags = ["py3"]
+
+    platform_tags = _platform_tags(system, machine, vi)
+
+    tags: list[str] = []
+    # Specific tags first (interp + abi + platform)
+    for interp in interp_tags:
+        for abi in abi_tags:
+            for plat in platform_tags:
+                tags.append(f"{interp}-{abi}-{plat}")
+
+    # Pure-python fallbacks
+    for interp in interp_tags:
+        if f"{interp}-none-any" not in tags:
+            tags.append(f"{interp}-none-any")
+    tags.append("py3-none-any")
+
+    # Deduplicate preserving order
+    seen: set[str] = set()
+    result: list[str] = []
+    for t in tags:
+        if t not in seen:
+            seen.add(t)
+            result.append(t)
+    return result
+
+
+def _platform_tags(system: str, machine: str, vi) -> list[str]:
+    if system == "Linux":
+        # Support manylinux + musllinux variants
+        tags = []
+        manylinux_versions = [
+            (2, 35), (2, 34), (2, 33), (2, 32), (2, 31), (2, 30),
+            (2, 29), (2, 28), (2, 27), (2, 26), (2, 17), (2, 12), (2, 5),
+        ]
+        arch_map = {
+            "x86_64": "x86_64",
+            "aarch64": "aarch64",
+            "arm64": "aarch64",
+            "armv7l": "armv7l",
+            "i686": "i686",
+            "ppc64le": "ppc64le",
+            "s390x": "s390x",
+        }
+        arch = arch_map.get(machine, machine)
+        for major, minor in manylinux_versions:
+            tags.append(f"manylinux_{major}_{minor}_{arch}")
+        tags.append(f"manylinux2014_{arch}")
+        tags.append(f"linux_{arch}")
+        return tags
+
+    elif system == "Darwin":
+        # macOS: detect arm64 vs x86_64
+        if machine in ("arm64", "aarch64"):
+            archs = ["arm64", "universal2"]
+        else:
+            archs = ["x86_64", "universal2", "intel"]
+
+        mac_ver = platform.mac_ver()[0]
+        if mac_ver:
+            try:
+                parts = mac_ver.split(".")
+                maj, mn = int(parts[0]), int(parts[1]) if len(parts) > 1 else 0
+            except ValueError:
+                maj, mn = 14, 0
+        else:
+            maj, mn = 14, 0
+
+        tags = []
+        for arch in archs:
+            for minor in range(mn, -1, -1):
+                tags.append(f"macosx_{maj}_{minor}_{arch}")
+            for older_major in range(maj - 1, 9, -1):
+                tags.append(f"macosx_{older_major}_0_{arch}")
+        return tags
+
+    elif system == "Windows":
+        if "64" in machine or machine == "amd64":
+            return ["win_amd64", "win32"]
+        elif "arm" in machine:
+            return ["win_arm64", "win32"]
+        else:
+            return ["win32"]
+
+    return ["any"]
+
+
+# ---------------------------------------------------------------------------
+# urllib.parse needed for _fetch_bytes params
+# ---------------------------------------------------------------------------
+import urllib.parse  # noqa: E402 (already imported via urllib.request chain)