pai-turbox 0.1.1__tar.gz

pai_turbox-0.1.1/MANIFEST.in

@@ -0,0 +1,6 @@
+include installer_backend.py _pai_turbox_loader.py index-url.txt VERSION README.md pyproject.toml setup.py
+exclude releases.json make_index.py
+exclude publish_oss_index.py release-policy.json requirements-publish.txt
+exclude install.py
+recursive-exclude tests *
+recursive-exclude .wheel-cache *

pai_turbox-0.1.1/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: pai-turbox
+Version: 0.1.1
+Summary: Environment-aware installation entry for TurboX binary wheels
+Author: TurboX Team
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-python
+Dynamic: summary
+Dynamic: Requires-Dist
+
+# pai-turbox pip installation and OSS release index
+
+The package name is `pai-turbox`; usage remains `import turbox`, existing console
+commands and `ENABLE_TURBOX=1`. Installation finishes through pip, without a
+second script or first-import binary download. Supported GPU PyTorch must already
+be installed in the active environment.
+
+## Customer installation
+
+```sh
+python -m pip install --no-cache-dir pai-turbox
+```
+
+Install into the active GPU PyTorch environment. The archive contains installation
+code only. Customers do not supply wheel-index or OSS credentials. Its embedded
+public index is:
+
+https://turbox-wlcb.oss-cn-wulanchabu.aliyuncs.com/release/dist/agent/index/releases.json
+
+The installer version is independent of the selected TurboX binary version.
+Existing same-version installations are not automatically replaced when the
+external index changes; see the update and cache rules below.
+
+## Build and installation
+
+The PEP 517 backend inspects the target interpreter's Torch/CUDA/device, reads the
+public index and selects an existing wheel. It verifies the original archive's
+SHA256 and metadata, then builds a pai-turbox wheel owning that binary payload.
+The compiled files stay unchanged under `_pai_turbox_payload/`. A lightweight
+loader exposes them as `turbox` and preserves original startup and license
+checks, without sharing files with an existing native turbox distribution.
+
+Public METADATA, dist-info and wheel filename use pai-turbox and VERSION.
+Original dependencies are resolved alongside exact target Torch and index policy
+constraints. There is no separate turbox distribution dependency. Source metadata
+marks Requires-Dist dynamic. RECORD is rebuilt for all owned files. Selection is
+frozen between metadata generation and wheel generation.
+
+## Publishing an index
+
+Install publisher dependencies from `requirements-publish.txt`, set
+`TURBOX_PUBLISH_ACCESS_KEY_ID` and `TURBOX_PUBLISH_ACCESS_KEY_SECRET` in the release
+job environment, then run:
+
+```sh
+python publish_oss_index.py --output releases.json --publish
+```
+
+The script lists `release/dist/agent/` using a slash delimiter and an additional
+relative-path check. It ignores all subdirectories. New or changed wheels are
+streamed, hashed and checked for ZIP integrity and matching metadata. An anonymous
+HEAD verifies the download address. Unchanged ETag/size/LastModified entries reuse
+previous hashes after public availability is checked. It publishes a versioned
+snapshot and updates releases.json, explicitly sets object public-read ACLs, and
+verifies anonymous readback. It never changes bucket or original wheel ACLs.
+
+`approved` means these index checks passed; it does not claim every runtime
+combination has been qualified. Missing CUDA information is not guessed: special
+filenames remain in the inventory with review_required until explicit mappings
+are supplied through release-policy.json. Dependency constraints and disabled
+artifacts are also policy data, not hardcoded installer version branches.
+
+Run one publishing job at a time. Transport/integrity errors fail the publication
+instead of replacing the working index with a transient partial result. Index
+writes happen only after generation finishes; retain snapshots for rollback.
+Credentials are environment-only and are absent from JSON, tar and normal logs.
+
+To publish a new installation entry after building it:
+
+```sh
+python -m build --sdist
+python publish_oss_index.py --output releases.json --publish \
+  --installer dist/pai_turbox-VERSION.tar.gz
+```
+
+The publisher checks name/version, the embedded default index and absence of
+credentials or business payloads before uploading the source entry. Immutable
+artifact names cannot be overwritten with different bytes. It also writes the
+trailing-slash Simple Index project object that pip actually requests from OSS.
+Increment VERSION for a changed installer release; index-only updates do not need
+a new installer artifact.
+
+## Selection, updates and cache
+
+Match Python/ABI/platform, Torch/CUDA and device; select the highest compatible
+approved stable version, then the latest OSS LastModified within that version.
+Times are normalized to UTC. Pin a version with
+`--config-settings turbox-version=0.2.11`, or an exact build with
+`--config-settings wheel-filename=EXACT_WHEEL_FILENAME`.
+
+Keep `--no-cache-dir` when reselecting an environment-dependent wheel. Standard
+wheel tags do not encode Torch/CUDA/device. A runtime guard rejects a mismatched
+cached binary, but rejection is not automatic cache invalidation. An existing
+same-version pai-turbox is not automatically updated by bare `pip install` merely
+because the JSON changed. Publish new installer release versions for normal
+package-name upgrades. Explicit same-version rebuilds can download/extract the
+source tar and pip-install the local tar, as covered by development verification;
+there is no separate installer script.
+
+References: [OSS object ACL](https://www.alibabacloud.com/help/en/oss/developer-reference/manage-object-acls-1),
+[pip build interface](https://pip.pypa.io/en/stable/reference/build-system/),
+[pip caching](https://pip.pypa.io/en/stable/topics/caching/).

pai_turbox-0.1.1/README.md

@@ -0,0 +1,102 @@
+# pai-turbox pip installation and OSS release index
+
+The package name is `pai-turbox`; usage remains `import turbox`, existing console
+commands and `ENABLE_TURBOX=1`. Installation finishes through pip, without a
+second script or first-import binary download. Supported GPU PyTorch must already
+be installed in the active environment.
+
+## Customer installation
+
+```sh
+python -m pip install --no-cache-dir pai-turbox
+```
+
+Install into the active GPU PyTorch environment. The archive contains installation
+code only. Customers do not supply wheel-index or OSS credentials. Its embedded
+public index is:
+
+https://turbox-wlcb.oss-cn-wulanchabu.aliyuncs.com/release/dist/agent/index/releases.json
+
+The installer version is independent of the selected TurboX binary version.
+Existing same-version installations are not automatically replaced when the
+external index changes; see the update and cache rules below.
+
+## Build and installation
+
+The PEP 517 backend inspects the target interpreter's Torch/CUDA/device, reads the
+public index and selects an existing wheel. It verifies the original archive's
+SHA256 and metadata, then builds a pai-turbox wheel owning that binary payload.
+The compiled files stay unchanged under `_pai_turbox_payload/`. A lightweight
+loader exposes them as `turbox` and preserves original startup and license
+checks, without sharing files with an existing native turbox distribution.
+
+Public METADATA, dist-info and wheel filename use pai-turbox and VERSION.
+Original dependencies are resolved alongside exact target Torch and index policy
+constraints. There is no separate turbox distribution dependency. Source metadata
+marks Requires-Dist dynamic. RECORD is rebuilt for all owned files. Selection is
+frozen between metadata generation and wheel generation.
+
+## Publishing an index
+
+Install publisher dependencies from `requirements-publish.txt`, set
+`TURBOX_PUBLISH_ACCESS_KEY_ID` and `TURBOX_PUBLISH_ACCESS_KEY_SECRET` in the release
+job environment, then run:
+
+```sh
+python publish_oss_index.py --output releases.json --publish
+```
+
+The script lists `release/dist/agent/` using a slash delimiter and an additional
+relative-path check. It ignores all subdirectories. New or changed wheels are
+streamed, hashed and checked for ZIP integrity and matching metadata. An anonymous
+HEAD verifies the download address. Unchanged ETag/size/LastModified entries reuse
+previous hashes after public availability is checked. It publishes a versioned
+snapshot and updates releases.json, explicitly sets object public-read ACLs, and
+verifies anonymous readback. It never changes bucket or original wheel ACLs.
+
+`approved` means these index checks passed; it does not claim every runtime
+combination has been qualified. Missing CUDA information is not guessed: special
+filenames remain in the inventory with review_required until explicit mappings
+are supplied through release-policy.json. Dependency constraints and disabled
+artifacts are also policy data, not hardcoded installer version branches.
+
+Run one publishing job at a time. Transport/integrity errors fail the publication
+instead of replacing the working index with a transient partial result. Index
+writes happen only after generation finishes; retain snapshots for rollback.
+Credentials are environment-only and are absent from JSON, tar and normal logs.
+
+To publish a new installation entry after building it:
+
+```sh
+python -m build --sdist
+python publish_oss_index.py --output releases.json --publish \
+  --installer dist/pai_turbox-VERSION.tar.gz
+```
+
+The publisher checks name/version, the embedded default index and absence of
+credentials or business payloads before uploading the source entry. Immutable
+artifact names cannot be overwritten with different bytes. It also writes the
+trailing-slash Simple Index project object that pip actually requests from OSS.
+Increment VERSION for a changed installer release; index-only updates do not need
+a new installer artifact.
+
+## Selection, updates and cache
+
+Match Python/ABI/platform, Torch/CUDA and device; select the highest compatible
+approved stable version, then the latest OSS LastModified within that version.
+Times are normalized to UTC. Pin a version with
+`--config-settings turbox-version=0.2.11`, or an exact build with
+`--config-settings wheel-filename=EXACT_WHEEL_FILENAME`.
+
+Keep `--no-cache-dir` when reselecting an environment-dependent wheel. Standard
+wheel tags do not encode Torch/CUDA/device. A runtime guard rejects a mismatched
+cached binary, but rejection is not automatic cache invalidation. An existing
+same-version pai-turbox is not automatically updated by bare `pip install` merely
+because the JSON changed. Publish new installer release versions for normal
+package-name upgrades. Explicit same-version rebuilds can download/extract the
+source tar and pip-install the local tar, as covered by development verification;
+there is no separate installer script.
+
+References: [OSS object ACL](https://www.alibabacloud.com/help/en/oss/developer-reference/manage-object-acls-1),
+[pip build interface](https://pip.pypa.io/en/stable/reference/build-system/),
+[pip caching](https://pip.pypa.io/en/stable/topics/caching/).

pai_turbox-0.1.1/VERSION

@@ -0,0 +1 @@
+0.1.1

pai_turbox-0.1.1/_pai_turbox_loader.py

@@ -0,0 +1,43 @@
+"""Expose the binary payload as turbox without sharing another wheel's files."""
+
+import importlib.machinery
+import json
+import os
+from pathlib import Path
+import sys
+
+PAYLOAD = Path(__file__).resolve().parent / "_pai_turbox_payload"
+
+
+class _TurboXFinder:
+    def find_spec(self, fullname, path=None, target=None):
+        if fullname != "turbox" or path is not None:
+            return None
+        # Relocated extensions must have Torch's shared libraries loaded first.
+        # This is deferred until TurboX is actually imported.
+        import torch
+        entry = json.loads((PAYLOAD / "selection.json").read_text())["wheels"][0]
+        device_mismatch = False
+        if torch.cuda.is_available():
+            name = torch.cuda.get_device_name(0)
+            device = "ppu" if name.startswith(("PPU", "ZW-M")) else "nv" if name.startswith(
+                ("NVIDIA", "Tesla", "Quadro", "GeForce")
+            ) else "unknown"
+            device_mismatch = device != entry["device"]
+        if (str(torch.__version__) != entry["torch"]
+                or torch.version.cuda != entry["cuda"] or device_mismatch):
+            raise ImportError(
+                "The installed pai-turbox binary belongs to a different Torch/CUDA/device environment. "
+                "Reinstall the source entry with --no-cache-dir to select a matching binary."
+            )
+        return importlib.machinery.PathFinder.find_spec(fullname, [str(PAYLOAD)])
+
+
+def install():
+    if not any(isinstance(finder, _TurboXFinder) for finder in sys.meta_path):
+        sys.meta_path.insert(0, _TurboXFinder())
+    if str(PAYLOAD) not in sys.path:
+        sys.path.insert(0, str(PAYLOAD))
+    if os.environ.get("ENABLE_TURBOX") == "1":
+        # Preserve the original wheel's startup behavior and license checks.
+        import _turbox_bootstrap  # noqa: F401

pai_turbox-0.1.1/index-url.txt

@@ -0,0 +1 @@
+https://turbox-wlcb.oss-cn-wulanchabu.aliyuncs.com/release/dist/agent/index/releases.json

pai_turbox-0.1.1/installer_backend.py

@@ -0,0 +1,316 @@
+"""PEP 517 adapter selecting original, hash-pinned TurboX binary wheels."""
+
+import json
+import base64
+import csv
+import hashlib
+import io
+import tempfile
+import tarfile
+import zipfile
+from email.parser import BytesParser
+import os
+from pathlib import Path
+import subprocess
+import sys
+import urllib.parse
+import urllib.request
+from datetime import datetime, timezone
+
+from packaging.tags import sys_tags
+from packaging.utils import parse_wheel_filename
+from packaging.version import Version
+from setuptools import build_meta as _backend
+
+ROOT = Path(__file__).resolve().parent
+PROBE = r'''
+import json, platform, sys, torch
+if not torch.cuda.is_available():
+    raise RuntimeError("No available GPU in the target PyTorch environment")
+name = torch.cuda.get_device_name(0)
+if name.startswith(("PPU", "ZW-M")):
+    device = "ppu"
+elif name.startswith(("NVIDIA", "Tesla", "Quadro", "GeForce")):
+    device = "nv"
+else:
+    raise RuntimeError("Unknown GPU family: " + name)
+print("PAI_TURBOX_ENV=" + json.dumps({
+    "torch": str(torch.__version__), "cuda": torch.version.cuda,
+    "device": device, "device_name": name,
+    "python": "cp" + str(sys.version_info.major) + str(sys.version_info.minor),
+    "system": platform.system(), "machine": platform.machine(),
+}))
+'''
+
+
+def detect_environment():
+    # pip's build isolation is sys.path/PYTHONPATH based. -I starts the same
+    # target interpreter without that overlay, so it sees preinstalled torch.
+    env = dict(os.environ, ENABLE_TURBOX="0")
+    env.pop("PYTHONPATH", None)
+    result = subprocess.run(
+        [sys.executable, "-I", "-c", PROBE], env=env, text=True,
+        stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=90,
+    )
+    if result.returncode:
+        raise RuntimeError(
+            "Cannot inspect the target PyTorch environment. Install supported "
+            "GPU PyTorch first. Probe output:\n" + result.stderr[-4000:]
+        )
+    for line in reversed(result.stdout.splitlines()):
+        if line.startswith("PAI_TURBOX_ENV="):
+            return json.loads(line.split("=", 1)[1])
+    raise RuntimeError("Target environment probe returned no environment data")
+
+
+def load_index(location):
+    if not location:
+        raise RuntimeError(
+            "Set TURBOX_WHEEL_INDEX to a release index JSON path or HTTPS URL. "
+            "The installation archive does not contain a frozen support matrix."
+        )
+    if location.startswith("https://"):
+        with urllib.request.urlopen(location, timeout=30) as response:
+            raw = response.read(8 * 1024 * 1024 + 1)
+        if len(raw) > 8 * 1024 * 1024:
+            raise RuntimeError("Release index exceeds 8 MiB")
+        manifest = json.loads(raw)
+    else:
+        if "://" in location:
+            raise RuntimeError("Remote indexes must use HTTPS")
+        manifest = json.loads(Path(location).read_text())
+    if manifest.get("schema_version") != 1:
+        raise RuntimeError("Unsupported release index schema; update the installer")
+    return manifest
+
+
+def modified_time(entry):
+    value = entry.get("last_modified", "")
+    try:
+        result = datetime.fromisoformat(value.replace("Z", "+00:00"))
+        if result.tzinfo is None or result.utcoffset() is None:
+            raise ValueError("timezone missing")
+        return result.astimezone(timezone.utc)
+    except (ValueError, TypeError, AttributeError) as exc:
+        raise RuntimeError(
+            "A timezone-aware last_modified is required to order builds: "
+            + entry["filename"]
+        ) from exc
+
+
+def select_release(manifest, environment, supported_tags=None, requested_version=None,
+                   requested_build=None):
+    tags = set(sys_tags() if supported_tags is None else supported_tags)
+    if environment["system"] != "Linux" or environment["machine"] != "x86_64":
+        raise RuntimeError("Only Linux x86_64 is currently supported")
+    keys = ("cuda", "device", "python")
+    matches = []
+    for entry in manifest["wheels"]:
+        if not entry.get("approved", False):
+            continue
+        if requested_build and entry["filename"] != requested_build:
+            continue
+        if requested_version and Version(Version(entry["version"]).public) != Version(requested_version):
+            continue
+        expected_torch = Version(entry["torch"])
+        actual_torch = Version(environment["torch"])
+        if expected_torch.public != actual_torch.public:
+            continue
+        if expected_torch.local is not None and expected_torch != actual_torch:
+            continue
+        if not all(entry[key] == environment[key] for key in keys):
+            continue
+        name, version, _, wheel_tags = parse_wheel_filename(entry["filename"])
+        if name != "turbox" or str(version) != entry["version"]:
+            raise RuntimeError("Manifest filename and package metadata disagree")
+        if not tags.intersection(wheel_tags):
+            continue
+        digest = entry["sha256"]
+        if len(digest) != 64 or any(c not in "0123456789abcdef" for c in digest):
+            raise RuntimeError("A valid SHA256 is required for every release")
+        url = urllib.parse.urlsplit(entry["url"])
+        if (url.scheme != "https" or not url.hostname or url.username
+                or url.password or url.fragment
+                or urllib.parse.unquote(url.path.rsplit("/", 1)[-1]) != entry["filename"]):
+            raise RuntimeError("A matching HTTPS wheel URL is required")
+        matches.append(entry)
+    # Consider only the highest stable public TurboX release for this exact
+    # environment. A prerelease must be explicitly opted in through the index.
+    matches = [e for e in matches if not Version(e["version"]).is_prerelease
+               or e.get("allow_prerelease", False)]
+    if matches:
+        latest = max(
+            Version(Version(e["version"]).public) for e in matches
+        )
+        matches = [e for e in matches if Version(Version(e["version"]).public) == latest]
+    if len(matches) > 1:
+        newest = max(modified_time(entry) for entry in matches)
+        matches = [entry for entry in matches if modified_time(entry) == newest]
+    if len(matches) != 1:
+        raise RuntimeError(
+            f"Expected one approved TurboX wheel, found {len(matches)} for "
+            + json.dumps(environment, sort_keys=True)
+        )
+    return matches[0]
+
+
+def selected_plan(config_settings=None, prepared=None):
+    settings = config_settings or {}
+    location = (settings.get("wheel-index") or os.environ.get("TURBOX_WHEEL_INDEX")
+                or (ROOT / "index-url.txt").read_text().strip())
+    manifest = prepared if prepared is not None else load_index(location)
+    environment = detect_environment()
+    entry = select_release(
+        manifest, environment,
+        requested_version=settings.get("turbox-version") or os.environ.get("TURBOX_VERSION"),
+        requested_build=settings.get("wheel-filename") or os.environ.get("TURBOX_WHEEL_FILENAME"),
+    )
+    print("[pai-turbox] Selected " + entry["filename"], flush=True)
+    return {"schema_version": 1, "wheels": [dict(entry, torch=environment["torch"])]}
+
+
+def download_wheel(entry):
+    cache = ROOT / ".wheel-cache"
+    cache.mkdir(exist_ok=True)
+    path = cache / entry["filename"]
+    if path.is_file() and hashlib.sha256(path.read_bytes()).hexdigest() == entry["sha256"]:
+        return path
+    with tempfile.NamedTemporaryFile(dir=cache, delete=False) as output:
+        temporary = Path(output.name)
+        try:
+            digest = hashlib.sha256()
+            with urllib.request.urlopen(entry["url"], timeout=60) as response:
+                while True:
+                    chunk = response.read(1024 * 1024)
+                    if not chunk:
+                        break
+                    digest.update(chunk)
+                    output.write(chunk)
+            output.close()
+            if digest.hexdigest() != entry["sha256"]:
+                raise RuntimeError("Downloaded TurboX wheel SHA256 mismatch")
+            temporary.replace(path)
+        finally:
+            temporary.unlink(missing_ok=True)
+    return path
+
+
+def public_metadata():
+    with tempfile.TemporaryDirectory() as directory:
+        name = _backend.prepare_metadata_for_build_wheel(directory)
+        return (Path(directory) / name / "METADATA").read_bytes()
+
+
+def package_files(plan):
+    entry = plan["wheels"][0]
+    archive = download_wheel(entry)
+    public_version = (ROOT / "VERSION").read_text().strip()
+    destination = "pai_turbox-" + public_version + ".dist-info"
+    output = {}
+    with zipfile.ZipFile(archive) as wheel:
+        metadata_paths = [n for n in wheel.namelist() if n.endswith(".dist-info/METADATA")]
+        if len(metadata_paths) != 1:
+            raise RuntimeError("Expected one original wheel METADATA")
+        origin = metadata_paths[0].rsplit("/", 1)[0]
+        original = BytesParser().parsebytes(wheel.read(metadata_paths[0]))
+        if original["Name"] != "turbox" or original["Version"] != entry["version"]:
+            raise RuntimeError("Downloaded wheel metadata differs from selected release")
+        message = BytesParser().parsebytes(public_metadata())
+        if message["Name"] != "pai-turbox" or message["Version"] != public_version:
+            raise RuntimeError("Source entry metadata differs from public package name/version")
+        # The public distribution owns the binary payload; no turbox dependency.
+        for requirement in original.get_all("Requires-Dist", []):
+            message["Requires-Dist"] = requirement
+        message["Requires-Dist"] = "torch==" + entry["torch"]
+        for requirement in entry.get("extra_requires", []):
+            message["Requires-Dist"] = requirement
+        for name in wheel.namelist():
+            if name.endswith("/"):
+                continue
+            parts = Path(name).parts
+            if name.startswith("/") or ".." in parts or ".data" in parts[0]:
+                raise RuntimeError("Unsupported original wheel installation path: " + name)
+            if name.startswith(origin + "/"):
+                relative = name[len(origin) + 1:]
+                if relative in ("RECORD", "RECORD.jws", "RECORD.p7s"):
+                    continue
+                output[destination + "/" + relative] = wheel.read(name)
+            else:
+                output["_pai_turbox_payload/" + name] = wheel.read(name)
+        output[destination + "/METADATA"] = message.as_bytes()
+    snapshot = json.dumps(plan, sort_keys=True).encode()
+    output[destination + "/turbox-selection.json"] = snapshot
+    output["_pai_turbox_payload/selection.json"] = snapshot
+    output["_pai_turbox_loader.py"] = (ROOT / "_pai_turbox_loader.py").read_bytes()
+    output["000_pai_turbox.pth"] = b"import _pai_turbox_loader; _pai_turbox_loader.install()\n"
+    return destination, output
+
+
+def get_requires_for_build_wheel(config_settings=None):
+    return []
+
+
+def get_requires_for_build_sdist(config_settings=None):
+    return []
+
+
+def prepare_metadata_for_build_wheel(metadata_directory, config_settings=None):
+    plan = selected_plan(config_settings)
+    destination, files = package_files(plan)
+    root = Path(metadata_directory)
+    for name, data in files.items():
+        if name.startswith(destination + "/"):
+            path = root / name
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_bytes(data)
+    return destination
+
+
+def build_wheel(wheel_directory, config_settings=None, metadata_directory=None):
+    snapshot = Path(metadata_directory) / "turbox-selection.json" if metadata_directory else None
+    prepared = json.loads(snapshot.read_text()) if snapshot and snapshot.is_file() else None
+    plan = selected_plan(config_settings, prepared)
+    destination, files = package_files(plan)
+    if metadata_directory:
+        # Preserve every metadata byte prepared for pip's dependency resolver.
+        for path in Path(metadata_directory).rglob("*"):
+            if path.is_file() and path.name != "RECORD":
+                files[destination + "/" + path.relative_to(metadata_directory).as_posix()] = path.read_bytes()
+    rows = []
+    for name, data in sorted(files.items()):
+        digest = base64.urlsafe_b64encode(hashlib.sha256(data).digest()).rstrip(b"=").decode()
+        rows.append((name, "sha256=" + digest, str(len(data))))
+    record = destination + "/RECORD"
+    rows.append((record, "", ""))
+    stream = io.StringIO(newline="")
+    csv.writer(stream).writerows(rows)
+    files[record] = stream.getvalue().encode()
+    tags = plan["wheels"][0]["filename"].rsplit("-", 3)[-3:]
+    version = (ROOT / "VERSION").read_text().strip()
+    filename = "pai_turbox-" + version + "-" + "-".join(tags)
+    Path(wheel_directory).mkdir(parents=True, exist_ok=True)
+    with zipfile.ZipFile(Path(wheel_directory) / filename, "w", zipfile.ZIP_DEFLATED) as wheel:
+        for name, data in files.items():
+            wheel.writestr(name, data)
+    return filename
+
+
+def build_sdist(sdist_directory, config_settings=None):
+    name = _backend.build_sdist(sdist_directory, config_settings)
+    archive = Path(sdist_directory) / name
+    temporary = archive.with_suffix(".tmp")
+    # PEP 643: dependencies are generated from the selected binary on the target.
+    # All other public metadata remains the source entry's static metadata.
+    with tarfile.open(archive, "r:gz") as source, tarfile.open(temporary, "w:gz") as target:
+        for member in source:
+            data = source.extractfile(member) if member.isfile() else None
+            if data is not None and member.name.endswith("/PKG-INFO"):
+                message = BytesParser().parsebytes(data.read())
+                if "requires-dist" not in [x.lower() for x in message.get_all("Dynamic", [])]:
+                    message["Dynamic"] = "Requires-Dist"
+                raw = message.as_bytes()
+                member.size = len(raw)
+                data = io.BytesIO(raw)
+            target.addfile(member, data)
+    temporary.replace(archive)
+    return name

pai_turbox-0.1.1/pai_turbox.egg-info/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: pai-turbox
+Version: 0.1.1
+Summary: Environment-aware installation entry for TurboX binary wheels
+Author: TurboX Team
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-python
+Dynamic: summary
+Dynamic: Requires-Dist
+
+# pai-turbox pip installation and OSS release index
+
+The package name is `pai-turbox`; usage remains `import turbox`, existing console
+commands and `ENABLE_TURBOX=1`. Installation finishes through pip, without a
+second script or first-import binary download. Supported GPU PyTorch must already
+be installed in the active environment.
+
+## Customer installation
+
+```sh
+python -m pip install --no-cache-dir pai-turbox
+```
+
+Install into the active GPU PyTorch environment. The archive contains installation
+code only. Customers do not supply wheel-index or OSS credentials. Its embedded
+public index is:
+
+https://turbox-wlcb.oss-cn-wulanchabu.aliyuncs.com/release/dist/agent/index/releases.json
+
+The installer version is independent of the selected TurboX binary version.
+Existing same-version installations are not automatically replaced when the
+external index changes; see the update and cache rules below.
+
+## Build and installation
+
+The PEP 517 backend inspects the target interpreter's Torch/CUDA/device, reads the
+public index and selects an existing wheel. It verifies the original archive's
+SHA256 and metadata, then builds a pai-turbox wheel owning that binary payload.
+The compiled files stay unchanged under `_pai_turbox_payload/`. A lightweight
+loader exposes them as `turbox` and preserves original startup and license
+checks, without sharing files with an existing native turbox distribution.
+
+Public METADATA, dist-info and wheel filename use pai-turbox and VERSION.
+Original dependencies are resolved alongside exact target Torch and index policy
+constraints. There is no separate turbox distribution dependency. Source metadata
+marks Requires-Dist dynamic. RECORD is rebuilt for all owned files. Selection is
+frozen between metadata generation and wheel generation.
+
+## Publishing an index
+
+Install publisher dependencies from `requirements-publish.txt`, set
+`TURBOX_PUBLISH_ACCESS_KEY_ID` and `TURBOX_PUBLISH_ACCESS_KEY_SECRET` in the release
+job environment, then run:
+
+```sh
+python publish_oss_index.py --output releases.json --publish
+```
+
+The script lists `release/dist/agent/` using a slash delimiter and an additional
+relative-path check. It ignores all subdirectories. New or changed wheels are
+streamed, hashed and checked for ZIP integrity and matching metadata. An anonymous
+HEAD verifies the download address. Unchanged ETag/size/LastModified entries reuse
+previous hashes after public availability is checked. It publishes a versioned
+snapshot and updates releases.json, explicitly sets object public-read ACLs, and
+verifies anonymous readback. It never changes bucket or original wheel ACLs.
+
+`approved` means these index checks passed; it does not claim every runtime
+combination has been qualified. Missing CUDA information is not guessed: special
+filenames remain in the inventory with review_required until explicit mappings
+are supplied through release-policy.json. Dependency constraints and disabled
+artifacts are also policy data, not hardcoded installer version branches.
+
+Run one publishing job at a time. Transport/integrity errors fail the publication
+instead of replacing the working index with a transient partial result. Index
+writes happen only after generation finishes; retain snapshots for rollback.
+Credentials are environment-only and are absent from JSON, tar and normal logs.
+
+To publish a new installation entry after building it:
+
+```sh
+python -m build --sdist
+python publish_oss_index.py --output releases.json --publish \
+  --installer dist/pai_turbox-VERSION.tar.gz
+```
+
+The publisher checks name/version, the embedded default index and absence of
+credentials or business payloads before uploading the source entry. Immutable
+artifact names cannot be overwritten with different bytes. It also writes the
+trailing-slash Simple Index project object that pip actually requests from OSS.
+Increment VERSION for a changed installer release; index-only updates do not need
+a new installer artifact.
+
+## Selection, updates and cache
+
+Match Python/ABI/platform, Torch/CUDA and device; select the highest compatible
+approved stable version, then the latest OSS LastModified within that version.
+Times are normalized to UTC. Pin a version with
+`--config-settings turbox-version=0.2.11`, or an exact build with
+`--config-settings wheel-filename=EXACT_WHEEL_FILENAME`.
+
+Keep `--no-cache-dir` when reselecting an environment-dependent wheel. Standard
+wheel tags do not encode Torch/CUDA/device. A runtime guard rejects a mismatched
+cached binary, but rejection is not automatic cache invalidation. An existing
+same-version pai-turbox is not automatically updated by bare `pip install` merely
+because the JSON changed. Publish new installer release versions for normal
+package-name upgrades. Explicit same-version rebuilds can download/extract the
+source tar and pip-install the local tar, as covered by development verification;
+there is no separate installer script.
+
+References: [OSS object ACL](https://www.alibabacloud.com/help/en/oss/developer-reference/manage-object-acls-1),
+[pip build interface](https://pip.pypa.io/en/stable/reference/build-system/),
+[pip caching](https://pip.pypa.io/en/stable/topics/caching/).

pai_turbox-0.1.1/pai_turbox.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+MANIFEST.in
+README.md
+VERSION
+_pai_turbox_loader.py
+index-url.txt
+installer_backend.py
+pyproject.toml
+setup.py
+pai_turbox.egg-info/PKG-INFO
+pai_turbox.egg-info/SOURCES.txt
+pai_turbox.egg-info/dependency_links.txt
+pai_turbox.egg-info/top_level.txt

pai_turbox-0.1.1/pai_turbox.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pai_turbox-0.1.1/pai_turbox.egg-info/top_level.txt

@@ -0,0 +1 @@
+

pai_turbox-0.1.1/pyproject.toml

@@ -0,0 +1,4 @@
+[build-system]
+requires = ["setuptools>=68", "wheel", "packaging>=24"]
+build-backend = "installer_backend"
+backend-path = ["."]

pai_turbox-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pai_turbox-0.1.1/setup.py

@@ -0,0 +1,19 @@
+"""Build the public installation entry, never TurboX business sources."""
+from pathlib import Path
+
+from setuptools import setup
+
+ROOT = Path(__file__).resolve().parent
+setup(
+    name="pai-turbox",
+    version=(ROOT / "VERSION").read_text().strip(),
+    description="Environment-aware installation entry for TurboX binary wheels",
+    long_description=(ROOT / "README.md").read_text(),
+    long_description_content_type="text/markdown",
+    author="TurboX Team",
+    python_requires=">=3.8",
+    packages=[],
+    py_modules=[],
+    install_requires=[],
+    classifiers=["Operating System :: POSIX :: Linux"],
+)