From e0fcadf32da7472c994ce2b95a8daa76158ad266 Mon Sep 17 00:00:00 2001 From: YeonwooSung Date: Fri, 9 Oct 2026 21:48:30 +0900 Subject: [PATCH 01/13] fix(server): constrain bundle image installs to uv.lock Pin ranged bundle dependencies to the versions in uv.lock when images install /app/bundle-libs. Exact bundle specs still override the lock. Refs #377 --- packages/sie_server/Dockerfile.cpu | 15 ++- packages/sie_server/Dockerfile.cuda12 | 16 ++- packages/sie_server/Dockerfile.cuda13 | 15 ++- .../src/sie_server/bundle_requirements.py | 120 +++++++++++++++++- packages/sie_server/src/sie_server/cli.py | 27 ++++ .../tests/core/test_bundle_requirements.py | 84 ++++++++++++ tools/ci/tests/test_docker_task.py | 38 ++++++ 7 files changed, 307 insertions(+), 8 deletions(-) diff --git a/packages/sie_server/Dockerfile.cpu b/packages/sie_server/Dockerfile.cpu index a6db66a2e..25d3d7e75 100644 --- a/packages/sie_server/Dockerfile.cpu +++ b/packages/sie_server/Dockerfile.cpu @@ -129,13 +129,20 @@ FROM base AS builder ARG BUNDLE +# Ranged bundle deps are constrained to uv.lock. Exact pins and URL/VCS specs stay overrides. +COPY uv.lock /tmp/uv.lock + RUN .venv/bin/python -m sie_server.cli resolve-deps \ --bundle "${BUNDLE}" \ --models-dir models \ --cpu \ + --lock /tmp/uv.lock \ + --constraints-output /tmp/bundle-constraints.txt \ > /tmp/bundle-requirements.txt \ && echo "Bundle ${BUNDLE} requirements:" \ - && cat /tmp/bundle-requirements.txt + && cat /tmp/bundle-requirements.txt \ + && echo "Bundle ${BUNDLE} lock constraints:" \ + && cat /tmp/bundle-constraints.txt # Bundle-specific deps land in a separate site-packages tree so the shared # venv layer stays byte-identical across bundles of the same platform. @@ -149,6 +156,7 @@ RUN --mount=type=cache,target=/root/.cache/pip \ --extra-index-url https://pypi.org/simple \ --target=/app/bundle-libs \ --no-compile \ + -c /tmp/bundle-constraints.txt \ -r /tmp/bundle-requirements.txt; \ fi @@ -163,7 +171,9 @@ RUN set -eux; \ rm -rf torch/test torch/utils/tensorboard torch/utils/bottleneck 2>/dev/null || true; \ find torch -type f -name '*.a' -delete 2>/dev/null || true; \ fi; \ - find /app/bundle-libs -exec touch -h -d @0 {} + 2>/dev/null || true + find /app/bundle-libs -exec touch -h -d @0 {} + 2>/dev/null || true; \ + /app/.venv/bin/pip freeze --path /app/bundle-libs > /app/bundle-libs-freeze.txt; \ + touch -d @0 /app/bundle-libs-freeze.txt # ============================================================================= # Runtime image @@ -219,6 +229,7 @@ COPY --link --from=base --chown=1000:1000 /app/models /app/models COPY --link --from=base --chown=1000:1000 /app/bundles /app/bundles # Bundle-specific extras — last layer so shared layers above stay cached. COPY --link --from=builder --chown=1000:1000 /app/bundle-libs /app/bundle-libs +COPY --link --from=builder --chown=1000:1000 /app/bundle-libs-freeze.txt /app/bundle-libs-freeze.txt RUN mkdir -p /app/evals /app/.cache/huggingface && chown -R sie:sie /app/evals /app/.cache diff --git a/packages/sie_server/Dockerfile.cuda12 b/packages/sie_server/Dockerfile.cuda12 index ab46ac2da..4d04661f2 100644 --- a/packages/sie_server/Dockerfile.cuda12 +++ b/packages/sie_server/Dockerfile.cuda12 @@ -148,12 +148,19 @@ FROM base AS builder ARG BUNDLE +# Ranged bundle deps are constrained to uv.lock. Exact pins and URL/VCS specs stay overrides. +COPY uv.lock /tmp/uv.lock + RUN .venv/bin/python -m sie_server.cli resolve-deps \ --bundle "${BUNDLE}" \ --models-dir models \ + --lock /tmp/uv.lock \ + --constraints-output /tmp/bundle-constraints.txt \ > /tmp/bundle-requirements.txt \ && echo "Bundle ${BUNDLE} requirements:" \ - && cat /tmp/bundle-requirements.txt + && cat /tmp/bundle-requirements.txt \ + && echo "Bundle ${BUNDLE} lock constraints:" \ + && cat /tmp/bundle-constraints.txt # Bundle-specific deps go into a separate site-packages tree (``bundle-libs``, # prepended to sys.path via a .pth) so the shared venv layer stays @@ -177,11 +184,13 @@ RUN --mount=type=cache,target=/root/.cache/pip \ --target=/app/bundle-libs \ --no-compile \ --extra-index-url https://docs.sglang.ai/whl/cu129/ \ + -c /tmp/bundle-constraints.txt \ -r /tmp/bundle-requirements.txt ;; \ *) \ .venv/bin/pip install \ --target=/app/bundle-libs \ --no-compile \ + -c /tmp/bundle-constraints.txt \ -r /tmp/bundle-requirements.txt ;; \ esac; \ fi @@ -201,7 +210,9 @@ RUN set -eux; \ find nvidia -type f -name '*.a' -delete 2>/dev/null || true; \ fi; \ # Normalize mtimes so rebuilds of the same bundle produce identical layer bytes. - find /app/bundle-libs -exec touch -h -d @0 {} + 2>/dev/null || true + find /app/bundle-libs -exec touch -h -d @0 {} + 2>/dev/null || true; \ + /app/.venv/bin/pip freeze --path /app/bundle-libs > /app/bundle-libs-freeze.txt; \ + touch -d @0 /app/bundle-libs-freeze.txt # ============================================================================= # Runtime image @@ -307,6 +318,7 @@ COPY --link --from=base --chown=1000:1000 /app/bundles /app/bundles # Bundle-specific extras — last layer so shared layers above stay cached. # A `.pth` file in the shared venv puts /app/bundle-libs at sys.path[0] at startup. COPY --link --from=builder --chown=1000:1000 /app/bundle-libs /app/bundle-libs +COPY --link --from=builder --chown=1000:1000 /app/bundle-libs-freeze.txt /app/bundle-libs-freeze.txt RUN mkdir -p /app/evals /app/.cache/huggingface /app/.cache/sie-kernels \ && chown -R sie:sie /app/evals /app/.cache diff --git a/packages/sie_server/Dockerfile.cuda13 b/packages/sie_server/Dockerfile.cuda13 index e9d8d6b13..0e9d97e8b 100644 --- a/packages/sie_server/Dockerfile.cuda13 +++ b/packages/sie_server/Dockerfile.cuda13 @@ -148,12 +148,19 @@ FROM base AS builder ARG BUNDLE +# Ranged bundle deps are constrained to uv.lock. Exact pins and URL/VCS specs stay overrides. +COPY uv.lock /tmp/uv.lock + RUN .venv/bin/python -m sie_server.cli resolve-deps \ --bundle "${BUNDLE}" \ --models-dir models \ + --lock /tmp/uv.lock \ + --constraints-output /tmp/bundle-constraints.txt \ > /tmp/bundle-requirements.txt \ && echo "Bundle ${BUNDLE} requirements:" \ - && cat /tmp/bundle-requirements.txt + && cat /tmp/bundle-requirements.txt \ + && echo "Bundle ${BUNDLE} lock constraints:" \ + && cat /tmp/bundle-constraints.txt # cu130 bundle deps go into a separate site-packages tree (``bundle-libs``, # prepended to sys.path via the .pth above). CUDA 13 engines need torch 2.11 @@ -191,6 +198,7 @@ RUN --mount=type=cache,target=/root/.cache/pip \ --prerelease=allow \ --extra-index-url https://download.pytorch.org/whl/cu130 \ --extra-index-url https://docs.sglang.ai/whl/cu130/ \ + --constraint /tmp/bundle-constraints.txt \ -r /tmp/bundle-requirements.txt ; \ fi @@ -206,7 +214,9 @@ RUN set -eux; \ find torch -type f -name '*.a' -delete 2>/dev/null || true; \ find nvidia -type f -name '*.a' -delete 2>/dev/null || true; \ fi; \ - find /app/bundle-libs -exec touch -h -d @0 {} + 2>/dev/null || true + find /app/bundle-libs -exec touch -h -d @0 {} + 2>/dev/null || true; \ + /app/.venv/bin/pip freeze --path /app/bundle-libs > /app/bundle-libs-freeze.txt; \ + touch -d @0 /app/bundle-libs-freeze.txt # ============================================================================= # Runtime image (CUDA 13 devel — nvcc for flashinfer/tvm_ffi first-decode JIT) @@ -272,6 +282,7 @@ COPY --link --from=base --chown=1000:1000 /app/models /app/models COPY --link --from=base --chown=1000:1000 /app/bundles /app/bundles # Bundle-specific extras — last layer so shared layers above stay cached. COPY --link --from=builder --chown=1000:1000 /app/bundle-libs /app/bundle-libs +COPY --link --from=builder --chown=1000:1000 /app/bundle-libs-freeze.txt /app/bundle-libs-freeze.txt RUN mkdir -p /app/evals /app/.cache/huggingface /app/.cache/sie-kernels \ && chown -R sie:sie /app/evals /app/.cache diff --git a/packages/sie_server/src/sie_server/bundle_requirements.py b/packages/sie_server/src/sie_server/bundle_requirements.py index 4f329db9c..14c1136ce 100644 --- a/packages/sie_server/src/sie_server/bundle_requirements.py +++ b/packages/sie_server/src/sie_server/bundle_requirements.py @@ -7,11 +7,21 @@ from __future__ import annotations import re -from collections.abc import Mapping +import tomllib +from collections.abc import Mapping, Sequence from hashlib import sha256 +from pathlib import Path from typing import cast +from packaging.requirements import Requirement +from packaging.version import InvalidVersion, Version + _CUDA_ONLY_PACKAGES = frozenset({"fla-core", "flash-attn", "xformers"}) +_EXACT_OPERATORS = frozenset({"==", "==="}) + + +def _normalize_package_name(name: str) -> str: + return re.sub(r"[-_.]+", "-", name).lower() def resolve_bundle_requirements( @@ -22,7 +32,7 @@ def resolve_bundle_requirements( """Convert a bundle ``deps`` mapping into canonical PEP 508 strings.""" requirements: list[str] = [] for package, constraint in bundle_deps.items(): - normalized = re.sub(r"[-_.]+", "-", package.lower()) + normalized = _normalize_package_name(package) if exclude_cuda and normalized in _CUDA_ONLY_PACKAGES: continue @@ -58,3 +68,109 @@ def bundle_requirements_sha256(bundle_deps: Mapping[str, object]) -> str: """Hash the exact normalized requirement payload baked by worker images.""" payload = "\n".join(normalized_bundle_requirements(bundle_deps)).encode() return sha256(payload).hexdigest() + + +def locked_versions_from_uv_lock(source: str | Path) -> dict[str, str]: + """Return locked constraint versions keyed by normalized package name. + + One lock entry becomes that exact version string. Several entries that + share a public version (``torch`` ``2.9.1`` and ``2.9.1+cu129``) become a + prefix match, ``2.9.1.*``, so each locked build matches and a newer + release does not. Distinct public versions are an error. + """ + text = source.read_text(encoding="utf-8") if isinstance(source, Path) else source + try: + data = tomllib.loads(text) + except tomllib.TOMLDecodeError as exc: + msg = f"invalid uv.lock: {exc}" + raise ValueError(msg) from exc + packages = data.get("package", []) + if not isinstance(packages, list): + msg = "uv.lock package table is not a list" + raise ValueError(msg) + + found: dict[str, set[str]] = {} + for package in packages: + if not isinstance(package, dict): + continue + name = package.get("name") + version = package.get("version") + if not isinstance(name, str) or not isinstance(version, str): + continue + found.setdefault(_normalize_package_name(name), set()).add(version) + + return {name: _constraint_version(name, versions) for name, versions in found.items()} + + +def merge_locked_requirements(requirements: Sequence[str], locked_versions: Mapping[str, str]) -> list[str]: + """Pin ranged requirements to the lock unless the bundle spec overrides it. + + Exact ``==`` / ``===`` pins and URL or VCS specs are returned unchanged. + A range is rewritten only when a locked version still satisfies it, so a + bundle can deliberately move off the lock (transformers 5 versus a 4.x + pin) without an unsatisfiable constraint. Packages missing from the lock + stay as written. + """ + merged: list[str] = [] + for requirement in requirements: + parsed = Requirement(requirement) + if _is_bundle_override(parsed): + merged.append(requirement) + continue + pinned = locked_versions.get(_normalize_package_name(parsed.name)) + if pinned is None or not _locked_constraint_satisfies(parsed, pinned): + merged.append(requirement) + continue + merged.append(_format_locked_requirement(requirement, parsed, pinned)) + return merged + + +def lock_constraint_lines(requirements: Sequence[str], locked_versions: Mapping[str, str]) -> list[str]: + """Return only the lock pins a constraints file should add.""" + merged = merge_locked_requirements(requirements, locked_versions) + return [updated for original, updated in zip(requirements, merged, strict=True) if updated != original] + + +def _constraint_version(name: str, versions: set[str]) -> str: + if len(versions) == 1: + return next(iter(versions)) + try: + public_versions = {Version(version).public for version in versions} + except InvalidVersion as exc: + msg = f"uv.lock pins {name} to an invalid version" + raise ValueError(msg) from exc + if len(public_versions) != 1: + joined = ", ".join(sorted(versions)) + msg = f"uv.lock pins {name} to multiple public versions: {joined}" + raise ValueError(msg) + return f"{next(iter(public_versions))}.*" + + +def _locked_constraint_satisfies(requirement: Requirement, constraint: str) -> bool: + """A prefix pin is usable when its public version is inside the bundle spec.""" + candidate = constraint.removesuffix(".*") if constraint.endswith(".*") else constraint + try: + version = Version(candidate) + except InvalidVersion: + return False + return requirement.specifier.contains(version, prereleases=True) + + +def _is_bundle_override(requirement: Requirement) -> bool: + """Exact pins and direct URL/VCS references are deliberate bundle overrides.""" + if requirement.url is not None: + return True + specs = list(requirement.specifier) + if len(specs) != 1: + return False + spec = specs[0] + return spec.operator in _EXACT_OPERATORS and not spec.version.endswith(".*") + + +def _format_locked_requirement(raw: str, requirement: Requirement, version: str) -> str: + extras = f"[{','.join(sorted(requirement.extras))}]" if requirement.extras else "" + pinned = f"{requirement.name}{extras}=={version}" + if requirement.marker is None: + return pinned + marker = raw.split(";", maxsplit=1)[1].strip() + return f"{pinned} ; {marker}" diff --git a/packages/sie_server/src/sie_server/cli.py b/packages/sie_server/src/sie_server/cli.py index 4d874f0e8..1ec0d65d1 100644 --- a/packages/sie_server/src/sie_server/cli.py +++ b/packages/sie_server/src/sie_server/cli.py @@ -207,6 +207,12 @@ def resolve_deps( models_dir: str = typer.Option(DEFAULT_MODELS_DIR, "--models-dir", help="Models directory"), output_json: bool = typer.Option(False, "--json", help="Output as JSON"), cpu: bool = typer.Option(False, "--cpu", help="Exclude CUDA-only dependencies (flash-attn)"), + lock: Path | None = typer.Option(None, "--lock", help="uv.lock used to pin ranged bundle dependencies"), # noqa: B008 + constraints_output: Path | None = typer.Option( # noqa: B008 + None, + "--constraints-output", + help="Write lock constraints for ranged dependencies to this file", + ), ) -> None: """Resolve and print dependencies for a bundle or model list. @@ -215,9 +221,21 @@ def resolve_deps( Use --cpu flag when building CPU-only images to exclude flash-attn and other CUDA-only dependencies. + + ``--lock`` and ``--constraints-output`` together write a constraints file + that pins ranged dependencies to ``uv.lock``. Exact pins and URL/VCS specs + are not tightened. Stdout stays the bundle requirements. """ + from sie_server.bundle_requirements import lock_constraint_lines, locked_versions_from_uv_lock from sie_server.core.deps import collect_bundle_deps + if (lock is None) != (constraints_output is None): + typer.echo("Error: --lock and --constraints-output must be used together", err=True) + raise typer.Exit(1) + if output_json and constraints_output is not None: + typer.echo("Error: --constraints-output cannot be combined with --json", err=True) + raise typer.Exit(1) + models_path = Path(models_dir).resolve() bundles_dir = _DEFAULT_BUNDLES_DIR pool_name = os.environ.get(ENV_POOL) or None @@ -254,6 +272,15 @@ def resolve_deps( typer.echo(f" - {conflict}", err=True) raise typer.Exit(1) + if constraints_output is not None and lock is not None: + try: + locked = locked_versions_from_uv_lock(lock) + except (OSError, ValueError) as exc: + typer.echo(f"Error: {exc}", err=True) + raise typer.Exit(1) from exc + body = "\n".join(lock_constraint_lines(result.requirements, locked)) + constraints_output.write_text(f"{body}\n" if body else "", encoding="utf-8") + if output_json: import json diff --git a/packages/sie_server/tests/core/test_bundle_requirements.py b/packages/sie_server/tests/core/test_bundle_requirements.py index 6a1d8b2f9..ea1eb44ca 100644 --- a/packages/sie_server/tests/core/test_bundle_requirements.py +++ b/packages/sie_server/tests/core/test_bundle_requirements.py @@ -1,11 +1,20 @@ from __future__ import annotations +from pathlib import Path + +import yaml from sie_server.bundle_requirements import ( bundle_requirements_sha256, + lock_constraint_lines, + locked_versions_from_uv_lock, + merge_locked_requirements, normalized_bundle_requirements, resolve_bundle_requirements, ) +_REPO_ROOT = Path(__file__).resolve().parents[4] +_BUNDLES = _REPO_ROOT / "packages" / "sie_server" / "bundles" + def test_resolve_bundle_requirements_preserves_cli_semantics() -> None: assert resolve_bundle_requirements( @@ -38,3 +47,78 @@ def test_release_pin_normalization_is_sorted_and_marker_free() -> None: assert normalized_bundle_requirements(deps) == ["a-first==1", "z-last==2"] assert bundle_requirements_sha256(deps) == "d2ccdab8db5e0df55e2b47ae7c7a8f4c9b7623bd42fb7c09f028114ed3aba884" + + +def _bundle_requirements(name: str) -> list[str]: + bundle = yaml.safe_load((_BUNDLES / f"{name}.yaml").read_text()) + return resolve_bundle_requirements(bundle["deps"]) + + +def test_default_bundle_ranges_pin_to_uv_lock_versions() -> None: + locked = locked_versions_from_uv_lock(_REPO_ROOT / "uv.lock") + original = _bundle_requirements("default") + merged = merge_locked_requirements(original, locked) + + assert "gliner>=0.2.26,<1" in original + assert f"gliner=={locked['gliner']}" in merged + assert locked["gliner"] == "0.2.26" + assert "gliner>=0.2.26,<1" not in merged + assert f"torch=={locked['torch']}" in merged + assert f"requests=={locked['requests']}" in merged + + +def test_exact_pins_and_url_specs_override_the_lock() -> None: + locked = locked_versions_from_uv_lock(_REPO_ROOT / "uv.lock") + original = _bundle_requirements("transformers5") + merged = merge_locked_requirements(original, locked) + url_specs = [requirement for requirement in original if " @" in requirement] + + assert url_specs + assert locked["gliner2"] == "1.3.2" + assert "gliner2==2.0.0" in merged + assert "torchvision==0.24.1" in merged + assert locked["torchvision"] != "0.24.1" + for requirement in url_specs: + assert requirement in merged + # Ranges that do not contain the locked version stay as written. + assert "transformers>=5.14,<6" in merged + assert "sentence-transformers>=5.6,<6" in merged + constraints = lock_constraint_lines(original, locked) + assert "gliner2==2.0.0" not in constraints + assert "torchvision==0.24.1" not in constraints + assert all(" @" not in line for line in constraints) + assert "transformers==4.57.6" not in constraints + + +def test_merge_leaves_url_specs_and_unlocked_packages_unchanged() -> None: + locked = {"gliner": "0.2.26", "demo": "9.9.9"} + requirements = [ + "gliner>=0.2.26,<1 ; sys_platform == 'linux'", + "demo @ git+https://example.com/demo.git@abc123", + "wheel @ https://example.com/wheel.whl ; sys_platform == 'linux'", + "absent>=1,<2", + "pinned==3", + ] + + assert merge_locked_requirements(requirements, locked) == [ + "gliner==0.2.26 ; sys_platform == 'linux'", + "demo @ git+https://example.com/demo.git@abc123", + "wheel @ https://example.com/wheel.whl ; sys_platform == 'linux'", + "absent>=1,<2", + "pinned==3", + ] + + +def test_local_version_builds_share_one_prefix_constraint() -> None: + lock = """ +version = 1 +[[package]] +name = "torch" +version = "2.9.1" + +[[package]] +name = "torch" +version = "2.9.1+cu129" +""" + assert locked_versions_from_uv_lock(lock) == {"torch": "2.9.1.*"} + assert merge_locked_requirements(["torch>=2.9,<2.10"], {"torch": "2.9.1.*"}) == ["torch==2.9.1.*"] diff --git a/tools/ci/tests/test_docker_task.py b/tools/ci/tests/test_docker_task.py index db12c03e3..7177c5def 100644 --- a/tools/ci/tests/test_docker_task.py +++ b/tools/ci/tests/test_docker_task.py @@ -244,6 +244,44 @@ def fail_verification(*_args, **_kwargs): assert commands == [] +def _dockerfile_logical_lines(text: str) -> list[str]: + logical: list[str] = [] + buffer = "" + for line in text.splitlines(): + stripped = line.strip() + buffer = f"{buffer} {stripped}".strip() if buffer else stripped + if buffer.endswith("\\"): + buffer = buffer[:-1].rstrip() + continue + logical.append(buffer) + buffer = "" + if buffer: + logical.append(buffer) + return logical + + +@pytest.mark.parametrize( + "dockerfile", + ["Dockerfile.cpu", "Dockerfile.cuda12", "Dockerfile.cuda13"], +) +def test_bundle_image_installs_are_constrained_to_the_lock(dockerfile: str) -> None: + text = (Path(__file__).resolve().parents[3] / "packages" / "sie_server" / dockerfile).read_text() + assert "COPY uv.lock /tmp/uv.lock" in text + assert "--constraints-output /tmp/bundle-constraints.txt" in text + assert "pip freeze --path /app/bundle-libs > /app/bundle-libs-freeze.txt" in text + assert "/app/bundle-libs-freeze.txt /app/bundle-libs-freeze.txt" in text + installs = [ + line + for line in _dockerfile_logical_lines(text) + if "-r /tmp/bundle-requirements.txt" in line and ("pip install" in line or "uv pip install" in line) + ] + assert installs + constraints_file = "/tmp/bundle-constraints.txt" # noqa: S108 + for line in installs: + assert constraints_file in line + assert f"-c {constraints_file}" in line or f"--constraint {constraints_file}" in line + + def test_expected_release_set_has_sixteen_tags_and_six_names(complete_source): images = docker_task.expected_versioned_images("ghcr.io/superlinked", VERSION, complete_source) assert len(images) == len(set(images)) == 16 From 307d09d178b693f85b59710b4f8fd3bf34c972b3 Mon Sep 17 00:00:00 2001 From: YeonwooSung Date: Fri, 9 Oct 2026 23:23:37 +0900 Subject: [PATCH 02/13] fix(server): pin transitive bundle deps and tolerate a split lock Pin the locked transitive closure, omit extras from constraint lines, and skip a package when uv.lock has two public versions instead of failing the image build. The constraints header states that this can install an older release than an unconstrained build. Refs #377 --- .../src/sie_server/bundle_requirements.py | 271 ++++++++++++++++-- packages/sie_server/src/sie_server/cli.py | 16 +- .../tests/core/test_bundle_requirements.py | 208 +++++++++++++- 3 files changed, 466 insertions(+), 29 deletions(-) diff --git a/packages/sie_server/src/sie_server/bundle_requirements.py b/packages/sie_server/src/sie_server/bundle_requirements.py index 14c1136ce..14890dbbe 100644 --- a/packages/sie_server/src/sie_server/bundle_requirements.py +++ b/packages/sie_server/src/sie_server/bundle_requirements.py @@ -9,6 +9,7 @@ import re import tomllib from collections.abc import Mapping, Sequence +from dataclasses import dataclass from hashlib import sha256 from pathlib import Path from typing import cast @@ -18,6 +19,7 @@ _CUDA_ONLY_PACKAGES = frozenset({"fla-core", "flash-attn", "xformers"}) _EXACT_OPERATORS = frozenset({"==", "==="}) +_DOWNGRADE_EXAMPLES = ("sentence-transformers", "gliner") def _normalize_package_name(name: str) -> str: @@ -70,14 +72,34 @@ def bundle_requirements_sha256(bundle_deps: Mapping[str, object]) -> str: return sha256(payload).hexdigest() -def locked_versions_from_uv_lock(source: str | Path) -> dict[str, str]: - """Return locked constraint versions keyed by normalized package name. +@dataclass(frozen=True) +class LockEdge: + """One uv.lock dependency edge, including any requested extras.""" - One lock entry becomes that exact version string. Several entries that - share a public version (``torch`` ``2.9.1`` and ``2.9.1+cu129``) become a - prefix match, ``2.9.1.*``, so each locked build matches and a newer - release does not. Distinct public versions are an error. + name: str + extras: frozenset[str] + + +@dataclass(frozen=True) +class UvLock: + """Package graph read from a uv.lock file. + + ``versions`` holds one constraint string per unambiguous package. Packages + with two public versions are listed in ``ambiguous`` and omitted from + ``versions`` so image builds skip them instead of aborting. ``dependencies`` + and ``optional_dependencies`` are the lock's ``dependencies`` and + ``optional-dependencies`` tables, keyed by normalized name. """ + + versions: Mapping[str, str] + ambiguous: frozenset[str] + dependencies: Mapping[str, tuple[LockEdge, ...]] + optional_dependencies: Mapping[str, Mapping[str, tuple[LockEdge, ...]]] + names: Mapping[str, str] + + +def parse_uv_lock(source: str | Path) -> UvLock: + """Parse package tables from a uv.lock file into a dependency graph.""" text = source.read_text(encoding="utf-8") if isinstance(source, Path) else source try: data = tomllib.loads(text) @@ -89,17 +111,63 @@ def locked_versions_from_uv_lock(source: str | Path) -> dict[str, str]: msg = "uv.lock package table is not a list" raise ValueError(msg) - found: dict[str, set[str]] = {} + grouped: dict[str, list[dict[str, object]]] = {} + names: dict[str, str] = {} for package in packages: if not isinstance(package, dict): continue - name = package.get("name") - version = package.get("version") - if not isinstance(name, str) or not isinstance(version, str): + raw_name = package.get("name") + raw_version = package.get("version") + if not isinstance(raw_name, str) or not isinstance(raw_version, str): continue - found.setdefault(_normalize_package_name(name), set()).add(version) + normalized = _normalize_package_name(raw_name) + names.setdefault(normalized, raw_name) + grouped.setdefault(normalized, []).append(package) + + versions: dict[str, str] = {} + ambiguous: set[str] = set() + dependencies: dict[str, tuple[LockEdge, ...]] = {} + optional_dependencies: dict[str, dict[str, tuple[LockEdge, ...]]] = {} + for normalized, entries in grouped.items(): + found = {version for entry in entries if isinstance(version := entry.get("version"), str)} + resolved = _constraint_version(normalized, found) + if resolved is None: + ambiguous.add(normalized) + else: + versions[normalized] = resolved + base: set[LockEdge] = set() + optional: dict[str, set[LockEdge]] = {} + for entry in entries: + base.update(_lock_edges(entry.get("dependencies"))) + raw_optional = entry.get("optional-dependencies") + if not isinstance(raw_optional, dict): + continue + for extra, items in raw_optional.items(): + if isinstance(extra, str): + optional.setdefault(extra.lower(), set()).update(_lock_edges(items)) + dependencies[normalized] = _freeze_edges(base) + if optional: + optional_dependencies[normalized] = {extra: _freeze_edges(edges) for extra, edges in optional.items()} + + return UvLock( + versions=versions, + ambiguous=frozenset(ambiguous), + dependencies=dependencies, + optional_dependencies=optional_dependencies, + names=names, + ) - return {name: _constraint_version(name, versions) for name, versions in found.items()} + +def locked_versions_from_uv_lock(source: str | Path) -> dict[str, str]: + """Return locked constraint versions keyed by normalized package name. + + One lock entry becomes that exact version string. Several entries that + share a public version (``torch`` ``2.9.1`` and ``2.9.1+cu129``) become a + prefix match, ``2.9.1.*``, so each locked build matches and a newer + release does not. Distinct public versions are omitted; the constraints + file records that skip instead of failing the image build. + """ + return dict(parse_uv_lock(source).versions) def merge_locked_requirements(requirements: Sequence[str], locked_versions: Mapping[str, str]) -> list[str]: @@ -125,13 +193,65 @@ def merge_locked_requirements(requirements: Sequence[str], locked_versions: Mapp return merged -def lock_constraint_lines(requirements: Sequence[str], locked_versions: Mapping[str, str]) -> list[str]: - """Return only the lock pins a constraints file should add.""" - merged = merge_locked_requirements(requirements, locked_versions) - return [updated for original, updated in zip(requirements, merged, strict=True) if updated != original] +def lock_constraint_lines(requirements: Sequence[str], lock: UvLock) -> list[str]: + """Return constraints for the locked transitive closure of ``requirements``. + + Each pin is ``name==version`` with no extras and no markers. Pip rejects + extras in a constraints file, and a marker would leave the pin inactive on + other platforms. The file starts with a comment that ranged dependencies + follow ``uv.lock`` and can therefore be older than an unconstrained install. + + Exact ``==`` pins and URL or VCS specs stay out of the file. Their lock + neighbors are still pinned when that neighbor is not part of a dependency + the bundle moved off the lock: those edges describe a distribution pip will + not install (transformers 5 versus a 4.x lock's ``huggingface-hub`` and + ``safetensors``) and would make the override unsatisfiable. A package with + two public versions is skipped with a comment instead of aborting. + """ + grouped = _requirement_groups(requirements) + constrained: list[tuple[str, frozenset[str]]] = [] + exact: list[tuple[str, frozenset[str]]] = [] + untrusted: list[tuple[str, frozenset[str]]] = [] + for name, reqs in grouped.items(): + kind = _root_kind(name, reqs, lock) + if kind is None: + continue + root = (name, _root_extras(reqs)) + if kind == "constrained": + constrained.append(root) + elif kind == "exact": + exact.append(root) + else: + untrusted.append(root) + + constrained_reach = _reachable(constrained, lock) + exact_reach = _reachable(exact, lock) + untrusted_reach = _reachable(untrusted, lock) + # Exact-override neighbors are pinned unless a rejected lock distribution + # also reaches them. A constrained dependency still wins: that package is + # installed at the locked version. + trusted = constrained_reach | (exact_reach - untrusted_reach) + + pins: list[str] = [] + skips: list[str] = [] + pinned_names: set[str] = set() + for name in sorted(trusted): + reqs = grouped.get(name, []) + if _pin_blocked(name, reqs, lock): + continue + display = lock.names.get(name, name) + if name in lock.ambiguous: + skips.append(f"# {display} skipped: uv.lock has multiple public versions") + continue + version = lock.versions.get(name) + if version is None: + continue + pins.append(f"{display}=={version}") + pinned_names.add(name) + return [*_constraint_header(pinned_names), *skips, *pins] -def _constraint_version(name: str, versions: set[str]) -> str: +def _constraint_version(name: str, versions: set[str]) -> str | None: if len(versions) == 1: return next(iter(versions)) try: @@ -140,12 +260,123 @@ def _constraint_version(name: str, versions: set[str]) -> str: msg = f"uv.lock pins {name} to an invalid version" raise ValueError(msg) from exc if len(public_versions) != 1: - joined = ", ".join(sorted(versions)) - msg = f"uv.lock pins {name} to multiple public versions: {joined}" - raise ValueError(msg) + return None return f"{next(iter(public_versions))}.*" +def _lock_edges(items: object) -> tuple[LockEdge, ...]: + if not isinstance(items, list): + return () + edges: list[LockEdge] = [] + for item in items: + if isinstance(item, str): + edges.append(LockEdge(_normalize_package_name(item), frozenset())) + continue + if not isinstance(item, dict): + continue + raw_name = item.get("name") + if not isinstance(raw_name, str): + continue + extras = _lock_extras(item.get("extra", item.get("extras"))) + edges.append(LockEdge(_normalize_package_name(raw_name), extras)) + return tuple(edges) + + +def _lock_extras(value: object) -> frozenset[str]: + if isinstance(value, str): + return frozenset({value.lower()}) + if isinstance(value, list): + return frozenset(item.lower() for item in value if isinstance(item, str)) + return frozenset() + + +def _freeze_edges(edges: set[LockEdge]) -> tuple[LockEdge, ...]: + return tuple(sorted(edges, key=lambda edge: (edge.name, sorted(edge.extras)))) + + +def _requirement_groups(requirements: Sequence[str]) -> dict[str, list[Requirement]]: + grouped: dict[str, list[Requirement]] = {} + for requirement in requirements: + parsed = Requirement(requirement) + grouped.setdefault(_normalize_package_name(parsed.name), []).append(parsed) + return grouped + + +def _root_kind(name: str, reqs: Sequence[Requirement], lock: UvLock) -> str | None: + """Classify a direct requirement as constrained, exact override, or untrusted. + + Untrusted roots are URL/VCS specs and ranges that do not contain the locked + version. Their lock edges belong to a distribution the bundle will not + install, so those edges must not become constraints. + """ + if name not in lock.versions and name not in lock.ambiguous: + return None + if any(req.url is not None for req in reqs): + return "untrusted" + if any(_is_bundle_override(req) for req in reqs): + return "exact" + version = lock.versions.get(name) + if version is not None and any(not _locked_constraint_satisfies(req, version) for req in reqs): + return "untrusted" + return "constrained" + + +def _root_extras(reqs: Sequence[Requirement]) -> frozenset[str]: + extras: set[str] = set() + for req in reqs: + extras.update(extra.lower() for extra in req.extras) + return frozenset(extras) + + +def _reachable(roots: Sequence[tuple[str, frozenset[str]]], lock: UvLock) -> set[str]: + seen_packages: set[str] = set() + seen_extras: set[tuple[str, str]] = set() + stack = list(roots) + while stack: + name, extras = stack.pop() + if name not in lock.versions and name not in lock.ambiguous: + continue + if name not in seen_packages: + seen_packages.add(name) + for edge in lock.dependencies.get(name, ()): + stack.append((edge.name, edge.extras)) + for extra in extras: + key = (name, extra) + if key in seen_extras: + continue + seen_extras.add(key) + for edge in lock.optional_dependencies.get(name, {}).get(extra, ()): + stack.append((edge.name, edge.extras)) + return seen_packages + + +def _pin_blocked(name: str, reqs: Sequence[Requirement], lock: UvLock) -> bool: + if not reqs: + return False + if any(_is_bundle_override(req) for req in reqs): + return True + version = lock.versions.get(name) + if version is None: + return False + return any(not _locked_constraint_satisfies(req, version) for req in reqs) + + +def _constraint_header(pinned_names: set[str]) -> list[str]: + lines = [ + "# Ranged dependencies are pinned to uv.lock. This can install an older", + "# release than an unconstrained build of the same commit.", + ] + present = [name for name in _DOWNGRADE_EXAMPLES if name in pinned_names] + if not present: + return lines + shown = " and ".join(present) + verb = "follow" if len(present) > 1 else "follows" + lines.append( + f"# For example, {shown} {verb} uv.lock rather than the newest release that still matches the bundle range." + ) + return lines + + def _locked_constraint_satisfies(requirement: Requirement, constraint: str) -> bool: """A prefix pin is usable when its public version is inside the bundle spec.""" candidate = constraint.removesuffix(".*") if constraint.endswith(".*") else constraint diff --git a/packages/sie_server/src/sie_server/cli.py b/packages/sie_server/src/sie_server/cli.py index 1ec0d65d1..d8ff2bf90 100644 --- a/packages/sie_server/src/sie_server/cli.py +++ b/packages/sie_server/src/sie_server/cli.py @@ -211,7 +211,7 @@ def resolve_deps( constraints_output: Path | None = typer.Option( # noqa: B008 None, "--constraints-output", - help="Write lock constraints for ranged dependencies to this file", + help="Write uv.lock constraints for the bundle's locked transitive closure", ), ) -> None: """Resolve and print dependencies for a bundle or model list. @@ -223,10 +223,14 @@ def resolve_deps( and other CUDA-only dependencies. ``--lock`` and ``--constraints-output`` together write a constraints file - that pins ranged dependencies to ``uv.lock``. Exact pins and URL/VCS specs - are not tightened. Stdout stays the bundle requirements. + that pins ranged dependencies and their locked transitive closure to + ``uv.lock``. Lines are ``name==version`` only (pip rejects extras). Exact + pins, URL/VCS specs, and ranges that do not contain the locked version are + not tightened. The file starts with a comment that the pins can install an + older release than an unconstrained build of the same commit. Stdout stays + the bundle requirements. """ - from sie_server.bundle_requirements import lock_constraint_lines, locked_versions_from_uv_lock + from sie_server.bundle_requirements import lock_constraint_lines, parse_uv_lock from sie_server.core.deps import collect_bundle_deps if (lock is None) != (constraints_output is None): @@ -274,11 +278,11 @@ def resolve_deps( if constraints_output is not None and lock is not None: try: - locked = locked_versions_from_uv_lock(lock) + parsed_lock = parse_uv_lock(lock) except (OSError, ValueError) as exc: typer.echo(f"Error: {exc}", err=True) raise typer.Exit(1) from exc - body = "\n".join(lock_constraint_lines(result.requirements, locked)) + body = "\n".join(lock_constraint_lines(result.requirements, parsed_lock)) constraints_output.write_text(f"{body}\n" if body else "", encoding="utf-8") if output_json: diff --git a/packages/sie_server/tests/core/test_bundle_requirements.py b/packages/sie_server/tests/core/test_bundle_requirements.py index ea1eb44ca..9cf09dbc4 100644 --- a/packages/sie_server/tests/core/test_bundle_requirements.py +++ b/packages/sie_server/tests/core/test_bundle_requirements.py @@ -9,6 +9,7 @@ locked_versions_from_uv_lock, merge_locked_requirements, normalized_bundle_requirements, + parse_uv_lock, resolve_bundle_requirements, ) @@ -68,7 +69,8 @@ def test_default_bundle_ranges_pin_to_uv_lock_versions() -> None: def test_exact_pins_and_url_specs_override_the_lock() -> None: - locked = locked_versions_from_uv_lock(_REPO_ROOT / "uv.lock") + parsed = parse_uv_lock(_REPO_ROOT / "uv.lock") + locked = parsed.versions original = _bundle_requirements("transformers5") merged = merge_locked_requirements(original, locked) url_specs = [requirement for requirement in original if " @" in requirement] @@ -83,11 +85,19 @@ def test_exact_pins_and_url_specs_override_the_lock() -> None: # Ranges that do not contain the locked version stay as written. assert "transformers>=5.14,<6" in merged assert "sentence-transformers>=5.6,<6" in merged - constraints = lock_constraint_lines(original, locked) + constraints = lock_constraint_lines(original, parsed) assert "gliner2==2.0.0" not in constraints - assert "torchvision==0.24.1" not in constraints + assert "gliner2==1.3.2" not in constraints + assert not any(line.startswith("torchvision==") for line in constraints) assert all(" @" not in line for line in constraints) assert "transformers==4.57.6" not in constraints + assert "sentence-transformers==5.4.1" not in constraints + # The 4.x lock's huggingface-hub and safetensors do not satisfy transformers 5. + assert f"huggingface-hub=={locked['huggingface-hub']}" not in constraints + assert f"safetensors=={locked['safetensors']}" not in constraints + # Exact gliner2==2.0.0 still contributes lock neighbors that the moved line does not own. + assert f"peft=={locked['peft']}" in constraints + assert f"torch=={locked['torch']}" in constraints def test_merge_leaves_url_specs_and_unlocked_packages_unchanged() -> None: @@ -122,3 +132,195 @@ def test_local_version_builds_share_one_prefix_constraint() -> None: """ assert locked_versions_from_uv_lock(lock) == {"torch": "2.9.1.*"} assert merge_locked_requirements(["torch>=2.9,<2.10"], {"torch": "2.9.1.*"}) == ["torch==2.9.1.*"] + constraints = lock_constraint_lines(["torch>=2.9,<2.10"], parse_uv_lock(lock)) + assert "torch==2.9.1.*" in constraints + assert not any("skipped:" in line for line in constraints) + + +def test_default_bundle_constraints_pin_transitive_deps_and_name_the_downgrade() -> None: + parsed = parse_uv_lock(_REPO_ROOT / "uv.lock") + constraints = lock_constraint_lines(_bundle_requirements("default"), parsed) + + assert constraints[0] == "# Ranged dependencies are pinned to uv.lock. This can install an older" + assert "older" in constraints[0] + assert "release than an unconstrained build" in constraints[1] + assert any(line.startswith("# For example, sentence-transformers and gliner ") for line in constraints) + assert f"onnxruntime=={parsed.versions['onnxruntime']}" in constraints + assert f"docling-core=={parsed.versions['docling-core']}" in constraints + assert f"sentence-transformers=={parsed.versions['sentence-transformers']}" in constraints + assert f"gliner=={parsed.versions['gliner']}" in constraints + assert parsed.versions["sentence-transformers"] == "5.4.1" + assert parsed.versions["gliner"] == "0.2.26" + # Exact bundle pins stay requirements, not constraints. + assert not any(line.startswith("pillow==") for line in constraints) + assert not any(line.startswith("gliformer==") for line in constraints) + assert all("[" not in line for line in constraints) + assert "chromadb==1.5.9" not in constraints + + +def test_constraints_pin_transitive_closure_not_the_whole_lock() -> None: + lock = """ +version = 1 +[[package]] +name = "direct" +version = "1.2.0" +dependencies = [ + { name = "onnxruntime" }, + { name = "docling-core" }, +] + +[[package]] +name = "onnxruntime" +version = "1.25.0" + +[[package]] +name = "docling-core" +version = "2.79.0" +dependencies = [ + { name = "leaf" }, +] + +[[package]] +name = "leaf" +version = "8.0.0" + +[[package]] +name = "outside" +version = "9.0.0" +""" + constraints = lock_constraint_lines(["direct>=1,<2"], parse_uv_lock(lock)) + assert "direct==1.2.0" in constraints + assert "onnxruntime==1.25.0" in constraints + assert "docling-core==2.79.0" in constraints + assert "leaf==8.0.0" in constraints + assert "outside==9.0.0" not in constraints + + +def test_constraint_lines_strip_extras() -> None: + lock = """ +version = 1 +[[package]] +name = "demo" +version = "1.2.3" +dependencies = [ + { name = "base" }, +] + +[package.optional-dependencies] +extra = [ + { name = "optional-dep" }, +] + +[[package]] +name = "base" +version = "4.0.0" + +[[package]] +name = "optional-dep" +version = "5.0.0" + +[[package]] +name = "not-requested" +version = "6.0.0" +""" + constraints = lock_constraint_lines( + ["demo[extra]>=1,<2 ; sys_platform == 'linux'"], + parse_uv_lock(lock), + ) + assert "demo==1.2.3" in constraints + assert "base==4.0.0" in constraints + assert "optional-dep==5.0.0" in constraints + assert "not-requested==6.0.0" not in constraints + assert all("[" not in line for line in constraints) + assert all(";" not in line for line in constraints) + + +def test_exact_override_neighbors_stay_pinned_when_a_rejected_range_does_not() -> None: + lock = """ +version = 1 +[[package]] +name = "kept" +version = "1.0.0" +dependencies = [ + { name = "shared" }, +] + +[[package]] +name = "pinned-override" +version = "1.0.0" +dependencies = [ + { name = "neighbor" }, + { name = "contested" }, +] + +[[package]] +name = "moved" +version = "4.0.0" +dependencies = [ + { name = "old-only" }, + { name = "contested" }, +] + +[[package]] +name = "neighbor" +version = "2.0.0" + +[[package]] +name = "shared" +version = "3.0.0" + +[[package]] +name = "old-only" +version = "5.0.0" + +[[package]] +name = "contested" +version = "7.0.0" +""" + constraints = lock_constraint_lines( + ["kept>=1,<2", "pinned-override==9.9.9", "moved>=5,<6"], + parse_uv_lock(lock), + ) + assert "kept==1.0.0" in constraints + assert "shared==3.0.0" in constraints + assert "neighbor==2.0.0" in constraints + assert not any(line.startswith("pinned-override==") for line in constraints) + assert not any(line.startswith("moved==") for line in constraints) + assert "old-only==5.0.0" not in constraints + assert "contested==7.0.0" not in constraints + + +def test_multiple_public_versions_are_skipped_without_raising() -> None: + lock = """ +version = 1 +[[package]] +name = "direct" +version = "1.0.0" +dependencies = [ + { name = "split" }, + { name = "stable" }, +] + +[[package]] +name = "split" +version = "1.0.0" +dependencies = [ + { name = "stable" }, +] + +[[package]] +name = "split" +version = "2.0.0" + +[[package]] +name = "stable" +version = "3.1.0" +""" + parsed = parse_uv_lock(lock) + assert locked_versions_from_uv_lock(lock) == {"direct": "1.0.0", "stable": "3.1.0"} + assert "split" in parsed.ambiguous + constraints = lock_constraint_lines(["direct>=1,<2"], parsed) + assert "direct==1.0.0" in constraints + assert "stable==3.1.0" in constraints + assert not any(line.startswith("split==") for line in constraints) + assert "# split skipped: uv.lock has multiple public versions" in constraints From e803153c8c2e5b2fb52f27f5f14adeb8ebfb3ec2 Mon Sep 17 00:00:00 2001 From: YeonwooSung Date: Sat, 10 Oct 2026 05:30:09 +0900 Subject: [PATCH 03/13] fix(server): stop bundle constraints from pinning the wrong torch edges Refs #377 --- .../src/sie_server/bundle_requirements.py | 60 ++++-- .../core/test_bundle_image_resolution.py | 175 ++++++++++++++++++ .../tests/core/test_bundle_requirements.py | 131 +++++++++++-- 3 files changed, 334 insertions(+), 32 deletions(-) create mode 100644 packages/sie_server/tests/core/test_bundle_image_resolution.py diff --git a/packages/sie_server/src/sie_server/bundle_requirements.py b/packages/sie_server/src/sie_server/bundle_requirements.py index 14890dbbe..a1aa3091a 100644 --- a/packages/sie_server/src/sie_server/bundle_requirements.py +++ b/packages/sie_server/src/sie_server/bundle_requirements.py @@ -87,8 +87,10 @@ class UvLock: ``versions`` holds one constraint string per unambiguous package. Packages with two public versions are listed in ``ambiguous`` and omitted from ``versions`` so image builds skip them instead of aborting. ``dependencies`` - and ``optional_dependencies`` are the lock's ``dependencies`` and - ``optional-dependencies`` tables, keyed by normalized name. + and ``optional_dependencies`` are the edges of the lock entries that the + constraint installs, keyed by normalized name. A shared public version is + emitted as ``2.9.1.*`` and takes edges from the public ``2.9.1`` entry + only, not from a local build such as ``2.9.1+cu129``. """ versions: Mapping[str, str] @@ -137,7 +139,7 @@ def parse_uv_lock(source: str | Path) -> UvLock: versions[normalized] = resolved base: set[LockEdge] = set() optional: dict[str, set[LockEdge]] = {} - for entry in entries: + for entry in _entries_for_emitted_constraint(entries, resolved): base.update(_lock_edges(entry.get("dependencies"))) raw_optional = entry.get("optional-dependencies") if not isinstance(raw_optional, dict): @@ -201,12 +203,13 @@ def lock_constraint_lines(requirements: Sequence[str], lock: UvLock) -> list[str other platforms. The file starts with a comment that ranged dependencies follow ``uv.lock`` and can therefore be older than an unconstrained install. - Exact ``==`` pins and URL or VCS specs stay out of the file. Their lock - neighbors are still pinned when that neighbor is not part of a dependency - the bundle moved off the lock: those edges describe a distribution pip will - not install (transformers 5 versus a 4.x lock's ``huggingface-hub`` and - ``safetensors``) and would make the override unsatisfiable. A package with - two public versions is skipped with a comment instead of aborting. + Exact ``==`` pins and URL or VCS specs stay out of the file. An exact pin + contributes lock neighbors only when it matches the locked version. A pin + that differs (``torch==2.11.0`` against a ``2.9.1`` lock) is an untrusted + root, same as a range that does not contain the lock: those edges describe + a distribution the bundle will not install. Neighbors reached only through + an untrusted root are not pinned. A package with two public versions is + skipped with a comment instead of aborting. """ grouped = _requirement_groups(requirements) constrained: list[tuple[str, frozenset[str]]] = [] @@ -227,9 +230,9 @@ def lock_constraint_lines(requirements: Sequence[str], lock: UvLock) -> list[str constrained_reach = _reachable(constrained, lock) exact_reach = _reachable(exact, lock) untrusted_reach = _reachable(untrusted, lock) - # Exact-override neighbors are pinned unless a rejected lock distribution - # also reaches them. A constrained dependency still wins: that package is - # installed at the locked version. + # Neighbors of an exact pin that matches the lock stay pinned unless a + # moved-off distribution also reaches them. A constrained dependency still + # wins: that package is installed at the locked version. trusted = constrained_reach | (exact_reach - untrusted_reach) pins: list[str] = [] @@ -264,6 +267,24 @@ def _constraint_version(name: str, versions: set[str]) -> str | None: return f"{next(iter(public_versions))}.*" +def _entries_for_emitted_constraint( + entries: Sequence[Mapping[str, object]], + constraint: str | None, +) -> list[Mapping[str, object]]: + """Edges for the build ``constraint`` installs, not every lock entry. + + A shared public version is emitted as ``2.9.1.*``. That installs the public + wheel (``2.9.1``), so a local build's edges (``2.9.1+cu129``) do not apply. + An exact version uses that build only. Ambiguous names keep every entry. + """ + if constraint is None: + return list(entries) + if constraint.endswith(".*"): + public = constraint.removesuffix(".*") + return [entry for entry in entries if entry.get("version") == public] + return [entry for entry in entries if entry.get("version") == constraint] + + def _lock_edges(items: object) -> tuple[LockEdge, ...]: if not isinstance(items, list): return () @@ -305,17 +326,22 @@ def _requirement_groups(requirements: Sequence[str]) -> dict[str, list[Requireme def _root_kind(name: str, reqs: Sequence[Requirement], lock: UvLock) -> str | None: """Classify a direct requirement as constrained, exact override, or untrusted. - Untrusted roots are URL/VCS specs and ranges that do not contain the locked - version. Their lock edges belong to a distribution the bundle will not - install, so those edges must not become constraints. + Untrusted roots are URL/VCS specs, ranges that do not contain the locked + version, and exact pins of a different version. Their lock edges belong to + a distribution the bundle will not install, so those edges must not become + constraints. An exact pin that matches the locked version still contributes + its edges. """ if name not in lock.versions and name not in lock.ambiguous: return None if any(req.url is not None for req in reqs): return "untrusted" - if any(_is_bundle_override(req) for req in reqs): - return "exact" version = lock.versions.get(name) + overrides = [req for req in reqs if _is_bundle_override(req)] + if overrides: + if version is not None and all(_locked_constraint_satisfies(req, version) for req in overrides): + return "exact" + return "untrusted" if version is not None and any(not _locked_constraint_satisfies(req, version) for req in reqs): return "untrusted" return "constrained" diff --git a/packages/sie_server/tests/core/test_bundle_image_resolution.py b/packages/sie_server/tests/core/test_bundle_image_resolution.py new file mode 100644 index 000000000..178a5912a --- /dev/null +++ b/packages/sie_server/tests/core/test_bundle_image_resolution.py @@ -0,0 +1,175 @@ +"""Resolve each release-matrix bundle the way its image install does. + +The image build runs on linux/amd64. ``uv pip install --dry-run`` applies that +marker environment on any host, with the same ``--target``, constraint, and +requirements arguments as the Dockerfiles. pip on macOS evaluates markers for +Darwin and misses the linux nvidia conflict those constraints used to create. +``--no-config`` keeps the repo's uv torch index from standing in for PyPI. +""" + +from __future__ import annotations + +import json +import os +import shutil +import subprocess +import sys +import tempfile +from pathlib import Path + +import pytest +import yaml +from sie_server.bundle_requirements import lock_constraint_lines, parse_uv_lock, resolve_bundle_requirements + +_REPO_ROOT = Path(__file__).resolve().parents[4] +_BUNDLES = _REPO_ROOT / "packages" / "sie_server" / "bundles" +# CUDA 12 and 13 images are Ubuntu 22.04 (glibc 2.35). manylinux_2_28 rejects +# wheels such as sglang 0.5.20, which publish only manylinux_2_34 tags. +_LINUX_PLATFORM = "x86_64-manylinux_2_35" +_PYTHON_VERSION = "3.12" +# Dockerfile.cuda12's non-default index branch. Embedding is not in the +# release matrix today; keep the same case split as the image. +_SGLANG_CUDA12_BUNDLES = frozenset({"sglang", "sglang-embedding", "sglang-vision-extract"}) +_SCRUBBED_ENV = ( + "UV_INDEX", + "UV_INDEX_URL", + "UV_EXTRA_INDEX_URL", + "UV_DEFAULT_INDEX", + "UV_INDEX_STRATEGY", + "UV_TORCH_BACKEND", + "UV_CONSTRAINT", + "UV_OVERRIDE", + "PIP_INDEX_URL", + "PIP_EXTRA_INDEX_URL", + "PIP_CONSTRAINT", +) + + +def _release_targets() -> list[tuple[str, str]]: + data = json.loads((_REPO_ROOT / ".github" / "release-matrix.json").read_text()) + targets = [(str(platform), str(bundle)) for platform in data["platforms"] for bundle in data["bundles"]] + targets.extend((str(item["platform"]), str(item["bundle"])) for item in data.get("include", [])) + return targets + + +_TARGETS = _release_targets() + + +def _uv_executable() -> str: + sibling = Path(sys.executable).resolve().with_name("uv") + if sibling.is_file() and os.access(sibling, os.X_OK): + return str(sibling) + found = shutil.which("uv") + if found: + return found + pytest.skip("uv is not installed, so the image resolver cannot run") + + +def _image_requirements(platform: str, bundle: str) -> list[str]: + bundle_path = _BUNDLES / f"{bundle}.yaml" + deps = yaml.safe_load(bundle_path.read_text())["deps"] + # Dockerfile.cpu passes --cpu, which drops flash-attn, xformers, and fla-core. + return resolve_bundle_requirements(deps, exclude_cuda=platform == "cpu") + + +def _resolve_command(platform: str, bundle: str, target: Path, requirements: Path, constraints: Path) -> list[str]: + """Arguments that affect resolution, matched to the platform Dockerfile.""" + command = [ + _uv_executable(), + "pip", + "install", + "--dry-run", + "--no-config", + "--python-platform", + _LINUX_PLATFORM, + "--python-version", + _PYTHON_VERSION, + "--target", + str(target), + ] + if platform == "cuda13": + # packages/sie_server/Dockerfile.cuda13 + command.extend( + [ + "--index-strategy", + "unsafe-best-match", + "--prerelease=allow", + "--extra-index-url", + "https://download.pytorch.org/whl/cu130", + "--extra-index-url", + "https://docs.sglang.ai/whl/cu130/", + "--constraint", + str(constraints), + ] + ) + elif platform == "cpu": + # packages/sie_server/Dockerfile.cpu. pip searches every configured index; + # uv's default first-index strategy would not. + command.extend( + [ + "--index-url", + "https://download.pytorch.org/whl/cpu", + "--extra-index-url", + "https://pypi.org/simple", + "--index-strategy", + "unsafe-best-match", + "-c", + str(constraints), + ] + ) + else: + # packages/sie_server/Dockerfile.cuda12 + if bundle in _SGLANG_CUDA12_BUNDLES: + command.extend( + [ + "--extra-index-url", + "https://docs.sglang.ai/whl/cu129/", + "--index-strategy", + "unsafe-best-match", + ] + ) + command.extend(["-c", str(constraints)]) + command.extend(["-r", str(requirements)]) + return command + + +def _resolver_env() -> dict[str, str]: + env = os.environ.copy() + for key in _SCRUBBED_ENV: + env.pop(key, None) + return env + + +@pytest.mark.parametrize( + ("platform", "bundle"), + _TARGETS, + ids=[f"{platform}-{bundle}" for platform, bundle in _TARGETS], +) +def test_release_bundle_constraints_resolve(platform: str, bundle: str) -> None: + requirements = _image_requirements(platform, bundle) + if not requirements: + return + constraints = lock_constraint_lines(requirements, parse_uv_lock(_REPO_ROOT / "uv.lock")) + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + requirements_path = root / "requirements.txt" + constraints_path = root / "constraints.txt" + target = root / "bundle-libs" + target.mkdir() + requirements_path.write_text("\n".join(requirements) + "\n", encoding="utf-8") + constraints_path.write_text("\n".join(constraints) + "\n", encoding="utf-8") + command = _resolve_command(platform, bundle, target, requirements_path, constraints_path) + assert str(target) in command + assert str(requirements_path) in command + assert str(constraints_path) in command + completed = subprocess.run( # noqa: S603 - fixed uv resolution command built above + command, + check=False, + capture_output=True, + text=True, + env=_resolver_env(), + cwd=tmp, + timeout=900, + ) + details = (completed.stderr or completed.stdout or "")[-4000:] + assert completed.returncode == 0, details diff --git a/packages/sie_server/tests/core/test_bundle_requirements.py b/packages/sie_server/tests/core/test_bundle_requirements.py index 9cf09dbc4..33549e7ad 100644 --- a/packages/sie_server/tests/core/test_bundle_requirements.py +++ b/packages/sie_server/tests/core/test_bundle_requirements.py @@ -62,7 +62,6 @@ def test_default_bundle_ranges_pin_to_uv_lock_versions() -> None: assert "gliner>=0.2.26,<1" in original assert f"gliner=={locked['gliner']}" in merged - assert locked["gliner"] == "0.2.26" assert "gliner>=0.2.26,<1" not in merged assert f"torch=={locked['torch']}" in merged assert f"requests=={locked['requests']}" in merged @@ -76,10 +75,10 @@ def test_exact_pins_and_url_specs_override_the_lock() -> None: url_specs = [requirement for requirement in original if " @" in requirement] assert url_specs - assert locked["gliner2"] == "1.3.2" assert "gliner2==2.0.0" in merged - assert "torchvision==0.24.1" in merged - assert locked["torchvision"] != "0.24.1" + # Exact bundle pin, not the lock's ``0.24.1.*`` prefix constraint. + torchvision_lines = [requirement for requirement in merged if requirement.startswith("torchvision==")] + assert torchvision_lines == ["torchvision==0.24.1"] for requirement in url_specs: assert requirement in merged # Ranges that do not contain the locked version stay as written. @@ -87,16 +86,17 @@ def test_exact_pins_and_url_specs_override_the_lock() -> None: assert "sentence-transformers>=5.6,<6" in merged constraints = lock_constraint_lines(original, parsed) assert "gliner2==2.0.0" not in constraints - assert "gliner2==1.3.2" not in constraints + assert f"gliner2=={locked['gliner2']}" not in constraints assert not any(line.startswith("torchvision==") for line in constraints) assert all(" @" not in line for line in constraints) - assert "transformers==4.57.6" not in constraints - assert "sentence-transformers==5.4.1" not in constraints + assert f"transformers=={locked['transformers']}" not in constraints + assert f"sentence-transformers=={locked['sentence-transformers']}" not in constraints # The 4.x lock's huggingface-hub and safetensors do not satisfy transformers 5. assert f"huggingface-hub=={locked['huggingface-hub']}" not in constraints assert f"safetensors=={locked['safetensors']}" not in constraints - # Exact gliner2==2.0.0 still contributes lock neighbors that the moved line does not own. - assert f"peft=={locked['peft']}" in constraints + # gliner2==2.0.0 moves off the lock, so its 1.x edges are not pinned. + # torch stays because the bundle range still contains the locked version. + assert f"peft=={locked['peft']}" not in constraints assert f"torch=={locked['torch']}" in constraints @@ -149,13 +149,13 @@ def test_default_bundle_constraints_pin_transitive_deps_and_name_the_downgrade() assert f"docling-core=={parsed.versions['docling-core']}" in constraints assert f"sentence-transformers=={parsed.versions['sentence-transformers']}" in constraints assert f"gliner=={parsed.versions['gliner']}" in constraints - assert parsed.versions["sentence-transformers"] == "5.4.1" - assert parsed.versions["gliner"] == "0.2.26" # Exact bundle pins stay requirements, not constraints. assert not any(line.startswith("pillow==") for line in constraints) assert not any(line.startswith("gliformer==") for line in constraints) assert all("[" not in line for line in constraints) - assert "chromadb==1.5.9" not in constraints + assert f"chromadb=={parsed.versions['chromadb']}" not in constraints + # The public torch pin must not import the cu129 wheel's nvidia stack. + assert not any(line.startswith("nvidia-cublas-cu12==") for line in constraints) def test_constraints_pin_transitive_closure_not_the_whole_lock() -> None: @@ -235,7 +235,7 @@ def test_constraint_lines_strip_extras() -> None: assert all(";" not in line for line in constraints) -def test_exact_override_neighbors_stay_pinned_when_a_rejected_range_does_not() -> None: +def test_exact_override_neighbors_stay_pinned_only_when_the_pin_matches_the_lock() -> None: lock = """ version = 1 [[package]] @@ -245,6 +245,14 @@ def test_exact_override_neighbors_stay_pinned_when_a_rejected_range_does_not() - { name = "shared" }, ] +[[package]] +name = "matched" +version = "1.0.0" +dependencies = [ + { name = "matched-neighbor" }, + { name = "contested" }, +] + [[package]] name = "pinned-override" version = "1.0.0" @@ -265,6 +273,10 @@ def test_exact_override_neighbors_stay_pinned_when_a_rejected_range_does_not() - name = "neighbor" version = "2.0.0" +[[package]] +name = "matched-neighbor" +version = "2.1.0" + [[package]] name = "shared" version = "3.0.0" @@ -278,18 +290,107 @@ def test_exact_override_neighbors_stay_pinned_when_a_rejected_range_does_not() - version = "7.0.0" """ constraints = lock_constraint_lines( - ["kept>=1,<2", "pinned-override==9.9.9", "moved>=5,<6"], + ["kept>=1,<2", "matched==1.0.0", "pinned-override==9.9.9", "moved>=5,<6"], parse_uv_lock(lock), ) assert "kept==1.0.0" in constraints assert "shared==3.0.0" in constraints - assert "neighbor==2.0.0" in constraints + assert "matched-neighbor==2.1.0" in constraints + assert "neighbor==2.0.0" not in constraints + assert not any(line.startswith("matched==") for line in constraints) assert not any(line.startswith("pinned-override==") for line in constraints) assert not any(line.startswith("moved==") for line in constraints) assert "old-only==5.0.0" not in constraints assert "contested==7.0.0" not in constraints +def test_public_prefix_constraint_ignores_local_build_edges() -> None: + lock = """ +version = 1 +[[package]] +name = "torch" +version = "2.9.1" +dependencies = [ + { name = "filelock" }, +] + +[[package]] +name = "torch" +version = "2.9.1+cu129" +dependencies = [ + { name = "filelock" }, + { name = "nvidia-cublas-cu12" }, +] + +[[package]] +name = "filelock" +version = "3.0.0" + +[[package]] +name = "nvidia-cublas-cu12" +version = "12.9.1.4" + +[[package]] +name = "torch-local-only" +version = "2.9.1+cu129" +dependencies = [ + { name = "nvidia-cublas-cu12" }, +] + +[[package]] +name = "torch-local-only" +version = "2.9.1+cu130" +dependencies = [ + { name = "nvidia-cublas-cu13" }, +] + +[[package]] +name = "nvidia-cublas-cu13" +version = "13.0.0" +""" + parsed = parse_uv_lock(lock) + assert parsed.versions["torch"] == "2.9.1.*" + assert parsed.versions["torch-local-only"] == "2.9.1.*" + public = lock_constraint_lines(["torch>=2.9,<2.10"], parsed) + assert "torch==2.9.1.*" in public + assert "filelock==3.0.0" in public + assert "nvidia-cublas-cu12==12.9.1.4" not in public + local_only = lock_constraint_lines(["torch-local-only>=2.9,<2.10"], parsed) + assert "torch-local-only==2.9.1.*" in local_only + assert "nvidia-cublas-cu12==12.9.1.4" not in local_only + assert "nvidia-cublas-cu13==13.0.0" not in local_only + + +def test_sole_local_build_keeps_its_own_edges() -> None: + lock = """ +version = 1 +[[package]] +name = "torch" +version = "2.9.1+cu129" +dependencies = [ + { name = "nvidia-cublas-cu12" }, +] + +[[package]] +name = "nvidia-cublas-cu12" +version = "12.9.1.4" +""" + constraints = lock_constraint_lines(["torch>=2.9,<2.10"], parse_uv_lock(lock)) + assert "torch==2.9.1+cu129" in constraints + assert "nvidia-cublas-cu12==12.9.1.4" in constraints + + +def test_moved_exact_pins_do_not_contribute_lock_edges() -> None: + parsed = parse_uv_lock(_REPO_ROOT / "uv.lock") + constraints = lock_constraint_lines(_bundle_requirements("tensorrt-llm"), parsed) + + assert f"huggingface-hub=={parsed.versions['huggingface-hub']}" not in constraints + assert f"setuptools=={parsed.versions['setuptools']}" not in constraints + assert not any(line.startswith("nvidia-cublas-cu12==") for line in constraints) + assert not any(line.startswith("torch==") for line in constraints) + assert not any(line.startswith("transformers==") for line in constraints) + + def test_multiple_public_versions_are_skipped_without_raising() -> None: lock = """ version = 1 From fdfa3fa4a56e117b3a22962ed1a736918b4d82b5 Mon Sep 17 00:00:00 2001 From: YeonwooSung Date: Sat, 10 Oct 2026 05:49:34 +0900 Subject: [PATCH 04/13] test(server): skip bundle resolution unless opted in Refs #377 --- .github/workflows/ci.yml | 23 ++++++++++++++++++- .../core/test_bundle_image_resolution.py | 4 ++++ tools/ci/required_ci.py | 1 + 3 files changed, 27 insertions(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index ad29226f5..752901f36 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -85,6 +85,27 @@ jobs: mise run helm -- dependencies mise exec -- uv run --frozen --project . --no-sync pytest -q -m docker tools/ci/tests/test_collector_*privacy.py + bundle-resolution: + name: CI / Bundle resolution + runs-on: blacksmith-2vcpu-ubuntu-2404 + timeout-minutes: 45 + steps: + - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5 + with: + persist-credentials: false + - uses: jdx/mise-action@c37c93293d6b742fc901e1406b8f764f6fb19dac # v2 + with: + version: 2026.5.5 + install_args: --jobs=1 + cache: false + - run: mise run sync + - name: Resolve release bundle constraints + env: + SIE_RUN_IMAGE_RESOLUTION: "1" + run: >- + mise exec -- uv run --frozen --project . --no-sync pytest -q + packages/sie_server/tests/core/test_bundle_image_resolution.py + typescript: name: CI / TypeScript runs-on: blacksmith-4vcpu-ubuntu-2404 @@ -267,7 +288,7 @@ jobs: required: name: CI / Required if: ${{ always() }} - needs: [policy, bootstrap, python, typescript, rust, contracts, helm, live-sdk, cpu-stack, python-distributions, npm-distributions] + needs: [policy, bootstrap, python, bundle-resolution, typescript, rust, contracts, helm, live-sdk, cpu-stack, python-distributions, npm-distributions] runs-on: blacksmith-2vcpu-ubuntu-2404 timeout-minutes: 5 steps: diff --git a/packages/sie_server/tests/core/test_bundle_image_resolution.py b/packages/sie_server/tests/core/test_bundle_image_resolution.py index 178a5912a..50b523e0d 100644 --- a/packages/sie_server/tests/core/test_bundle_image_resolution.py +++ b/packages/sie_server/tests/core/test_bundle_image_resolution.py @@ -140,6 +140,10 @@ def _resolver_env() -> dict[str, str]: return env +@pytest.mark.skipif( + os.environ.get("SIE_RUN_IMAGE_RESOLUTION") != "1", + reason="needs network access to package indexes", +) @pytest.mark.parametrize( ("platform", "bundle"), _TARGETS, diff --git a/tools/ci/required_ci.py b/tools/ci/required_ci.py index 47808ef75..294562b8f 100644 --- a/tools/ci/required_ci.py +++ b/tools/ci/required_ci.py @@ -10,6 +10,7 @@ "policy", "bootstrap", "python", + "bundle-resolution", "typescript", "rust", "contracts", From 9c270aa532e6c185e1f8e85280901dd6b3590290 Mon Sep 17 00:00:00 2001 From: YeonwooSung Date: Sat, 10 Oct 2026 23:50:24 +0900 Subject: [PATCH 05/13] fix(server): type the lock edge fields and check each image install ty rejected item.get on a dict narrowed from object. The lock edge reader now casts to Mapping, matching the other bundle field reads. The Dockerfile test splits a RUN on ;; so each CUDA 12 install must carry its own constraint file. An opted-in resolution run fails when uv is missing instead of skipping. Refs #377 --- .../src/sie_server/bundle_requirements.py | 5 +++-- .../tests/core/test_bundle_image_resolution.py | 11 ++++++++++- tools/ci/tests/test_docker_task.py | 14 +++++++++++--- 3 files changed, 24 insertions(+), 6 deletions(-) diff --git a/packages/sie_server/src/sie_server/bundle_requirements.py b/packages/sie_server/src/sie_server/bundle_requirements.py index a1aa3091a..3478b7b71 100644 --- a/packages/sie_server/src/sie_server/bundle_requirements.py +++ b/packages/sie_server/src/sie_server/bundle_requirements.py @@ -295,10 +295,11 @@ def _lock_edges(items: object) -> tuple[LockEdge, ...]: continue if not isinstance(item, dict): continue - raw_name = item.get("name") + fields = cast("Mapping[str, object]", item) + raw_name = fields.get("name") if not isinstance(raw_name, str): continue - extras = _lock_extras(item.get("extra", item.get("extras"))) + extras = _lock_extras(fields.get("extra", fields.get("extras"))) edges.append(LockEdge(_normalize_package_name(raw_name), extras)) return tuple(edges) diff --git a/packages/sie_server/tests/core/test_bundle_image_resolution.py b/packages/sie_server/tests/core/test_bundle_image_resolution.py index 50b523e0d..1a8a5e5b1 100644 --- a/packages/sie_server/tests/core/test_bundle_image_resolution.py +++ b/packages/sie_server/tests/core/test_bundle_image_resolution.py @@ -62,7 +62,9 @@ def _uv_executable() -> str: found = shutil.which("uv") if found: return found - pytest.skip("uv is not installed, so the image resolver cannot run") + pytest.fail( + "SIE_RUN_IMAGE_RESOLUTION=1 but uv is not installed; the resolution job must not pass without resolving" + ) def _image_requirements(platform: str, bundle: str) -> list[str]: @@ -140,6 +142,13 @@ def _resolver_env() -> dict[str, str]: return env +def test_missing_uv_fails_the_opt_in(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None: + monkeypatch.setattr(sys, "executable", str(tmp_path / "python")) + monkeypatch.setattr(shutil, "which", lambda _name: None) + with pytest.raises(pytest.fail.Exception, match="uv is not installed"): + _uv_executable() + + @pytest.mark.skipif( os.environ.get("SIE_RUN_IMAGE_RESOLUTION") != "1", reason="needs network access to package indexes", diff --git a/tools/ci/tests/test_docker_task.py b/tools/ci/tests/test_docker_task.py index 7177c5def..25cac2b2a 100644 --- a/tools/ci/tests/test_docker_task.py +++ b/tools/ci/tests/test_docker_task.py @@ -277,9 +277,17 @@ def test_bundle_image_installs_are_constrained_to_the_lock(dockerfile: str) -> N ] assert installs constraints_file = "/tmp/bundle-constraints.txt" # noqa: S108 - for line in installs: - assert constraints_file in line - assert f"-c {constraints_file}" in line or f"--constraint {constraints_file}" in line + # A case/if arm ends at `;;`. One logical RUN can hold both CUDA 12 + # branches, so each install command is checked on its own. + commands = [ + part.strip() + for line in installs + for part in line.split(";;") + if "-r /tmp/bundle-requirements.txt" in part and ("pip install" in part or "uv pip install" in part) + ] + assert commands + for command in commands: + assert f"-c {constraints_file}" in command or f"--constraint {constraints_file}" in command def test_expected_release_set_has_sixteen_tags_and_six_names(complete_source): From 711445a32e766ac0ed63ae8ab25cc133518631f7 Mon Sep 17 00:00:00 2001 From: YeonwooSung Date: Sun, 11 Oct 2026 02:03:56 +0900 Subject: [PATCH 06/13] fix(server): leave a contested lock neighbor unpinned A package reached by both a constrained root and an untrusted root was still pinned to uv.lock. That pin can contradict the distribution the bundle actually installs, such as huggingface-hub 0.36 next to transformers 5. Direct constrained requirements stay pinned. Refs #377 --- .../src/sie_server/bundle_requirements.py | 19 ++++++++---- .../tests/core/test_bundle_requirements.py | 30 +++++++++++++++++++ 2 files changed, 43 insertions(+), 6 deletions(-) diff --git a/packages/sie_server/src/sie_server/bundle_requirements.py b/packages/sie_server/src/sie_server/bundle_requirements.py index 3478b7b71..778ef109a 100644 --- a/packages/sie_server/src/sie_server/bundle_requirements.py +++ b/packages/sie_server/src/sie_server/bundle_requirements.py @@ -207,8 +207,12 @@ def lock_constraint_lines(requirements: Sequence[str], lock: UvLock) -> list[str contributes lock neighbors only when it matches the locked version. A pin that differs (``torch==2.11.0`` against a ``2.9.1`` lock) is an untrusted root, same as a range that does not contain the lock: those edges describe - a distribution the bundle will not install. Neighbors reached only through - an untrusted root are not pinned. A package with two public versions is + a distribution the bundle will not install. A neighbor an untrusted root + can reach is not pinned, even when a constrained root reaches it too. + Pinning that shared package to the lock can contradict the untrusted + distribution (``huggingface-hub`` 0.36 from ``sentence-transformers`` + versus ``huggingface-hub>=1`` from transformers 5). The constrained + requirement itself stays pinned. A package with two public versions is skipped with a comment instead of aborting. """ grouped = _requirement_groups(requirements) @@ -230,10 +234,13 @@ def lock_constraint_lines(requirements: Sequence[str], lock: UvLock) -> list[str constrained_reach = _reachable(constrained, lock) exact_reach = _reachable(exact, lock) untrusted_reach = _reachable(untrusted, lock) - # Neighbors of an exact pin that matches the lock stay pinned unless a - # moved-off distribution also reaches them. A constrained dependency still - # wins: that package is installed at the locked version. - trusted = constrained_reach | (exact_reach - untrusted_reach) + # A transitive package an untrusted root can reach stays unpinned, even + # when a constrained root reaches it too. The image installs the untrusted + # distribution, and the lock pin can make that solve fail. Direct + # constrained requirements stay pinned: dropping ``torch`` because + # transformers 5 also depends on it would float the bundle's own torch. + constrained_names = {name for name, _extras in constrained} + trusted = ((constrained_reach | exact_reach) - untrusted_reach) | constrained_names pins: list[str] = [] skips: list[str] = [] diff --git a/packages/sie_server/tests/core/test_bundle_requirements.py b/packages/sie_server/tests/core/test_bundle_requirements.py index 33549e7ad..56660b681 100644 --- a/packages/sie_server/tests/core/test_bundle_requirements.py +++ b/packages/sie_server/tests/core/test_bundle_requirements.py @@ -304,6 +304,36 @@ def test_exact_override_neighbors_stay_pinned_only_when_the_pin_matches_the_lock assert "contested==7.0.0" not in constraints +def test_untrusted_root_unpins_a_transitive_also_reached_by_a_constrained_root() -> None: + lock = """ +version = 1 +[[package]] +name = "sentence-transformers" +version = "5.4.1" +dependencies = [ + { name = "huggingface-hub" }, +] + +[[package]] +name = "transformers" +version = "4.57.6" +dependencies = [ + { name = "huggingface-hub" }, +] + +[[package]] +name = "huggingface-hub" +version = "0.36.2" +""" + constraints = lock_constraint_lines( + ["sentence-transformers>=5.4.1,<6", "transformers>=5.14,<6"], + parse_uv_lock(lock), + ) + assert "sentence-transformers==5.4.1" in constraints + assert "huggingface-hub==0.36.2" not in constraints + assert not any(line.startswith("transformers==") for line in constraints) + + def test_public_prefix_constraint_ignores_local_build_edges() -> None: lock = """ version = 1 From 35de8d5b5e5b5fa8e9a9fd55d5b809e06c3324ee Mon Sep 17 00:00:00 2001 From: svonava Date: Sat, 17 Oct 2026 17:48:58 -0700 Subject: [PATCH 07/13] test(server): preserve declared bundle override ranges --- .../sie_server/tests/core/test_bundle_requirements.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/packages/sie_server/tests/core/test_bundle_requirements.py b/packages/sie_server/tests/core/test_bundle_requirements.py index 56660b681..db7b7c089 100644 --- a/packages/sie_server/tests/core/test_bundle_requirements.py +++ b/packages/sie_server/tests/core/test_bundle_requirements.py @@ -3,6 +3,7 @@ from pathlib import Path import yaml +from packaging.requirements import Requirement from sie_server.bundle_requirements import ( bundle_requirements_sha256, lock_constraint_lines, @@ -82,8 +83,11 @@ def test_exact_pins_and_url_specs_override_the_lock() -> None: for requirement in url_specs: assert requirement in merged # Ranges that do not contain the locked version stay as written. - assert "transformers>=5.14,<6" in merged - assert "sentence-transformers>=5.6,<6" in merged + for name in ("transformers", "sentence-transformers"): + declared = [raw for raw in original if Requirement(raw).name == name] + assert len(declared) == 1 + assert not Requirement(declared[0]).specifier.contains(locked[name], prereleases=True) + assert declared[0] in merged constraints = lock_constraint_lines(original, parsed) assert "gliner2==2.0.0" not in constraints assert f"gliner2=={locked['gliner2']}" not in constraints From 8f7c114754a379eb72fe34c8e86f51de4f6353b8 Mon Sep 17 00:00:00 2001 From: svonava Date: Sun, 18 Oct 2026 03:36:46 -0700 Subject: [PATCH 08/13] build(bundles): lock and verify complete runtime overlays --- .github/workflows/ci.yml | 8 +- packages/sie_server/Dockerfile.cpu | 59 +- packages/sie_server/Dockerfile.cuda12 | 75 +- packages/sie_server/Dockerfile.cuda13 | 86 +- packages/sie_server/bundle-locks/README.md | 84 + .../cpu-ctranslate2-amd64/manifest.json | 28 + .../cpu-ctranslate2-amd64/pylock.toml | 26 + .../cpu-ctranslate2-arm64/manifest.json | 28 + .../cpu-ctranslate2-arm64/pylock.toml | 26 + .../cpu-default-amd64/manifest.json | 39 + .../cpu-default-amd64/pylock.toml | 889 +++++++++ .../cpu-default-arm64/manifest.json | 39 + .../cpu-default-arm64/pylock.toml | 888 +++++++++ .../cpu-sglang-amd64/manifest.json | 44 + .../bundle-locks/cpu-sglang-amd64/pylock.toml | 1224 +++++++++++++ .../cpu-sglang-arm64/manifest.json | 44 + .../bundle-locks/cpu-sglang-arm64/pylock.toml | 1224 +++++++++++++ .../cpu-transformers5-amd64/manifest.json | 39 + .../cpu-transformers5-amd64/pylock.toml | 385 ++++ .../cpu-transformers5-arm64/manifest.json | 39 + .../cpu-transformers5-arm64/pylock.toml | 385 ++++ .../cuda12-ctranslate2-amd64/manifest.json | 24 + .../cuda12-ctranslate2-amd64/pylock.toml | 26 + .../cuda12-default-amd64/manifest.json | 24 + .../cuda12-default-amd64/pylock.toml | 993 ++++++++++ .../cuda12-sglang-amd64/manifest.json | 28 + .../cuda12-sglang-amd64/pylock.toml | 1319 ++++++++++++++ .../manifest.json | 28 + .../pylock.toml | 1153 ++++++++++++ .../cuda12-transformers5-amd64/manifest.json | 24 + .../cuda12-transformers5-amd64/pylock.toml | 503 +++++ .../cuda13-sglang-cu130-amd64/manifest.json | 43 + .../cuda13-sglang-cu130-amd64/pylock.toml | 1282 +++++++++++++ .../cuda13-tensorrt-llm-amd64/manifest.json | 43 + .../cuda13-tensorrt-llm-amd64/pylock.toml | 1621 +++++++++++++++++ .../sie_server/bundle-locks/exceptions.json | 723 ++++++++ .../sie_server/src/sie_server/bundle_lock.py | 485 +++++ .../core/test_bundle_image_resolution.py | 195 +- .../sie_server/tests/core/test_bundle_lock.py | 249 +++ tools/ci/bundle_lock.py | 233 +++ tools/ci/tests/test_bundle_lock.py | 106 ++ tools/ci/tests/test_docker_task.py | 35 +- 42 files changed, 14493 insertions(+), 303 deletions(-) create mode 100644 packages/sie_server/bundle-locks/README.md create mode 100644 packages/sie_server/bundle-locks/cpu-ctranslate2-amd64/manifest.json create mode 100644 packages/sie_server/bundle-locks/cpu-ctranslate2-amd64/pylock.toml create mode 100644 packages/sie_server/bundle-locks/cpu-ctranslate2-arm64/manifest.json create mode 100644 packages/sie_server/bundle-locks/cpu-ctranslate2-arm64/pylock.toml create mode 100644 packages/sie_server/bundle-locks/cpu-default-amd64/manifest.json create mode 100644 packages/sie_server/bundle-locks/cpu-default-amd64/pylock.toml create mode 100644 packages/sie_server/bundle-locks/cpu-default-arm64/manifest.json create mode 100644 packages/sie_server/bundle-locks/cpu-default-arm64/pylock.toml create mode 100644 packages/sie_server/bundle-locks/cpu-sglang-amd64/manifest.json create mode 100644 packages/sie_server/bundle-locks/cpu-sglang-amd64/pylock.toml create mode 100644 packages/sie_server/bundle-locks/cpu-sglang-arm64/manifest.json create mode 100644 packages/sie_server/bundle-locks/cpu-sglang-arm64/pylock.toml create mode 100644 packages/sie_server/bundle-locks/cpu-transformers5-amd64/manifest.json create mode 100644 packages/sie_server/bundle-locks/cpu-transformers5-amd64/pylock.toml create mode 100644 packages/sie_server/bundle-locks/cpu-transformers5-arm64/manifest.json create mode 100644 packages/sie_server/bundle-locks/cpu-transformers5-arm64/pylock.toml create mode 100644 packages/sie_server/bundle-locks/cuda12-ctranslate2-amd64/manifest.json create mode 100644 packages/sie_server/bundle-locks/cuda12-ctranslate2-amd64/pylock.toml create mode 100644 packages/sie_server/bundle-locks/cuda12-default-amd64/manifest.json create mode 100644 packages/sie_server/bundle-locks/cuda12-default-amd64/pylock.toml create mode 100644 packages/sie_server/bundle-locks/cuda12-sglang-amd64/manifest.json create mode 100644 packages/sie_server/bundle-locks/cuda12-sglang-amd64/pylock.toml create mode 100644 packages/sie_server/bundle-locks/cuda12-sglang-vision-extract-amd64/manifest.json create mode 100644 packages/sie_server/bundle-locks/cuda12-sglang-vision-extract-amd64/pylock.toml create mode 100644 packages/sie_server/bundle-locks/cuda12-transformers5-amd64/manifest.json create mode 100644 packages/sie_server/bundle-locks/cuda12-transformers5-amd64/pylock.toml create mode 100644 packages/sie_server/bundle-locks/cuda13-sglang-cu130-amd64/manifest.json create mode 100644 packages/sie_server/bundle-locks/cuda13-sglang-cu130-amd64/pylock.toml create mode 100644 packages/sie_server/bundle-locks/cuda13-tensorrt-llm-amd64/manifest.json create mode 100644 packages/sie_server/bundle-locks/cuda13-tensorrt-llm-amd64/pylock.toml create mode 100644 packages/sie_server/bundle-locks/exceptions.json create mode 100644 packages/sie_server/src/sie_server/bundle_lock.py create mode 100644 packages/sie_server/tests/core/test_bundle_lock.py create mode 100644 tools/ci/bundle_lock.py create mode 100644 tools/ci/tests/test_bundle_lock.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 19e0a56c8..0a3895ecf 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -120,11 +120,15 @@ jobs: install_args: --jobs=1 cache: false - run: mise run sync - - name: Resolve release bundle constraints + - name: Install the Docker-pinned lock reader + run: mise install uv@0.9.28 + - name: Verify saved bundle closures and input drift + run: mise exec -- uv run --frozen --project . --no-sync python tools/ci/bundle_lock.py check + - name: Validate every saved target with the Docker installer env: SIE_RUN_IMAGE_RESOLUTION: "1" run: >- - mise exec -- uv run --frozen --project . --no-sync pytest -q + mise exec --no-deps uv@0.9.28 -- uv run --frozen --project . --no-sync pytest -q packages/sie_server/tests/core/test_bundle_image_resolution.py typescript: diff --git a/packages/sie_server/Dockerfile.cpu b/packages/sie_server/Dockerfile.cpu index 94e6a2be5..ae132b9f0 100644 --- a/packages/sie_server/Dockerfile.cpu +++ b/packages/sie_server/Dockerfile.cpu @@ -128,37 +128,35 @@ RUN set -eux; \ FROM base AS builder ARG BUNDLE +ARG TARGETARCH -# Ranged bundle deps are constrained to uv.lock. Exact pins and URL/VCS specs stay overrides. +# Freeze the entire overlay, including packages absent from the root lock. +# The base .venv above is a separate boundary; this does not claim a fully +# reproducible image or change the public bundle declarations. COPY uv.lock /tmp/uv.lock - -RUN .venv/bin/python -m sie_server.cli resolve-deps \ - --bundle "${BUNDLE}" \ - --models-dir models \ - --cpu \ - --lock /tmp/uv.lock \ - --constraints-output /tmp/bundle-constraints.txt \ - > /tmp/bundle-requirements.txt \ - && echo "Bundle ${BUNDLE} requirements:" \ - && cat /tmp/bundle-requirements.txt \ - && echo "Bundle ${BUNDLE} lock constraints:" \ - && cat /tmp/bundle-constraints.txt - -# Bundle-specific deps land in a separate site-packages tree so the shared -# venv layer stays byte-identical across bundles of the same platform. -# Even if /tmp/bundle-requirements.txt is empty, create /app/bundle-libs so -# the runtime `COPY --from` never fails. -RUN --mount=type=cache,target=/root/.cache/pip \ - mkdir -p /app/bundle-libs; \ - if [ -s /tmp/bundle-requirements.txt ]; then \ - .venv/bin/pip install \ - --index-url https://download.pytorch.org/whl/cpu \ - --extra-index-url https://pypi.org/simple \ - --target=/app/bundle-libs \ - --no-compile \ - -c /tmp/bundle-constraints.txt \ - -r /tmp/bundle-requirements.txt; \ - fi +COPY packages/sie_server/bundle-locks /tmp/bundle-locks +COPY tools/ci/bundle_lock.py /tmp/bundle-lock-compiler.py + +RUN test "$(uv --version)" = "uv 0.9.28" \ + && .venv/bin/python -m sie_server.bundle_lock check \ + --lock-dir /tmp/bundle-locks --bundles-dir /app/bundles \ + --root-lock /tmp/uv.lock --compiler /tmp/bundle-lock-compiler.py --platform cpu \ + --bundle "${BUNDLE}" --architecture "${TARGETARCH}" + +# PEP751 supplies exact versions, wheel/archive hashes and VCS commits. There +# is no fresh dependency resolution against a moving index during installation. +# Source builds may still use build-time dependencies; those and the base venv +# are outside this runtime-overlay inventory contract. +RUN --mount=type=cache,target=/root/.cache/uv \ + UV_NO_CACHE=0 UV_COMPILE_BYTECODE=0 UV_HTTP_TIMEOUT=600 uv pip sync \ + --no-config --python /app/.venv/bin/python \ + --target /app/bundle-libs \ + "/tmp/bundle-locks/cpu-${BUNDLE}-${TARGETARCH}/pylock.toml" \ + && .venv/bin/python -m sie_server.bundle_lock verify \ + --lock-dir /tmp/bundle-locks --bundles-dir /app/bundles \ + --root-lock /tmp/uv.lock --compiler /tmp/bundle-lock-compiler.py --platform cpu \ + --bundle "${BUNDLE}" --architecture "${TARGETARCH}" \ + --installed /app/bundle-libs --receipt /app/bundle-libs-inventory.json # bundle-libs cleanup (symmetric to the .venv cleanup in base). Preserve # dist-info RECORD files for runtime native-library discovery. @@ -173,7 +171,7 @@ RUN set -eux; \ fi; \ find /app/bundle-libs -exec touch -h -d @0 {} + 2>/dev/null || true; \ /app/.venv/bin/pip freeze --path /app/bundle-libs > /app/bundle-libs-freeze.txt; \ - touch -d @0 /app/bundle-libs-freeze.txt + touch -d @0 /app/bundle-libs-freeze.txt /app/bundle-libs-inventory.json # ============================================================================= # Runtime image @@ -231,6 +229,7 @@ COPY --link --from=base --chown=1000:1000 /app/bundles /app/bundles # Bundle-specific extras — last layer so shared layers above stay cached. COPY --link --from=builder --chown=1000:1000 /app/bundle-libs /app/bundle-libs COPY --link --from=builder --chown=1000:1000 /app/bundle-libs-freeze.txt /app/bundle-libs-freeze.txt +COPY --link --from=builder --chown=1000:1000 /app/bundle-libs-inventory.json /app/bundle-libs-inventory.json RUN mkdir -p /app/evals /app/.cache/huggingface /app/.cache/sie && chown -R sie:sie /app/evals /app/.cache \ && chmod 700 /app/.cache/sie diff --git a/packages/sie_server/Dockerfile.cuda12 b/packages/sie_server/Dockerfile.cuda12 index 5393c3a28..a743e485a 100644 --- a/packages/sie_server/Dockerfile.cuda12 +++ b/packages/sie_server/Dockerfile.cuda12 @@ -147,53 +147,35 @@ RUN set -eux; \ FROM base AS builder ARG BUNDLE +ARG TARGETARCH -# Ranged bundle deps are constrained to uv.lock. Exact pins and URL/VCS specs stay overrides. +# Freeze the entire overlay, including packages absent from the root lock. +# The base .venv above is a separate boundary; this does not claim a fully +# reproducible image or change the public bundle declarations. COPY uv.lock /tmp/uv.lock - -RUN .venv/bin/python -m sie_server.cli resolve-deps \ - --bundle "${BUNDLE}" \ - --models-dir models \ - --lock /tmp/uv.lock \ - --constraints-output /tmp/bundle-constraints.txt \ - > /tmp/bundle-requirements.txt \ - && echo "Bundle ${BUNDLE} requirements:" \ - && cat /tmp/bundle-requirements.txt \ - && echo "Bundle ${BUNDLE} lock constraints:" \ - && cat /tmp/bundle-constraints.txt - -# Bundle-specific deps go into a separate site-packages tree (``bundle-libs``, -# prepended to sys.path via a .pth) so the shared venv layer stays -# byte-identical across bundles. Branches resolve with ``.venv/bin/pip`` (shared -# torch/transformers/nvidia wheels visible on the venv's sys.path); bundle-libs -# carries each bundle's closure for any package whose version differs from the -# shared venv. flash-attn deps carry `sys_platform == 'linux'` markers so they -# install on Linux (this image) but not on developer machines. -# -# Per-bundle CUDA wheel index. SGLang's sgl-kernel/flashinfer wheels live on the -# docs.sglang.ai cu129 index (not PyPI), so the SGLang-family bundles add it. -# The sglang-cu130 bundle (sglang 0.5.13 / torch 2.11 / cu130, CUDA 13) is built by the -# separate ``cuda13`` platform — see Dockerfile.cuda13 — not here. -RUN --mount=type=cache,target=/root/.cache/pip \ - --mount=type=cache,target=/root/.cache/uv \ - mkdir -p /app/bundle-libs; \ - if [ -s /tmp/bundle-requirements.txt ]; then \ - case "$BUNDLE" in \ - sglang | sglang-embedding | sglang-vision-extract) \ - .venv/bin/pip install \ - --target=/app/bundle-libs \ - --no-compile \ - --extra-index-url https://docs.sglang.ai/whl/cu129/ \ - -c /tmp/bundle-constraints.txt \ - -r /tmp/bundle-requirements.txt ;; \ - *) \ - .venv/bin/pip install \ - --target=/app/bundle-libs \ - --no-compile \ - -c /tmp/bundle-constraints.txt \ - -r /tmp/bundle-requirements.txt ;; \ - esac; \ - fi +COPY packages/sie_server/bundle-locks /tmp/bundle-locks +COPY tools/ci/bundle_lock.py /tmp/bundle-lock-compiler.py + +RUN test "$(uv --version)" = "uv 0.9.28" \ + && .venv/bin/python -m sie_server.bundle_lock check \ + --lock-dir /tmp/bundle-locks --bundles-dir /app/bundles \ + --root-lock /tmp/uv.lock --compiler /tmp/bundle-lock-compiler.py --platform cuda12 \ + --bundle "${BUNDLE}" --architecture "${TARGETARCH}" + +# PEP751 supplies exact versions, wheel/archive hashes and VCS commits. There +# is no fresh dependency resolution against a moving index during installation. +# Source builds may still use build-time dependencies; those and the base venv +# are outside this runtime-overlay inventory contract. +RUN --mount=type=cache,target=/root/.cache/uv \ + UV_NO_CACHE=0 UV_COMPILE_BYTECODE=0 UV_HTTP_TIMEOUT=600 uv pip sync \ + --no-config --python /app/.venv/bin/python \ + --target /app/bundle-libs \ + "/tmp/bundle-locks/cuda12-${BUNDLE}-${TARGETARCH}/pylock.toml" \ + && .venv/bin/python -m sie_server.bundle_lock verify \ + --lock-dir /tmp/bundle-locks --bundles-dir /app/bundles \ + --root-lock /tmp/uv.lock --compiler /tmp/bundle-lock-compiler.py --platform cuda12 \ + --bundle "${BUNDLE}" --architecture "${TARGETARCH}" \ + --installed /app/bundle-libs --receipt /app/bundle-libs-inventory.json # bundle-libs cleanup (symmetric to the .venv cleanup in base). The .venv # tree is already final in the base stage; only the per-bundle tree needs @@ -212,7 +194,7 @@ RUN set -eux; \ # Normalize mtimes so rebuilds of the same bundle produce identical layer bytes. find /app/bundle-libs -exec touch -h -d @0 {} + 2>/dev/null || true; \ /app/.venv/bin/pip freeze --path /app/bundle-libs > /app/bundle-libs-freeze.txt; \ - touch -d @0 /app/bundle-libs-freeze.txt + touch -d @0 /app/bundle-libs-freeze.txt /app/bundle-libs-inventory.json # ============================================================================= # Runtime image @@ -319,6 +301,7 @@ COPY --link --from=base --chown=1000:1000 /app/bundles /app/bundles # A `.pth` file in the shared venv puts /app/bundle-libs at sys.path[0] at startup. COPY --link --from=builder --chown=1000:1000 /app/bundle-libs /app/bundle-libs COPY --link --from=builder --chown=1000:1000 /app/bundle-libs-freeze.txt /app/bundle-libs-freeze.txt +COPY --link --from=builder --chown=1000:1000 /app/bundle-libs-inventory.json /app/bundle-libs-inventory.json RUN mkdir -p /app/evals /app/.cache/huggingface /app/.cache/sie-kernels /app/.cache/sie \ && chown -R sie:sie /app/evals /app/.cache \ diff --git a/packages/sie_server/Dockerfile.cuda13 b/packages/sie_server/Dockerfile.cuda13 index 9f1b7fb15..13eb810ee 100644 --- a/packages/sie_server/Dockerfile.cuda13 +++ b/packages/sie_server/Dockerfile.cuda13 @@ -147,60 +147,41 @@ RUN set -eux; \ FROM base AS builder ARG BUNDLE +ARG TARGETARCH -# Ranged bundle deps are constrained to uv.lock. Exact pins and URL/VCS specs stay overrides. +# Freeze the entire overlay, including packages absent from the root lock. +# The base .venv above is a separate boundary; this does not claim a fully +# reproducible image or change the public bundle declarations. COPY uv.lock /tmp/uv.lock - -RUN .venv/bin/python -m sie_server.cli resolve-deps \ - --bundle "${BUNDLE}" \ - --models-dir models \ - --lock /tmp/uv.lock \ - --constraints-output /tmp/bundle-constraints.txt \ - > /tmp/bundle-requirements.txt \ - && echo "Bundle ${BUNDLE} requirements:" \ - && cat /tmp/bundle-requirements.txt \ - && echo "Bundle ${BUNDLE} lock constraints:" \ - && cat /tmp/bundle-constraints.txt - -# cu130 bundle deps go into a separate site-packages tree (``bundle-libs``, -# prepended to sys.path via the .pth above). CUDA 13 engines need torch 2.11 -# from the cu130 PyTorch index, where the only ``2.11.0`` is the ``+cu130`` -# local-version wheel; pip's multi-index resolution does not reliably prefer it -# over PyPI's default-CUDA build, so cuda13 bundles resolve with ``uv`` and -# ``--index-strategy unsafe-best-match`` against the cu130 PyTorch + sglang -# indexes (so torch 2.11 + sgl-kernel/flashinfer land for cu130). This uv + -# cu130-index resolution was validated with sglang 0.5.13, torch 2.11, and a -# cu130 runtime in a fresh GPU environment. +COPY packages/sie_server/bundle-locks /tmp/bundle-locks +COPY tools/ci/bundle_lock.py /tmp/bundle-lock-compiler.py + +RUN test "$(uv --version)" = "uv 0.9.28" \ + && .venv/bin/python -m sie_server.bundle_lock check \ + --lock-dir /tmp/bundle-locks --bundles-dir /app/bundles \ + --root-lock /tmp/uv.lock --compiler /tmp/bundle-lock-compiler.py --platform cuda13 \ + --bundle "${BUNDLE}" --architecture "${TARGETARCH}" + +# COVERAGE NOTE: the cu130 bundle-libs overlay shadows a cu12 Torch in the +# base venv. CPU image checks do not prove GPU namespace isolation: a cu130 +# missing nvidia submodule can fall through to a cu12 .so at first decode. +# The saved closure and inventory do not replace live GPU validation of this +# dual-Torch configuration (removing the base carry remains separate work). # -# COVERAGE NOTE: the CUDA 13 image CI callers -# builds this image and asserts on CPU that the bundle-libs cu130 overlay -# SHADOWS the base venv (import torch -> 2.11+cu130, transformers 5.x). It does -# NOT exercise GPU init: the cu12 base venv + cu130 bundle-libs both expose the -# ``nvidia/`` namespace package, and a cu130-missing submodule could in theory -# fall through to a cu12 ``.so`` at first decode. That dual-torch GPU path is -# covered only by live GPU runs (Modal; first release health-check) — slimming -# torch out of sie-server core to remove the carry is the tracked fix (#1415). -# UV_NO_CACHE=0 makes the --mount uv cache effective; UV_COMPILE_BYTECODE=0 for -# --no-compile parity. UV_HTTP_TIMEOUT=600 raises uv's per-request timeout from -# the 30s default: the cu130 closure pulls several very large NVIDIA wheels from -# pypi.nvidia.com (cufft ~204 MB, cusolver ~191 MB, nccl/cusparselt/nvshmem -# 130-190 MB), and downloading them concurrently over a congested link exceeds -# 30s, which previously failed the build with "nvidia-nvshmem-cu13 ... operation -# timed out" after retries. -RUN --mount=type=cache,target=/root/.cache/pip \ - --mount=type=cache,target=/root/.cache/uv \ - mkdir -p /app/bundle-libs; \ - if [ -s /tmp/bundle-requirements.txt ]; then \ - UV_NO_CACHE=0 UV_COMPILE_BYTECODE=0 UV_HTTP_TIMEOUT=600 uv pip install \ - --python /app/.venv/bin/python \ - --target=/app/bundle-libs \ - --index-strategy unsafe-best-match \ - --prerelease=allow \ - --extra-index-url https://download.pytorch.org/whl/cu130 \ - --extra-index-url https://docs.sglang.ai/whl/cu130/ \ - --constraint /tmp/bundle-constraints.txt \ - -r /tmp/bundle-requirements.txt ; \ - fi +# PEP751 supplies exact versions, wheel/archive hashes and VCS commits. There +# is no fresh dependency resolution against a moving index during installation. +# Source builds may still use build-time dependencies; those and the base venv +# are outside this runtime-overlay inventory contract. +RUN --mount=type=cache,target=/root/.cache/uv \ + UV_NO_CACHE=0 UV_COMPILE_BYTECODE=0 UV_HTTP_TIMEOUT=600 uv pip sync \ + --no-config --python /app/.venv/bin/python \ + --target /app/bundle-libs \ + "/tmp/bundle-locks/cuda13-${BUNDLE}-${TARGETARCH}/pylock.toml" \ + && .venv/bin/python -m sie_server.bundle_lock verify \ + --lock-dir /tmp/bundle-locks --bundles-dir /app/bundles \ + --root-lock /tmp/uv.lock --compiler /tmp/bundle-lock-compiler.py --platform cuda13 \ + --bundle "${BUNDLE}" --architecture "${TARGETARCH}" \ + --installed /app/bundle-libs --receipt /app/bundle-libs-inventory.json # bundle-libs cleanup (symmetric to the .venv cleanup in base). Preserve # dist-info RECORD files so tvm_ffi can find xgrammar's native binding. @@ -216,7 +197,7 @@ RUN set -eux; \ fi; \ find /app/bundle-libs -exec touch -h -d @0 {} + 2>/dev/null || true; \ /app/.venv/bin/pip freeze --path /app/bundle-libs > /app/bundle-libs-freeze.txt; \ - touch -d @0 /app/bundle-libs-freeze.txt + touch -d @0 /app/bundle-libs-freeze.txt /app/bundle-libs-inventory.json # ============================================================================= # Runtime image (CUDA 13 devel — nvcc for flashinfer/tvm_ffi first-decode JIT) @@ -283,6 +264,7 @@ COPY --link --from=base --chown=1000:1000 /app/bundles /app/bundles # Bundle-specific extras — last layer so shared layers above stay cached. COPY --link --from=builder --chown=1000:1000 /app/bundle-libs /app/bundle-libs COPY --link --from=builder --chown=1000:1000 /app/bundle-libs-freeze.txt /app/bundle-libs-freeze.txt +COPY --link --from=builder --chown=1000:1000 /app/bundle-libs-inventory.json /app/bundle-libs-inventory.json RUN mkdir -p /app/evals /app/.cache/huggingface /app/.cache/sie-kernels /app/.cache/sie \ && chown -R sie:sie /app/evals /app/.cache \ diff --git a/packages/sie_server/bundle-locks/README.md b/packages/sie_server/bundle-locks/README.md new file mode 100644 index 000000000..0d6bad7ff --- /dev/null +++ b/packages/sie_server/bundle-locks/README.md @@ -0,0 +1,84 @@ +# Saved bundle dependency closures + +Each target directory fixes the complete runtime distribution set installed in +`/app/bundle-libs`: exact versions, public artifact URLs and SHA256 hashes, or an +exact Git commit. It includes dependencies absent from the root `uv.lock`. +Image builds consume `pylock.toml` with the pinned uv 0.9.28 installer; they do +not resolve the overlay again from ranged bundle declarations. + +The target set is the 11 Linux amd64 release-matrix combinations plus separate +CPU arm64 locks for `default`, `ctranslate2`, `sglang`, and `transformers5`. +Python 3.12 and the target architecture are part of each manifest. An image +combination without a saved lock fails before installation. + +## Boundary and receipts + +This contract covers the runtime distribution inventory of `bundle-libs`. +It does **not** make the whole image reproducible. The base `.venv`, operating +system packages, native audio-prep build, Python image, and build dependencies +used for an sdist/VCS package remain separate inputs. Repeated source builds +can differ even when the source commit and runtime inventory are fixed. + +CUDA 13 still overlays cu130 Torch on a base environment containing cu12 Torch. +A saved inventory or CPU import check does not establish GPU namespace +isolation; a missing cu130 `nvidia` submodule may fall through to the base. +Live GPU qualification remains separate from lock validation. + +Before installing, the verifier binds the lock to the root lock, resolved +bundle declarations, target, uv version, exact exception manifest, and the +compiler/verifier/declaration-resolver source hashes. After installation it +checks the actual distribution set, versions, dependency metadata, requested +extras, and recorded direct-source identities without importing package code. +Missing, additional, duplicate, incompatible, or substituted distributions fail +the build. The runtime image retains both `/app/bundle-libs-inventory.json` and +the existing `/app/bundle-libs-freeze.txt`. + +The installer verifies artifact hashes. Installed PEP610 metadata is a separate +check: uv 0.9.28 records a direct archive URL with an empty `archive_info` hash +table. The verifier checks the URL and any recorded hash; it does not claim +that installed metadata independently proves the downloaded bytes. VCS URLs +and resolved commits must match exactly. + +## Root pins and deliberate differences + +All compatible root versions constrain compilation. `exceptions.json` records +every target-specific version or source difference with an exact version, +artifact-set fingerprint, and reason. An unexplained new difference or stale +exception fails validation. Packages missing from the root lock still receive +full version/source locks here. + +The existing index routes are preserved. In particular, the CUDA 12 PyPI +Torch 2.9.1 wheel requires CUDA 12.8 NVIDIA packages while the root Linux Torch +build uses cu129. Their exact differences are explicit. CPU/cu130 wheel variants +and engine-required Transformers, Torch, and related versions are also explicit. +Same-byte public mirrors and a root entry without artifact records are labeled +source differences; they are not reported as dependency incompatibilities. + +## Validation and updates + +From a bootstrapped clean checkout: + +```console +mise exec -- uv run --frozen --no-sync python tools/ci/bundle_lock.py check +mise install uv@0.9.28 +SIE_RUN_IMAGE_RESOLUTION=1 mise exec --no-deps uv@0.9.28 -- uv run --frozen --no-sync pytest -q packages/sie_server/tests/core/test_bundle_image_resolution.py +``` + +The required Bundle resolution CI job runs these checks for all 15 targets. +Its dry runs check the actual saved-lock reader without installing model +packages. Image builds perform the additional installed-inventory check. + +For an intentional update, first review any new root/bundle conflicts and edit +the exact exception records. Compile with an explicit cutoff using only public +indexes, then review the complete lock and manifest diff: + +```console +mise exec --no-deps uv@0.9.28 -- uv run --frozen --no-sync python tools/ci/bundle_lock.py compile --target cpu-default-amd64 --exclude-newer 2026-10-18T00:00:00Z +``` + +The compiler rejects a different uv version and strips ambient pip/uv index, +override, and hash-bypass settings. Some public mirror entries omit hashes even +with `--generate-hashes`; during explicit compilation the helper downloads at +most 64 MiB per missing artifact and records its SHA256. A missing/oversized +artifact fails instead of saving an unhashed lock. Changing compiler policy +requires reviewing regenerated manifests, even if package versions stay equal. diff --git a/packages/sie_server/bundle-locks/cpu-ctranslate2-amd64/manifest.json b/packages/sie_server/bundle-locks/cpu-ctranslate2-amd64/manifest.json new file mode 100644 index 000000000..fc024c5f6 --- /dev/null +++ b/packages/sie_server/bundle-locks/cpu-ctranslate2-amd64/manifest.json @@ -0,0 +1,28 @@ +{ + "completed_artifact_hashes": [], + "exceptions_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", + "exclude_newer": "2026-10-18T00:00:00Z", + "indexes": [ + "--default-index", + "https://pypi.org/simple", + "--index", + "https://download.pytorch.org/whl/cpu", + "--index-strategy", + "unsafe-best-match" + ], + "inputs": { + "requirements_sha256": "06013808500bdd0b62b916d46f4b7a308290f5c07567315faf967cfe9f7f5888", + "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" + }, + "lock_sha256": "1f2350156ca95ae0ed398f20d94458135d6c9ac1fd4985419e1ea6873576e718", + "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "schema_version": 1, + "target": { + "architecture": "amd64", + "bundle": "ctranslate2", + "platform": "cpu", + "python_platform": "x86_64-manylinux_2_35", + "python_version": "3.12" + }, + "uv_version": "0.9.28" +} diff --git a/packages/sie_server/bundle-locks/cpu-ctranslate2-amd64/pylock.toml b/packages/sie_server/bundle-locks/cpu-ctranslate2-amd64/pylock.toml new file mode 100644 index 000000000..c90321074 --- /dev/null +++ b/packages/sie_server/bundle-locks/cpu-ctranslate2-amd64/pylock.toml @@ -0,0 +1,26 @@ +lock-version = "1.0" +created-by = "uv" +requires-python = ">=3.12" + +[[packages]] +name = "ctranslate2" +version = "4.8.1" +wheels = [{ url = "https://files.pythonhosted.org/packages/47/c9/976a565398a03fb2973cbe5edd5ca03c4332d86b634799e0ee562420d3bc/ctranslate2-4.8.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-03T12:39:20Z, size = 39529060, hashes = { sha256 = "dacc408f716ebc73b3b3c6ddd937700e776c4c68b6d9c81862990150ff0f6af6" } }] + +[[packages]] +name = "numpy" +version = "2.4.4" +sdist = { url = "https://files.pythonhosted.org/packages/d7/9f/b8cef5bffa569759033adda9481211426f12f53299629b410340795c2514/numpy-2.4.4.tar.gz", upload-time = 2026-03-29T13:22:01Z, size = 20731587, hashes = { sha256 = "2d390634c5182175533585cc89f3608a4682ccb173cc9bb940b2881c8d6f8fa0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0a/0d/0e3ecece05b7a7e87ab9fb587855548da437a061326fff64a223b6dcb78a/numpy-2.4.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-29T13:19:03Z, size = 16645480, hashes = { sha256 = "81f4a14bee47aec54f883e0cad2d73986640c1590eb9bfaaba7ad17394481e6e" } }] + +[[packages]] +name = "pyyaml" +version = "6.0.3" +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", upload-time = 2025-09-25T21:33:16Z, size = 130960, hashes = { sha256 = "d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-09-25T21:32:16Z, size = 807870, hashes = { sha256 = "ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc" } }] + +[[packages]] +name = "setuptools" +version = "83.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/34/26/f5d29e25ffdb535afef2d35cdb55b325298f96debd670da4c325e08d70f4/setuptools-83.0.0.tar.gz", upload-time = 2026-07-04T15:31:22Z, size = 1154254, hashes = { sha256 = "025bccbbf0fa05b6192bc64ae1e7b16e001fd6d6d4d5de03c97b1c1ade523bef" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5d/40/e1e72872c6354b306daef1703549e8e83b4d43cfea356311bf722a043752/setuptools-83.0.0-py3-none-any.whl", upload-time = 2026-07-04T15:31:20Z, size = 1008090, hashes = { sha256 = "29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3" } }] diff --git a/packages/sie_server/bundle-locks/cpu-ctranslate2-arm64/manifest.json b/packages/sie_server/bundle-locks/cpu-ctranslate2-arm64/manifest.json new file mode 100644 index 000000000..327b65287 --- /dev/null +++ b/packages/sie_server/bundle-locks/cpu-ctranslate2-arm64/manifest.json @@ -0,0 +1,28 @@ +{ + "completed_artifact_hashes": [], + "exceptions_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", + "exclude_newer": "2026-10-18T00:00:00Z", + "indexes": [ + "--default-index", + "https://pypi.org/simple", + "--index", + "https://download.pytorch.org/whl/cpu", + "--index-strategy", + "unsafe-best-match" + ], + "inputs": { + "requirements_sha256": "06013808500bdd0b62b916d46f4b7a308290f5c07567315faf967cfe9f7f5888", + "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" + }, + "lock_sha256": "1bc8a0f417323c67420e71cf16b71e562c7db5842b50d4c5cd60efea8106141b", + "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "schema_version": 1, + "target": { + "architecture": "arm64", + "bundle": "ctranslate2", + "platform": "cpu", + "python_platform": "aarch64-manylinux_2_35", + "python_version": "3.12" + }, + "uv_version": "0.9.28" +} diff --git a/packages/sie_server/bundle-locks/cpu-ctranslate2-arm64/pylock.toml b/packages/sie_server/bundle-locks/cpu-ctranslate2-arm64/pylock.toml new file mode 100644 index 000000000..f5f1046c0 --- /dev/null +++ b/packages/sie_server/bundle-locks/cpu-ctranslate2-arm64/pylock.toml @@ -0,0 +1,26 @@ +lock-version = "1.0" +created-by = "uv" +requires-python = ">=3.12" + +[[packages]] +name = "ctranslate2" +version = "4.8.1" +wheels = [{ url = "https://files.pythonhosted.org/packages/2c/d4/03428106134a0a58922461074f8942f92c5ed0bb3a8d018677ad64a9c476/ctranslate2-4.8.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-07-03T12:39:17Z, size = 16882768, hashes = { sha256 = "5ca144b93035b9f53e6d67b7cdf5802c3fffca9aa0247940eecbd4592c68ce2f" } }] + +[[packages]] +name = "numpy" +version = "2.4.4" +sdist = { url = "https://files.pythonhosted.org/packages/d7/9f/b8cef5bffa569759033adda9481211426f12f53299629b410340795c2514/numpy-2.4.4.tar.gz", upload-time = 2026-03-29T13:22:01Z, size = 20731587, hashes = { sha256 = "2d390634c5182175533585cc89f3608a4682ccb173cc9bb940b2881c8d6f8fa0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7f/37/eed308a8f56cba4d1fdf467a4fc67ef4ff4bf1c888f5fc980481890104b1/numpy-2.4.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-03-29T13:19:00Z, size = 15670666, hashes = { sha256 = "f9e75681b59ddaa5e659898085ae0eaea229d054f2ac0c7e563a62205a700121" } }] + +[[packages]] +name = "pyyaml" +version = "6.0.3" +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", upload-time = 2025-09-25T21:33:16Z, size = 130960, hashes = { sha256 = "d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2025-09-25T21:32:13Z, size = 775116, hashes = { sha256 = "9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28" } }] + +[[packages]] +name = "setuptools" +version = "83.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/34/26/f5d29e25ffdb535afef2d35cdb55b325298f96debd670da4c325e08d70f4/setuptools-83.0.0.tar.gz", upload-time = 2026-07-04T15:31:22Z, size = 1154254, hashes = { sha256 = "025bccbbf0fa05b6192bc64ae1e7b16e001fd6d6d4d5de03c97b1c1ade523bef" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5d/40/e1e72872c6354b306daef1703549e8e83b4d43cfea356311bf722a043752/setuptools-83.0.0-py3-none-any.whl", upload-time = 2026-07-04T15:31:20Z, size = 1008090, hashes = { sha256 = "29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3" } }] diff --git a/packages/sie_server/bundle-locks/cpu-default-amd64/manifest.json b/packages/sie_server/bundle-locks/cpu-default-amd64/manifest.json new file mode 100644 index 000000000..d5f1cf9ab --- /dev/null +++ b/packages/sie_server/bundle-locks/cpu-default-amd64/manifest.json @@ -0,0 +1,39 @@ +{ + "completed_artifact_hashes": [ + { + "bytes": 134899, + "sha256": "85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", + "url": "https://download.pytorch.org/whl/jinja2-3.1.6-py3-none-any.whl" + }, + { + "bytes": 22947, + "sha256": "d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", + "url": "https://download.pytorch.org/whl/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl" + } + ], + "exceptions_sha256": "255cb27de28343d5b9fe46ed86874e7ec150450b3849330851adc5ec16830709", + "exclude_newer": "2026-10-18T00:00:00Z", + "indexes": [ + "--default-index", + "https://pypi.org/simple", + "--index", + "https://download.pytorch.org/whl/cpu", + "--index-strategy", + "unsafe-best-match" + ], + "inputs": { + "requirements_sha256": "397c01d0c898fe61f36cd06392478cf6dd42a41190a7516767b7cfe3dde5bb6e", + "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" + }, + "lock_sha256": "3ef32d5d618de1e61ab62c2077e07a16f09053cb992cab9606ce02e584c79652", + "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "schema_version": 1, + "target": { + "architecture": "amd64", + "bundle": "default", + "platform": "cpu", + "python_platform": "x86_64-manylinux_2_35", + "python_version": "3.12" + }, + "uv_version": "0.9.28" +} diff --git a/packages/sie_server/bundle-locks/cpu-default-amd64/pylock.toml b/packages/sie_server/bundle-locks/cpu-default-amd64/pylock.toml new file mode 100644 index 000000000..a51a44e9b --- /dev/null +++ b/packages/sie_server/bundle-locks/cpu-default-amd64/pylock.toml @@ -0,0 +1,889 @@ +lock-version = "1.0" +created-by = "uv" +requires-python = ">=3.12" + +[[packages]] +name = "accelerate" +version = "1.15.0" +sdist = { url = "https://files.pythonhosted.org/packages/f5/b5/1d3ed029ac71d3f2961346829a268da923698e9fd63f218f78841f216bfd/accelerate-1.15.0.tar.gz", upload-time = 2026-09-09T13:04:49Z, size = 422615, hashes = { sha256 = "5654f8c5eaa0d4fa68b33e287a97765da6849bf6d51dcac874e73fbbddfb6134" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8a/4c/34f0450479d01195027260da68d8a3880683f1640c3ca5adf64acb3185f1/accelerate-1.15.0-py3-none-any.whl", upload-time = 2026-09-09T13:04:47Z, size = 394295, hashes = { sha256 = "97eacca0b73e45cb867dbf8c5d5d4dc32219544300e0c8992c7334dc2ef33cec" } }] + +[[packages]] +name = "aiohappyeyeballs" +version = "2.6.1" +sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", upload-time = 2025-03-12T01:42:48Z, size = 22760, hashes = { sha256 = "c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", upload-time = 2025-03-12T01:42:47Z, size = 15265, hashes = { sha256 = "f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8" } }] + +[[packages]] +name = "aiohttp" +version = "3.14.3" +sdist = { url = "https://files.pythonhosted.org/packages/58/d9/22ce5786ac0c1653ae8b6c23bded02c1686d11f0dbb45b31ce128e0df985/aiohttp-3.14.3.tar.gz", upload-time = 2026-07-23T01:57:27Z, size = 7971213, hashes = { sha256 = "9491196535a88924a60afd5b5f434b5b203b6cc616250878dbdb223a8f7844bc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/52/b7/7cd31f29d6055bd711ae6e669367fba6f5ae9de463910a793e30556a8db7/aiohttp-3.14.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-23T01:54:15Z, size = 1792122, hashes = { sha256 = "543906c127fb1d929b95076db19b83fa2d46751006ff1e23b093aa5ac4d8db42" } }] + +[[packages]] +name = "aiosignal" +version = "1.4.0" +sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", upload-time = 2025-07-03T22:54:43Z, size = 25007, hashes = { sha256 = "f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", upload-time = 2025-07-03T22:54:42Z, size = 7490, hashes = { sha256 = "053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e" } }] + +[[packages]] +name = "annotated-doc" +version = "0.0.4" +sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", upload-time = 2025-11-10T22:07:42Z, size = 7288, hashes = { sha256 = "fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", upload-time = 2025-11-10T22:07:40Z, size = 5303, hashes = { sha256 = "571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320" } }] + +[[packages]] +name = "annotated-types" +version = "0.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", upload-time = 2024-05-20T21:33:25Z, size = 16081, hashes = { sha256 = "aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", upload-time = 2024-05-20T21:33:24Z, size = 13643, hashes = { sha256 = "1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53" } }] + +[[packages]] +name = "antlr4-python3-runtime" +version = "4.9.3" +sdist = { url = "https://files.pythonhosted.org/packages/3e/38/7859ff46355f76f8d19459005ca000b6e7012f2f1ca597746cbcd1fbfe5e/antlr4-python3-runtime-4.9.3.tar.gz", upload-time = 2021-11-06T17:52:23Z, size = 117034, hashes = { sha256 = "f224469b4168294902bb1efa80a8bf7855f24c99aef99cbefc1bcd3cce77881b" } } + +[[packages]] +name = "anyio" +version = "4.14.2" +sdist = { url = "https://files.pythonhosted.org/packages/61/cc/a381afa6efea9f496eff839d4a6a1aed3bfafc7b3ab4b0d1b243a12573dd/anyio-4.14.2.tar.gz", upload-time = 2026-07-12T20:29:07Z, size = 260176, hashes = { sha256 = "cfa139f3ed1a23ee8f88a145ddb5ac7605b8bbfd8592baacd7ce3d8bb4313c7f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/da/35/f2287558c17e29fafc8ef3daf819bb9834061cfa43bff8014f7df7f63bdc/anyio-4.14.2-py3-none-any.whl", upload-time = 2026-07-12T20:29:05Z, size = 125813, hashes = { sha256 = "9f505dda5ac9f0c8309b5e8bd445a8c2bf7246f3ce950121e45ea15bc41d1494" } }] + +[[packages]] +name = "attrs" +version = "26.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", upload-time = 2026-03-19T14:22:25Z, size = 952055, hashes = { sha256 = "d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", upload-time = 2026-03-19T14:22:23Z, size = 67548, hashes = { sha256 = "c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309" } }] + +[[packages]] +name = "beautifulsoup4" +version = "4.14.3" +sdist = { url = "https://files.pythonhosted.org/packages/c3/b0/1c6a16426d389813b48d95e26898aff79abbde42ad353958ad95cc8c9b21/beautifulsoup4-4.14.3.tar.gz", upload-time = 2025-11-30T15:08:26Z, size = 627737, hashes = { sha256 = "6292b1c5186d356bba669ef9f7f051757099565ad9ada5dd630bd9de5fa7fb86" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1a/39/47f9197bdd44df24d67ac8893641e16f386c984a0619ef2ee4c51fbbc019/beautifulsoup4-4.14.3-py3-none-any.whl", upload-time = 2025-11-30T15:08:24Z, size = 107721, hashes = { sha256 = "0918bfe44902e6ad8d57732ba310582e98da931428d231a5ecb9e7c703a735bb" } }] + +[[packages]] +name = "cbor" +version = "1.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/9b/99/01c6a987c920500189eb74a291bd3a388e6c7cf85736bb6b066d9833315e/cbor-1.0.0.tar.gz", upload-time = 2016-02-09T23:11:12Z, size = 20096, hashes = { sha256 = "13225a262ddf5615cbd9fd55a76a0d53069d18b07d2e9f19c39e6acb8609bbb6" } } + +[[packages]] +name = "certifi" +version = "2026.4.22" +sdist = { url = "https://files.pythonhosted.org/packages/25/ee/6caf7a40c36a1220410afe15a1cc64993a1f864871f698c0f93acb72842a/certifi-2026.4.22.tar.gz", upload-time = 2026-04-22T11:26:11Z, size = 137077, hashes = { sha256 = "8d455352a37b71bf76a79caa83a3d6c25afee4a385d632127b6afb3963f1c580" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/22/30/7cd8fdcdfbc5b869528b079bfb76dcdf6056b1a2097a662e5e8c04f42965/certifi-2026.4.22-py3-none-any.whl", upload-time = 2026-04-22T11:26:09Z, size = 135707, hashes = { sha256 = "3cb2210c8f88ba2318d29b0388d1023c8492ff72ecdde4ebdaddbb13a31b1c4a" } }] + +[[packages]] +name = "charset-normalizer" +version = "3.4.7" +sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", upload-time = 2026-04-02T09:28:39Z, size = 144271, hashes = { sha256 = "ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4b/f8/d0118a2f5f23b02cd166fa385c60f9b0d4f9194f574e2b31cef350ad7223/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-02T09:26:29Z, size = 216589, hashes = { sha256 = "5649fd1c7bade02f320a462fdefd0b4bd3ce036065836d4f42e0de958038e116" } }, + { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", upload-time = 2026-04-02T09:28:37Z, size = 61958, hashes = { sha256 = "3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d" } }, +] + +[[packages]] +name = "click" +version = "8.1.8" +sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", upload-time = 2024-12-21T18:38:44Z, size = 226593, hashes = { sha256 = "ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", upload-time = 2024-12-21T18:38:41Z, size = 98188, hashes = { sha256 = "63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2" } }] + +[[packages]] +name = "colorlog" +version = "6.10.1" +sdist = { url = "https://files.pythonhosted.org/packages/a2/61/f083b5ac52e505dfc1c624eafbf8c7589a0d7f32daa398d2e7590efa5fda/colorlog-6.10.1.tar.gz", upload-time = 2025-10-16T16:14:11Z, size = 17162, hashes = { sha256 = "eb4ae5cb65fe7fec7773c2306061a8e63e02efc2c72eba9d27b0fa23c94f1321" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/6d/c1/e419ef3723a074172b68aaa89c9f3de486ed4c2399e2dbd8113a4fdcaf9e/colorlog-6.10.1-py3-none-any.whl", upload-time = 2025-10-16T16:14:10Z, size = 11743, hashes = { sha256 = "2d7e8348291948af66122cff006c9f8da6255d224e7cf8e37d8de2df3bad8c9c" } }] + +[[packages]] +name = "datasets" +version = "3.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/1a/89/d3d6fef58a488f8569c82fd293ab7cbd4250244d67f425dcae64c63800ea/datasets-3.6.0.tar.gz", upload-time = 2025-05-07T15:15:02Z, size = 569336, hashes = { sha256 = "1b2bf43b19776e2787e181cfd329cb0ca1a358ea014780c3581e0f276375e041" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/20/34/a08b0ee99715eaba118cbe19a71f7b5e2425c2718ef96007c325944a1152/datasets-3.6.0-py3-none-any.whl", upload-time = 2025-05-07T15:14:59Z, size = 491546, hashes = { sha256 = "25000c4a2c0873a710df127d08a202a06eab7bf42441a6bc278b499c2f72cd1b" } }] + +[[packages]] +name = "defusedxml" +version = "0.7.1" +sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", upload-time = 2021-03-08T10:59:26Z, size = 75520, hashes = { sha256 = "1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", upload-time = 2021-03-08T10:59:24Z, size = 25604, hashes = { sha256 = "a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61" } }] + +[[packages]] +name = "dill" +version = "0.3.8" +sdist = { url = "https://files.pythonhosted.org/packages/17/4d/ac7ffa80c69ea1df30a8aa11b3578692a5118e7cd1aa157e3ef73b092d15/dill-0.3.8.tar.gz", upload-time = 2024-01-27T23:42:16Z, size = 184847, hashes = { sha256 = "3ebe3c479ad625c4553aca177444d89b486b1d84982eeacded644afc0cf797ca" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c9/7a/cef76fd8438a42f96db64ddaa85280485a9c395e7df3db8158cfec1eee34/dill-0.3.8-py3-none-any.whl", upload-time = 2024-01-27T23:42:14Z, size = 116252, hashes = { sha256 = "c36ca9ffb54365bdd2f8eb3eff7d2a21237f8452b57ace88b1ac615b7e815bd7" } }] + +[[packages]] +name = "docling" +version = "2.99.0" +sdist = { url = "https://files.pythonhosted.org/packages/61/73/f6a0d6ada626281c1914dfb2de30c6e0067b1f8e3993e77eabb05fb08bf6/docling-2.99.0.tar.gz", upload-time = 2026-06-08T15:14:20Z, size = 8755, hashes = { sha256 = "306ea071d935f3852f75c873fe1b8663da580d2c359b8de162da52a6151c4c91" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/05/cc/cd8bea43057e64ec7755a18e009270500263f513e058649b909e83e2c0a7/docling-2.99.0-py3-none-any.whl", upload-time = 2026-06-08T15:14:19Z, size = 4798, hashes = { sha256 = "a78d4fd34e4ca495cd50003288b4de4a9b040dbff59f8ca5624aa8fa37d43728" } }] + +[[packages]] +name = "docling-core" +version = "2.79.0" +sdist = { url = "https://files.pythonhosted.org/packages/4d/b3/9196498f28c5a872b76b356df3ccefc20f2978eea12b8459a3398d036a2e/docling_core-2.79.0.tar.gz", upload-time = 2026-06-05T17:48:55Z, size = 334965, hashes = { sha256 = "3a5c6f757a95b93a1bb4c2c46efbe580f35a390f762a4b4105d97b7fca7cdfeb" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d0/f2/2cbf2b8ba8f2ebdefa5ebed29cf1d2eb4306a57ebf6c8b98703b7d4e2054/docling_core-2.79.0-py3-none-any.whl", upload-time = 2026-06-05T17:48:53Z, size = 286672, hashes = { sha256 = "42540cbd7ff8bca264e8e8fda9a66ad4446613f520bee8e130588193bc3e0212" } }] + +[[packages]] +name = "docling-ibm-models" +version = "3.13.2" +sdist = { url = "https://files.pythonhosted.org/packages/c1/25/84166f5751d7837612138966669019a4ef67c09bf6d3ef8d3cc1aa0e6268/docling_ibm_models-3.13.2.tar.gz", upload-time = 2026-04-23T11:04:23Z, size = 98655, hashes = { sha256 = "195e02dd119df34d2ce5f76ac614da82825851013e4898db7b0468cdf8740a3d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a4/fc/584f75ca31aa6694fed5338ecb54dc4c8341704b1e5b7b6a4528651f12fa/docling_ibm_models-3.13.2-py3-none-any.whl", upload-time = 2026-04-23T11:04:22Z, size = 94013, hashes = { sha256 = "5fa0838bf15a4e06d2fcb686d756a6f4c329ea0a8820d085f06d07abe96269ed" } }] + +[[packages]] +name = "docling-parse" +version = "6.2.0" +sdist = { url = "https://files.pythonhosted.org/packages/64/46/2c9c0738452368ad63018f380f4ad6fad8c69b64f04222aa012190bc8a4f/docling_parse-6.2.0.tar.gz", upload-time = 2026-05-28T04:31:53Z, size = 6670444, hashes = { sha256 = "f13d6c49e3b5f9caaf0d626e0dcc7948c5b4700d0eae0559ec353ed07c4f2f50" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3c/dd/572cde51f4c192a2752680e76fcb030cb997f656b4eea3b196fe8b7b7b2b/docling_parse-6.2.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-05-28T04:31:27Z, size = 10191025, hashes = { sha256 = "05f6b1e15408741953ee4beb61442168c3267489634ce16ebd8e9214deec621e" } }] + +[[packages]] +name = "docling-slim" +version = "2.99.0" +sdist = { url = "https://files.pythonhosted.org/packages/a3/10/42e81debe1b7db6ae6dbbcd41f90f2aaa59501a1089fe9f304821783c409/docling_slim-2.99.0.tar.gz", upload-time = 2026-06-08T15:12:53Z, size = 410480, hashes = { sha256 = "b05150cda69e4c24c85aa32d2e329f21188dd4304547928eab32d8bb8b645bba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1c/d8/caa986a093c89238cc4019e10885677ffe4ee7aeb46a807626ac18654dfb/docling_slim-2.99.0-py3-none-any.whl", upload-time = 2026-06-08T15:12:51Z, size = 530895, hashes = { sha256 = "f67e31ca3cc39c5b19df3cfcb8fbe7bcc5ef29ffff320bbafca56e3b9ce40f24" } }] + +[[packages]] +name = "einops" +version = "0.8.2" +sdist = { url = "https://files.pythonhosted.org/packages/2c/77/850bef8d72ffb9219f0b1aac23fbc1bf7d038ee6ea666f331fa273031aa2/einops-0.8.2.tar.gz", upload-time = 2026-01-26T04:13:17Z, size = 56261, hashes = { sha256 = "609da665570e5e265e27283aab09e7f279ade90c4f01bcfca111f3d3e13f2827" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/09/f8d8f8f31e4483c10a906437b4ce31bdf3d6d417b73fe33f1a8b59e34228/einops-0.8.2-py3-none-any.whl", upload-time = 2026-01-26T04:13:18Z, size = 65638, hashes = { sha256 = "54058201ac7087911181bfec4af6091bb59380360f069276601256a76af08193" } }] + +[[packages]] +name = "et-xmlfile" +version = "2.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/d3/38/af70d7ab1ae9d4da450eeec1fa3918940a5fafb9055e934af8d6eb0c2313/et_xmlfile-2.0.0.tar.gz", upload-time = 2024-10-25T17:25:40Z, size = 17234, hashes = { sha256 = "dab3f4764309081ce75662649be815c4c9081e88f0837825f90fd28317d4da54" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c1/8b/5fe2cc11fee489817272089c4203e679c63b570a5aaeb18d852ae3cbba6a/et_xmlfile-2.0.0-py3-none-any.whl", upload-time = 2024-10-25T17:25:39Z, size = 18059, hashes = { sha256 = "7a91720bc756843502c3b7504c77b8fe44217c85c537d85037f0f536151b2caa" } }] + +[[packages]] +name = "faker" +version = "40.15.0" +sdist = { url = "https://files.pythonhosted.org/packages/7f/13/6741787bd91c4109c7bed047d68273965cd52ce8a5f773c471b949334b6d/faker-40.15.0.tar.gz", upload-time = 2026-04-17T20:05:27Z, size = 1967447, hashes = { sha256 = "20f3a6ec8c266b74d4c554e34118b21c3c2056c0b4a519d15c8decb3a4e6e795" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a7/a7/a600f8f30d4505e89166de51dd121bd540ab8e560e8cf0901de00a81de8c/faker-40.15.0-py3-none-any.whl", upload-time = 2026-04-17T20:05:25Z, size = 2004447, hashes = { sha256 = "71ab3c3370da9d2205ab74ffb0fd51273063ad562b3a3bb69d0026a20923e318" } }] + +[[packages]] +name = "filelock" +version = "3.29.0" +sdist = { url = "https://files.pythonhosted.org/packages/b5/fe/997687a931ab51049acce6fa1f23e8f01216374ea81374ddee763c493db5/filelock-3.29.0.tar.gz", upload-time = 2026-04-19T15:39:10Z, size = 57571, hashes = { sha256 = "69974355e960702e789734cb4871f884ea6fe50bd8404051a3530bc07809cf90" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/81/47/dd9a212ef6e343a6857485ffe25bba537304f1913bdbed446a23f7f592e1/filelock-3.29.0-py3-none-any.whl", upload-time = 2026-04-19T15:39:08Z, size = 39812, hashes = { sha256 = "96f5f6344709aa1572bbf631c640e4ebeeb519e08da902c39a001882f30ac258" } }] + +[[packages]] +name = "filetype" +version = "1.2.0" +sdist = { url = "https://files.pythonhosted.org/packages/bb/29/745f7d30d47fe0f251d3ad3dc2978a23141917661998763bebb6da007eb1/filetype-1.2.0.tar.gz", upload-time = 2022-11-02T17:34:04Z, size = 998020, hashes = { sha256 = "66b56cd6474bf41d8c54660347d37afcc3f7d1970648de365c102ef77548aadb" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/18/79/1b8fa1bb3568781e84c9200f951c735f3f157429f44be0495da55894d620/filetype-1.2.0-py2.py3-none-any.whl", upload-time = 2022-11-02T17:34:01Z, size = 19970, hashes = { sha256 = "7ce71b6880181241cf7ac8697a2f1eb6a8bd9b429f7ad6d27b8db9ba5f1c2d25" } }] + +[[packages]] +name = "flagembedding" +version = "1.4.0" +sdist = { url = "https://files.pythonhosted.org/packages/07/51/22dc9c448577542b3c3d75ae48eda0a97dfa29552a56cddd87437fec5940/flagembedding-1.4.0.tar.gz", upload-time = 2026-04-22T16:09:54Z, size = 175024, hashes = { sha256 = "2079c14ecf0341d64519785e53c0401122a752e5b6a0ac497f23c02f0d21b3b9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/73/70/3593ccb1299f8440369fd3c542ef2f5c09718eb8c7628614303e65dd38f8/flagembedding-1.4.0-py3-none-any.whl", upload-time = 2026-04-22T16:09:52Z, size = 247714, hashes = { sha256 = "fb1856b312851591341cf4533187350e9ce43f66bbf195c66f25a73266ff7db9" } }] + +[[packages]] +name = "flatbuffers" +version = "25.12.19" +wheels = [{ url = "https://files.pythonhosted.org/packages/e8/2d/d2a548598be01649e2d46231d151a6c56d10b964d94043a335ae56ea2d92/flatbuffers-25.12.19-py2.py3-none-any.whl", upload-time = 2025-12-19T23:16:13Z, size = 26661, hashes = { sha256 = "7634f50c427838bb021c2d66a3d1168e9d199b0607e6329399f04846d42e20b4" } }] + +[[packages]] +name = "frozenlist" +version = "1.8.0" +sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", upload-time = 2025-10-06T05:38:17Z, size = 45875, hashes = { sha256 = "3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2025-10-06T05:36:09Z, size = 242411, hashes = { sha256 = "494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383" } }, + { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", upload-time = 2025-10-06T05:38:16Z, size = 13409, hashes = { sha256 = "0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d" } }, +] + +[[packages]] +name = "fsspec" +version = "2025.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/34/f4/5721faf47b8c499e776bc34c6a8fc17efdf7fdef0b00f398128bc5dcb4ac/fsspec-2025.3.0.tar.gz", upload-time = 2025-03-07T21:47:56Z, size = 298491, hashes = { sha256 = "a935fd1ea872591f2b5148907d103488fc523295e6c64b835cfad8c3eca44972" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/56/53/eb690efa8513166adef3e0669afd31e95ffde69fb3c52ec2ac7223ed6018/fsspec-2025.3.0-py3-none-any.whl", upload-time = 2025-03-07T21:47:54Z, size = 193615, hashes = { sha256 = "efb87af3efa9103f94ca91a7f8cb7a4df91af9f74fc106c9c7ea0efd7277c1b3" } }] + +[[packages]] +name = "ftfy" +version = "6.3.1" +sdist = { url = "https://files.pythonhosted.org/packages/a5/d3/8650919bc3c7c6e90ee3fa7fd618bf373cbbe55dff043bd67353dbb20cd8/ftfy-6.3.1.tar.gz", upload-time = 2024-10-26T00:50:35Z, size = 308927, hashes = { sha256 = "9b3c3d90f84fb267fe64d375a07b7f8912d817cf86009ae134aa03e1819506ec" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ab/6e/81d47999aebc1b155f81eca4477a616a70f238a2549848c38983f3c22a82/ftfy-6.3.1-py3-none-any.whl", upload-time = 2024-10-26T00:50:33Z, size = 44821, hashes = { sha256 = "7c70eb532015cd2f9adb53f101fb6c7945988d023a085d127d1573dc49dd0083" } }] + +[[packages]] +name = "gliclass" +version = "0.1.17" +sdist = { url = "https://files.pythonhosted.org/packages/f5/4d/a14af220823eccbd4f2edfff303b24f0e2acf1a0f4177318347bf0c8524e/gliclass-0.1.17.tar.gz", upload-time = 2026-04-30T14:35:58Z, size = 47472, hashes = { sha256 = "17d2ec477da2270337cad9d8ae4ae90b8c675d1bfed9c73bc77d44996d36b522" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/52/3f/0b4e6253a14af7bd1e7306f0b1a8dc6af607caa4a9868015234ee94ad27c/gliclass-0.1.17-py3-none-any.whl", upload-time = 2026-04-30T14:35:57Z, size = 48821, hashes = { sha256 = "330c89e4fb39b50cc9c62d52c44dc7c5a13303883680706c71b598ecf88ab354" } }] + +[[packages]] +name = "gliformer" +version = "0.1.2" +sdist = { url = "https://files.pythonhosted.org/packages/5e/a7/c0e8c23f576de77c3fd323a045cb56fb4d8821e7c13be7b06ca5c0435d5d/gliformer-0.1.2.tar.gz", upload-time = 2026-09-15T15:40:35Z, size = 422264, hashes = { sha256 = "7b1ae88206dcddce33dacf60f750f509d4188d07f6aa82a7df40d4a1134f800b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3c/06/49c0c4eefd7672025909359ed534a862ea8217fc1e08460ee8957d5cc25b/gliformer-0.1.2-py3-none-any.whl", upload-time = 2026-09-15T15:40:33Z, size = 435508, hashes = { sha256 = "b9a1194b56fc0ab193fef919ad68d0b3086ce2fe3f0b4392ce26873139ac8768" } }] + +[[packages]] +name = "gliner" +version = "0.2.26" +sdist = { url = "https://files.pythonhosted.org/packages/49/18/e199cb97147c4a9260c75e4caf51e17be6ff969b0604a029c9c62810cbe0/gliner-0.2.26.tar.gz", upload-time = 2026-03-19T15:07:22Z, size = 181224, hashes = { sha256 = "6783be92b4b81caa878dcc4269ba37800207c37118d8ff9be028b93bddd6813d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7c/6e/d54d3d2867e29b68a22b144f570c8204209647fccc7879cec5218d6ed5fb/gliner-0.2.26-py3-none-any.whl", upload-time = 2026-03-19T15:07:19Z, size = 170429, hashes = { sha256 = "b9baa47641efb90b9d069add0528ed2464d137991ff097f42b0cab37a91ba991" } }] + +[[packages]] +name = "gliner2" +version = "2.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/b2/a8/2dcfdb8862dbeb488b6b86047075a213cc101ca592eae1a43b824cca74dd/gliner2-2.0.0.tar.gz", upload-time = 2026-08-24T15:13:43Z, size = 565826, hashes = { sha256 = "82b149f893ba0f6adf75ef1db599b6dbecd9811cca34dbd0bac7cd9e90b90ce4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/00/44/87d2803c5c5c6c0bd22bce4d52c66c965dacae29e0121d7e04c9883711df/gliner2-2.0.0-py3-none-any.whl", upload-time = 2026-08-24T15:13:41Z, size = 326214, hashes = { sha256 = "6f7c4cba0ef3173636d8bd9404aa94d4e0ccf36d4b4b9a0d27d740dd2d3236c3" } }] + +[[packages]] +name = "glirel" +version = "1.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/aa/17/366a8bcdf3631af9f11b989c3387b952cf3fd3b786df95952e826d64374a/glirel-1.2.1.tar.gz", upload-time = 2025-04-11T10:10:58Z, size = 49623, hashes = { sha256 = "96e0636810c6f020707a515d4f08aa36b7950c7d06030b5fe149b86d716e00e4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2f/62/fce91d0f41f493d1fb69db3df828aa6c2a76390a4a38db5db6a40b3b2150/glirel-1.2.1-py3-none-any.whl", upload-time = 2025-04-11T10:10:57Z, size = 54298, hashes = { sha256 = "ecbe2f955d8f2a406931022a10753e889761de7a736ec4090187830e49689aaf" } }] + +[[packages]] +name = "h11" +version = "0.16.0" +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", upload-time = 2025-04-24T03:35:25Z, size = 101250, hashes = { sha256 = "4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", upload-time = 2025-04-24T03:35:24Z, size = 37515, hashes = { sha256 = "63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86" } }] + +[[packages]] +name = "hf-xet" +version = "1.4.3" +marker = "platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" +sdist = { url = "https://files.pythonhosted.org/packages/53/92/ec9ad04d0b5728dca387a45af7bc98fbb0d73b2118759f5f6038b61a57e8/hf_xet-1.4.3.tar.gz", upload-time = 2026-03-31T22:40:07Z, size = 670477, hashes = { sha256 = "8ddedb73c8c08928c793df2f3401ec26f95be7f7e516a7bee2fbb546f6676113" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/df/9a/a24b26dc8a65f0ecc0fe5be981a19e61e7ca963b85e062c083f3a9100529/hf_xet-1.4.3-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-03-31T22:39:42Z, size = 4212320, hashes = { sha256 = "fc360b70c815bf340ed56c7b8c63aacf11762a4b099b2fe2c9bd6d6068668c08" } }] + +[[packages]] +name = "httpcore" +version = "1.0.9" +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", upload-time = 2025-04-24T22:06:22Z, size = 85484, hashes = { sha256 = "6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", upload-time = 2025-04-24T22:06:20Z, size = 78784, hashes = { sha256 = "2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55" } }] + +[[packages]] +name = "httpx" +version = "0.28.1" +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", upload-time = 2024-12-06T15:37:23Z, size = 141406, hashes = { sha256 = "75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", upload-time = 2024-12-06T15:37:21Z, size = 73517, hashes = { sha256 = "d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad" } }] + +[[packages]] +name = "huggingface-hub" +version = "0.36.2" +sdist = { url = "https://files.pythonhosted.org/packages/7c/b7/8cb61d2eece5fb05a83271da168186721c450eb74e3c31f7ef3169fa475b/huggingface_hub-0.36.2.tar.gz", upload-time = 2026-02-06T09:24:13Z, size = 649782, hashes = { sha256 = "1934304d2fb224f8afa3b87007d58501acfda9215b334eed53072dd5e815ff7a" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a8/af/48ac8483240de756d2438c380746e7130d1c6f75802ef22f3c6d49982787/huggingface_hub-0.36.2-py3-none-any.whl", upload-time = 2026-02-06T09:24:11Z, size = 566395, hashes = { sha256 = "48f0c8eac16145dfce371e9d2d7772854a4f591bcb56c9cf548accf531d54270" } }] + +[[packages]] +name = "idna" +version = "3.17" +sdist = { url = "https://files.pythonhosted.org/packages/b9/28/99c51f664567218d824af024c0251650fb27e4ca066df188dab0769c5b91/idna-3.17.tar.gz", upload-time = 2026-05-28T14:32:38Z, size = 196048, hashes = { sha256 = "5eb0cb53bc467c12eadcf6de83163ad8527cec9416f44b9b61b19caedad2b87f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/de/a7/f76514cc40ad6234098ecdebda08732d75964776c51a42845b7da10649e2/idna-3.17-py3-none-any.whl", upload-time = 2026-05-28T14:32:37Z, size = 65316, hashes = { sha256 = "466e48829084efe2548012b855df21540b96f2e20e51bd124c851536556a592c" } }] + +[[packages]] +name = "ijson" +version = "3.5.0" +sdist = { url = "https://files.pythonhosted.org/packages/f4/57/60d1a6a512f2f0508d0bc8b4f1cc5616fd3196619b66bd6a01f9155a1292/ijson-3.5.0.tar.gz", upload-time = 2026-02-24T03:58:30Z, size = 68658, hashes = { sha256 = "94688760720e3f5212731b3cb8d30267f9a045fb38fb3870254e7b9504246f31" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/6d/81/2fee58f9024a3449aee83edfa7167fb5ccd7e1af2557300e28531bb68e16/ijson-3.5.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-02-24T03:57:14Z, size = 149729, hashes = { sha256 = "7389a56b8562a19948bdf1d7bae3a2edc8c7f86fb59834dcb1c4c722818e645a" } }] + +[[packages]] +name = "inscriptis" +version = "2.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/23/f0/77b6eeaa0cde44b8ef0d5d0c2c0ee7ddeb6e6e4aebec33e15b8d0abbf3ed/inscriptis-2.6.0.tar.gz", upload-time = 2025-03-22T18:23:26Z, size = 41620, hashes = { sha256 = "6f164bf45ea6972d61fd048a8e074d5125d215eaa837f8e70c158c97c31c3181" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5e/c4/e1a68d42fa4609231da5f14e159c3d6256fb9e2951928592cebf7c899379/inscriptis-2.6.0-py3-none-any.whl", upload-time = 2025-03-22T18:23:24Z, size = 45120, hashes = { sha256 = "654dbcd0551c2f6004f8069a05cafff3eed2d327d5057adc6e657ba2610f52af" } }] + +[[packages]] +name = "ir-datasets" +version = "0.5.11" +sdist = { url = "https://files.pythonhosted.org/packages/80/c6/f02811c51fec845ee87a10bb3675516a2d71935b203e5ddb80b7eb59b1da/ir_datasets-0.5.11.tar.gz", upload-time = 2025-06-24T07:58:31Z, size = 758463, hashes = { sha256 = "06c90af634ae5063c813286b35065debca1a974d26e136403d899f3ecd7ad463" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/81/38/73fa582d6997362d9b4901b2a8ba1177b2d2896aa59ab8d069a3884e2e0d/ir_datasets-0.5.11-py3-none-any.whl", upload-time = 2025-06-24T07:58:29Z, size = 866095, hashes = { sha256 = "ae78549e5a7fa45e50462b7acb9f0765fc344fec6054108bf3dd063050555206" } }] + +[[packages]] +name = "jinja2" +version = "3.1.6" +wheels = [{ url = "https://download.pytorch.org/whl/jinja2-3.1.6-py3-none-any.whl", upload-time = 2025-10-14T18:38:59Z, hashes = { sha256 = "85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67" } }] + +[[packages]] +name = "joblib" +version = "1.5.3" +sdist = { url = "https://files.pythonhosted.org/packages/41/f2/d34e8b3a08a9cc79a50b2208a93dce981fe615b64d5a4d4abee421d898df/joblib-1.5.3.tar.gz", upload-time = 2025-12-15T08:41:46Z, size = 331603, hashes = { sha256 = "8561a3269e6801106863fd0d6d84bb737be9e7631e33aaed3fb9ce5953688da3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7b/91/984aca2ec129e2757d1e4e3c81c3fcda9d0f85b74670a094cc443d9ee949/joblib-1.5.3-py3-none-any.whl", upload-time = 2025-12-15T08:41:44Z, size = 309071, hashes = { sha256 = "5fc3c5039fc5ca8c0276333a188bbd59d6b7ab37fe6632daa76bc7f9ec18e713" } }] + +[[packages]] +name = "jsonlines" +version = "4.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/35/87/bcda8e46c88d0e34cad2f09ee2d0c7f5957bccdb9791b0b934ec84d84be4/jsonlines-4.0.0.tar.gz", upload-time = 2023-09-01T12:34:44Z, size = 11359, hashes = { sha256 = "0c6d2c09117550c089995247f605ae4cf77dd1533041d366351f6f298822ea74" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f8/62/d9ba6323b9202dd2fe166beab8a86d29465c41a0288cbe229fac60c1ab8d/jsonlines-4.0.0-py3-none-any.whl", upload-time = 2023-09-01T12:34:42Z, size = 8701, hashes = { sha256 = "185b334ff2ca5a91362993f42e83588a360cf95ce4b71a73548502bda52a7c55" } }] + +[[packages]] +name = "jsonref" +version = "1.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/aa/0d/c1f3277e90ccdb50d33ed5ba1ec5b3f0a242ed8c1b1a85d3afeb68464dca/jsonref-1.1.0.tar.gz", upload-time = 2023-01-16T16:10:04Z, size = 8814, hashes = { sha256 = "32fe8e1d85af0fdefbebce950af85590b22b60f9e95443176adbde4e1ecea552" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0c/ec/e1db9922bceb168197a558a2b8c03a7963f1afe93517ddd3cf99f202f996/jsonref-1.1.0-py3-none-any.whl", upload-time = 2023-01-16T16:10:02Z, size = 9425, hashes = { sha256 = "590dc7773df6c21cbf948b5dac07a72a251db28b0238ceecce0a2abfa8ec30a9" } }] + +[[packages]] +name = "jsonschema" +version = "4.23.0" +sdist = { url = "https://files.pythonhosted.org/packages/38/2e/03362ee4034a4c917f697890ccd4aec0800ccf9ded7f511971c75451deec/jsonschema-4.23.0.tar.gz", upload-time = 2024-07-08T18:40:05Z, size = 325778, hashes = { sha256 = "d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/69/4a/4f9dbeb84e8850557c02365a0eee0649abe5eb1d84af92a25731c6c0f922/jsonschema-4.23.0-py3-none-any.whl", upload-time = 2024-07-08T18:40:00Z, size = 88462, hashes = { sha256 = "fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566" } }] + +[[packages]] +name = "jsonschema-specifications" +version = "2025.9.1" +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", upload-time = 2025-09-08T01:34:59Z, size = 32855, hashes = { sha256 = "b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", upload-time = 2025-09-08T01:34:57Z, size = 18437, hashes = { sha256 = "98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe" } }] + +[[packages]] +name = "latex2mathml" +version = "3.81.0" +sdist = { url = "https://files.pythonhosted.org/packages/3b/62/35bb816c5c19d4d0cde5bdfb82ebb996306243d5f94e03f201658c629960/latex2mathml-3.81.0.tar.gz", upload-time = 2026-04-15T00:55:27Z, size = 77584, hashes = { sha256 = "4b959cdc3cac8686bc0e3e5aece8127dfb1b81ca1241bed8e00ef31b82bb4022" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e8/b1/c488b530994c4f68e46efa99a4d6ca6741aaf158e35779fe6c4d8a9a427d/latex2mathml-3.81.0-py3-none-any.whl", upload-time = 2026-04-15T00:55:29Z, size = 79185, hashes = { sha256 = "d317710393fe20579aea39cfe8928fa2ad9b8780896e585326c75e89c1d1d1a4" } }] + +[[packages]] +name = "loguru" +version = "0.7.3" +sdist = { url = "https://files.pythonhosted.org/packages/3a/05/a1dae3dffd1116099471c643b8924f5aa6524411dc6c63fdae648c4f1aca/loguru-0.7.3.tar.gz", upload-time = 2024-12-06T11:20:56Z, size = 63559, hashes = { sha256 = "19480589e77d47b8d85b2c827ad95d49bf31b0dcde16593892eb51dd18706eb6" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl", upload-time = 2024-12-06T11:20:54Z, size = 61595, hashes = { sha256 = "31a33c10c8e1e10422bfd431aeb5d351c7cf7fa671e3c4df004162264b28220c" } }] + +[[packages]] +name = "lxml" +version = "6.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/28/30/9abc9e34c657c33834eaf6cd02124c61bdf5944d802aa48e69be8da3585d/lxml-6.1.0.tar.gz", upload-time = 2026-04-18T04:32:51Z, size = 4197006, hashes = { sha256 = "bfd57d8008c4965709a919c3e9a98f76c2c7cb319086b3d26858250620023b13" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/7c/e08a970727d556caa040a44773c7b7e3ad0f0d73dedc863543e9a8b931f2/lxml-6.1.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-04-18T04:32:58Z, size = 5093820, hashes = { sha256 = "9147d8e386ec3b82c3b15d88927f734f565b0aaadef7def562b853adca45784a" } }, + { url = "https://files.pythonhosted.org/packages/31/ba/3c13d3fc24b7cacf675f808a3a1baabf43a30d0cd24c98f94548e9aa58eb/lxml-6.1.0-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-18T04:33:06Z, size = 5240445, hashes = { sha256 = "bc783ee3147e60a25aa0445ea82b3e8aabb83b240f2b95d32cb75587ff781814" } }, +] + +[[packages]] +name = "lz4" +version = "4.4.5" +sdist = { url = "https://files.pythonhosted.org/packages/57/51/f1b86d93029f418033dddf9b9f79c8d2641e7454080478ee2aab5123173e/lz4-4.4.5.tar.gz", upload-time = 2025-11-03T13:02:36Z, size = 172886, hashes = { sha256 = "5f0b9e53c1e82e88c10d7c180069363980136b9d7a8306c4dca4f760d60c39f0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/55/d9/e3867222474f6c1b76e89f3bd914595af69f55bf2c1866e984c548afdc15/lz4-4.4.5-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-11-03T13:01:51Z, size = 1368249, hashes = { sha256 = "24092635f47538b392c4eaeff14c7270d2c8e806bf4be2a6446a378591c5e69e" } }] + +[[packages]] +name = "mail-parser" +version = "4.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/01/6b/55b188888abccfc1dba0617a6d99da1c39dc355822900ae9d5bccf8756b2/mail_parser-4.3.0.tar.gz", upload-time = 2026-05-27T22:15:14Z, size = 2792149, hashes = { sha256 = "fb4c64ec0a74ed095b3bad274ab08f6fca024ad5fbf72ff9ccc501ba654ba3b2" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8d/4f/38717202a3be94a37c262907adca700498fbb435a8356cfaed38387469c8/mail_parser-4.3.0-py3-none-any.whl", upload-time = 2026-05-27T22:15:13Z, size = 33895, hashes = { sha256 = "e4092a15023b7075f4666f5040e2fca71fa35a7020753b7e90359c357ed3a099" } }] + +[[packages]] +name = "markdown-it-py" +version = "4.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", upload-time = 2025-08-11T12:57:52Z, size = 73070, hashes = { sha256 = "cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", upload-time = 2025-08-11T12:57:51Z, size = 87321, hashes = { sha256 = "87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147" } }] + +[[packages]] +name = "marko" +version = "2.2.2" +sdist = { url = "https://files.pythonhosted.org/packages/e3/2f/050b6d485f052ddf17d76a41f9334d6fb2a8a85df35347a12d97ed3bc5c1/marko-2.2.2.tar.gz", upload-time = 2026-01-05T11:04:41Z, size = 143641, hashes = { sha256 = "6940308e655f63733ca518c47a68ec9510279dbb916c83616e4c4b5829f052e8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/83/f8/36d79bac5701e6786f9880c61bbe57574760a13c1af84ab71e5ed21faecc/marko-2.2.2-py3-none-any.whl", upload-time = 2026-01-05T11:04:40Z, size = 42701, hashes = { sha256 = "f064ae8c10416285ad1d96048dc11e98ef04e662d3342ae416f662b70aa7959e" } }] + +[[packages]] +name = "markupsafe" +version = "3.0.3" +wheels = [{ url = "https://download.pytorch.org/whl/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-27T13:54:35Z, hashes = { sha256 = "d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d" } }] + +[[packages]] +name = "mdurl" +version = "0.1.2" +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", upload-time = 2022-08-14T12:40:10Z, size = 8729, hashes = { sha256 = "bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", upload-time = 2022-08-14T12:40:09Z, size = 9979, hashes = { sha256 = "84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8" } }] + +[[packages]] +name = "mpire" +version = "2.10.2" +sdist = { url = "https://files.pythonhosted.org/packages/3a/93/80ac75c20ce54c785648b4ed363c88f148bf22637e10c9863db4fbe73e74/mpire-2.10.2.tar.gz", upload-time = 2024-05-07T14:00:31Z, size = 271270, hashes = { sha256 = "f66a321e93fadff34585a4bfa05e95bd946cf714b442f51c529038eb45773d97" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/20/14/1db1729ad6db4999c3a16c47937d601fcb909aaa4224f5eca5a2f145a605/mpire-2.10.2-py3-none-any.whl", upload-time = 2024-05-07T14:00:29Z, size = 272756, hashes = { sha256 = "d627707f7a8d02aa4c7f7d59de399dec5290945ddf7fbd36cbb1d6ebb37a51fb" } }] + +[[packages]] +name = "mpmath" +version = "1.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", upload-time = 2023-03-07T16:47:11Z, size = 508106, hashes = { sha256 = "7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", upload-time = 2023-03-07T16:47:09Z, size = 536198, hashes = { sha256 = "a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c" } }] + +[[packages]] +name = "multidict" +version = "6.7.1" +sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", upload-time = 2026-01-26T02:46:45Z, size = 102010, hashes = { sha256 = "ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-01-26T02:44:03Z, size = 256322, hashes = { sha256 = "bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961" } }, + { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", upload-time = 2026-01-26T02:46:44Z, size = 12319, hashes = { sha256 = "55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56" } }, +] + +[[packages]] +name = "multiprocess" +version = "0.70.16" +sdist = { url = "https://files.pythonhosted.org/packages/b5/ae/04f39c5d0d0def03247c2893d6f2b83c136bf3320a2154d7b8858f2ba72d/multiprocess-0.70.16.tar.gz", upload-time = 2024-01-28T18:52:34Z, size = 1772603, hashes = { sha256 = "161af703d4652a0e1410be6abccecde4a7ddffd19341be0a7011b94aeb171ac1" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bc/f7/7ec7fddc92e50714ea3745631f79bd9c96424cb2702632521028e57d3a36/multiprocess-0.70.16-py310-none-any.whl", upload-time = 2024-01-28T18:52:26Z, size = 134824, hashes = { sha256 = "c4a9944c67bd49f823687463660a2d6daae94c289adff97e0f9d696ba6371d02" } }, + { url = "https://files.pythonhosted.org/packages/50/15/b56e50e8debaf439f44befec5b2af11db85f6e0f344c3113ae0be0593a91/multiprocess-0.70.16-py311-none-any.whl", upload-time = 2024-01-28T18:52:28Z, size = 143519, hashes = { sha256 = "af4cabb0dac72abfb1e794fa7855c325fd2b55a10a44628a3c1ad3311c04127a" } }, + { url = "https://files.pythonhosted.org/packages/0a/7d/a988f258104dcd2ccf1ed40fdc97e26c4ac351eeaf81d76e266c52d84e2f/multiprocess-0.70.16-py312-none-any.whl", upload-time = 2024-01-28T18:52:29Z, size = 146741, hashes = { sha256 = "fc0544c531920dde3b00c29863377f87e1632601092ea2daca74e4beb40faa2e" } }, + { url = "https://files.pythonhosted.org/packages/ea/89/38df130f2c799090c978b366cfdf5b96d08de5b29a4a293df7f7429fa50b/multiprocess-0.70.16-py38-none-any.whl", upload-time = 2024-01-28T18:52:30Z, size = 132628, hashes = { sha256 = "a71d82033454891091a226dfc319d0cfa8019a4e888ef9ca910372a446de4435" } }, + { url = "https://files.pythonhosted.org/packages/da/d9/f7f9379981e39b8c2511c9e0326d212accacb82f12fbfdc1aa2ce2a7b2b6/multiprocess-0.70.16-py39-none-any.whl", upload-time = 2024-01-28T18:52:31Z, size = 133351, hashes = { sha256 = "a0bafd3ae1b732eac64be2e72038231c1ba97724b60b09400d68f229fcc2fbf3" } }, +] + +[[packages]] +name = "networkx" +version = "3.6.1" +sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", upload-time = 2025-12-08T17:02:39Z, size = 2517025, hashes = { sha256 = "26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", upload-time = 2025-12-08T17:02:38Z, size = 2068504, hashes = { sha256 = "d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762" } }] + +[[packages]] +name = "numpy" +version = "2.4.4" +sdist = { url = "https://files.pythonhosted.org/packages/d7/9f/b8cef5bffa569759033adda9481211426f12f53299629b410340795c2514/numpy-2.4.4.tar.gz", upload-time = 2026-03-29T13:22:01Z, size = 20731587, hashes = { sha256 = "2d390634c5182175533585cc89f3608a4682ccb173cc9bb940b2881c8d6f8fa0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0a/0d/0e3ecece05b7a7e87ab9fb587855548da437a061326fff64a223b6dcb78a/numpy-2.4.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-29T13:19:03Z, size = 16645480, hashes = { sha256 = "81f4a14bee47aec54f883e0cad2d73986640c1590eb9bfaaba7ad17394481e6e" } }] + +[[packages]] +name = "omegaconf" +version = "2.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/09/48/6388f1bb9da707110532cb70ec4d2822858ddfb44f1cdf1233c20a80ea4b/omegaconf-2.3.0.tar.gz", upload-time = 2022-12-08T20:59:22Z, size = 3298120, hashes = { sha256 = "d5d4b6d29955cc50ad50c46dc269bcd92c6e00f5f90d23ab5fee7bfca4ba4cc7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e3/94/1843518e420fa3ed6919835845df698c7e27e183cb997394e4a670973a65/omegaconf-2.3.0-py3-none-any.whl", upload-time = 2022-12-08T20:59:19Z, size = 79500, hashes = { sha256 = "7b4df175cdb08ba400f45cae3bdcae7ba8365db4d165fc65fd04b050ab63b46b" } }] + +[[packages]] +name = "onnxruntime" +version = "1.25.0" +wheels = [{ url = "https://files.pythonhosted.org/packages/a9/1b/d681878f227513917d8620e4ea504af5eb3313fc01f8aea7b19a976c65db/onnxruntime-1.25.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-22T17:19:53Z, size = 17996146, hashes = { sha256 = "be93baa694ef8e5831fcb7b542da21f502b122918b5b9612d9f02972e043ee01" } }] + +[[packages]] +name = "open-clip-torch" +version = "2.32.0" +sdist = { url = "https://files.pythonhosted.org/packages/6d/7b/fd38dfd522968135dce71d0b543c2ae776f9c8e27df6ad46b63bab09eef7/open_clip_torch-2.32.0.tar.gz", upload-time = 2025-04-05T21:55:24Z, size = 1491248, hashes = { sha256 = "0220bc111162527eb738c1fe20dbfd6ea45dfe44726b54a4de18d3945d8f2f00" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/32/f9/0458745c1d299411161ee3b6c32228a3de0be1d8497d779fd7f17a8e96aa/open_clip_torch-2.32.0-py3-none-any.whl", upload-time = 2025-04-05T21:55:22Z, size = 1528783, hashes = { sha256 = "80b35b43e37afc2b6173aa5ab0ad68744ab3a3211e624f72dfe743a162707637" } }] + +[[packages]] +name = "opencv-python" +version = "4.13.0.92" +wheels = [ + { url = "https://files.pythonhosted.org/packages/db/07/90b34a8e2cf9c50fe8ed25cac9011cde0676b4d9d9c973751ac7616223a2/opencv_python-4.13.0.92-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-02-05T06:59:19Z, size = 70460872, hashes = { sha256 = "402033cddf9d294693094de5ef532339f14ce821da3ad7df7c9f6e8316da32cf" } }, + { url = "https://files.pythonhosted.org/packages/fd/55/b3b49a1b97aabcfbbd6c7326df9cb0b6fa0c0aefa8e89d500939e04aa229/opencv_python-4.13.0.92-cp37-abi3-manylinux_2_28_x86_64.whl", upload-time = 2026-02-05T06:59:23Z, size = 72927042, hashes = { sha256 = "620d602b8f7d8b8dab5f4b99c6eb353e78d3fb8b0f53db1bd258bb1aa001c1d5" } }, +] + +[[packages]] +name = "openpyxl" +version = "3.1.5" +sdist = { url = "https://files.pythonhosted.org/packages/3d/f9/88d94a75de065ea32619465d2f77b29a0469500e99012523b91cc4141cd1/openpyxl-3.1.5.tar.gz", upload-time = 2024-06-28T14:03:44Z, size = 186464, hashes = { sha256 = "cf0e3cf56142039133628b5acffe8ef0c12bc902d2aadd3e0fe5878dc08d1050" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c0/da/977ded879c29cbd04de313843e76868e6e13408a94ed6b987245dc7c8506/openpyxl-3.1.5-py2.py3-none-any.whl", upload-time = 2024-06-28T14:03:41Z, size = 250910, hashes = { sha256 = "5282c12b107bffeef825f4617dc029afaf41d0ea60823bbb665ef3079dc79de2" } }] + +[[packages]] +name = "packaging" +version = "24.2" +sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", upload-time = 2024-11-08T09:47:47Z, size = 163950, hashes = { sha256 = "c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", upload-time = 2024-11-08T09:47:44Z, size = 65451, hashes = { sha256 = "09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759" } }] + +[[packages]] +name = "pandas" +version = "2.3.3" +sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", upload-time = 2025-09-29T23:34:51Z, size = 4495223, hashes = { sha256 = "e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e5/63/cd7d615331b328e287d8233ba9fdf191a9c2d11b6af0c7a59cfcec23de68/pandas-2.3.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-09-29T23:20:14Z, size = 12362693, hashes = { sha256 = "b3d11d2fda7eb164ef27ffc14b4fcab16a80e1ce67e9f57e19ec0afaf715ba89" } }] + +[[packages]] +name = "peft" +version = "0.19.1" +sdist = { url = "https://files.pythonhosted.org/packages/86/cf/037f1e3d5186496c05513a6754639e2dab3038a05f384284d49a9bd06a2d/peft-0.19.1.tar.gz", upload-time = 2026-04-16T15:46:45Z, size = 763738, hashes = { sha256 = "0d97542fe96dcdaa20d3b81c06f26f988618f416a73544ab23c3618ccb674a40" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e8/b6/f54d676ed93cc2dd2234c3b172ea9c8c3d7d29361e66b1b23dec57a67465/peft-0.19.1-py3-none-any.whl", upload-time = 2026-04-16T15:46:42Z, size = 680692, hashes = { sha256 = "2113f72a81621b5913ef28f9022204c742df111890c5f49d812716a4a301e356" } }] + +[[packages]] +name = "pillow" +version = "12.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/1c/3d/bb7fca845737cf9d7dbde16ed1843984665ff2e0a518f5db43e77ec540b9/pillow-12.3.0.tar.gz", upload-time = 2026-07-01T11:56:38Z, size = 47025035, hashes = { sha256 = "3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/84/21/a35af28dcc61f37ed850a2d64c65c701321dfbf25085e469d5559360cbbf/pillow-12.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-01T11:54:13Z, size = 6940830, hashes = { sha256 = "78cb2c6865a35ab8ff8b75fd122f6033b92a62c82801110e48ddd6c936a45d91" } }] + +[[packages]] +name = "pluggy" +version = "1.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", upload-time = 2025-05-15T12:30:07Z, size = 69412, hashes = { sha256 = "7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", upload-time = 2025-05-15T12:30:06Z, size = 20538, hashes = { sha256 = "e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746" } }] + +[[packages]] +name = "polyfactory" +version = "3.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/85/68/7717bd9e63ed254617a7d3dc9260904fb736d6ea203e58ffddcb186c64e4/polyfactory-3.3.0.tar.gz", upload-time = 2026-02-22T09:46:28Z, size = 348668, hashes = { sha256 = "237258b6ff43edf362ffd1f68086bb796466f786adfa002b0ac256dbf2246e9a" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/dd/34/b6f19941adcdaf415b5e8a8d577499f5b6a76b59cbae37f9b125a9ffe9f2/polyfactory-3.3.0-py3-none-any.whl", upload-time = 2026-02-22T09:46:25Z, size = 62707, hashes = { sha256 = "686abcaa761930d3df87b91e95b26b8d8cb9fdbbbe0b03d5f918acff5c72606e" } }] + +[[packages]] +name = "propcache" +version = "0.4.1" +sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", upload-time = 2025-10-08T19:49:02Z, size = 46442, hashes = { sha256 = "f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/46/4b/3aae6835b8e5f44ea6a68348ad90f78134047b503765087be2f9912140ea/propcache-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-10-08T19:46:54Z, size = 221575, hashes = { sha256 = "15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf" } }, + { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", upload-time = 2025-10-08T19:49:00Z, size = 13305, hashes = { sha256 = "af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237" } }, +] + +[[packages]] +name = "protobuf" +version = "6.33.6" +sdist = { url = "https://files.pythonhosted.org/packages/66/70/e908e9c5e52ef7c3a6c7902c9dfbb34c7e29c25d2f81ade3856445fd5c94/protobuf-6.33.6.tar.gz", upload-time = 2026-03-18T19:05:00Z, size = 444531, hashes = { sha256 = "a6768d25248312c297558af96a9f9c929e8c4cee0659cb07e780731095f38135" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/16/92/d1e32e3e0d894fe00b15ce28ad4944ab692713f2e7f0a99787405e43533a/protobuf-6.33.6-cp39-abi3-manylinux2014_x86_64.whl", upload-time = 2026-03-18T19:04:55Z, size = 323436, hashes = { sha256 = "e9db7e292e0ab79dd108d7f1a94fe31601ce1ee3f7b79e0692043423020b0593" } }, + { url = "https://files.pythonhosted.org/packages/c4/72/02445137af02769918a93807b2b7890047c32bfb9f90371cbc12688819eb/protobuf-6.33.6-py3-none-any.whl", upload-time = 2026-03-18T19:04:59Z, size = 170656, hashes = { sha256 = "77179e006c476e69bf8e8ce866640091ec42e1beb80b213c3900006ecfba6901" } }, +] + +[[packages]] +name = "psutil" +version = "7.2.2" +sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", upload-time = 2026-01-28T18:14:54Z, size = 493740, hashes = { sha256 = "0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-01-28T18:15:25Z, size = 155560, hashes = { sha256 = "076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9" } }] + +[[packages]] +name = "pyarrow" +version = "23.0.1" +sdist = { url = "https://files.pythonhosted.org/packages/88/22/134986a4cc224d593c1afde5494d18ff629393d74cc2eddb176669f234a4/pyarrow-23.0.1.tar.gz", upload-time = 2026-02-16T10:14:12Z, size = 1167336, hashes = { sha256 = "b8c5873e33440b2bc2f4a79d2b47017a89c5a24116c055625e6f2ee50523f019" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2c/a5/da83046273d990f256cb79796a190bbf7ec999269705ddc609403f8c6b06/pyarrow-23.0.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-02-16T10:10:17Z, size = 47586063, hashes = { sha256 = "813d99f31275919c383aab17f0f455a04f5a429c261cc411b1e9a8f5e4aaaa05" } }] + +[[packages]] +name = "pyclipper" +version = "1.4.0" +sdist = { url = "https://files.pythonhosted.org/packages/f6/21/3c06205bb407e1f79b73b7b4dfb3950bd9537c4f625a68ab5cc41177f5bc/pyclipper-1.4.0.tar.gz", upload-time = 2025-12-01T13:15:35Z, size = 54489, hashes = { sha256 = "9882bd889f27da78add4dd6f881d25697efc740bf840274e749988d25496c8e1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7a/06/6e3e241882bf7d6ab23d9c69ba4e85f1ec47397cbbeee948a16cf75e21ed/pyclipper-1.4.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-12-01T13:15:06Z, size = 978235, hashes = { sha256 = "d1f807e2b4760a8e5c6d6b4e8c1d71ef52b7fe1946ff088f4fa41e16a881a5ca" } }] + +[[packages]] +name = "pydantic" +version = "2.12.5" +sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", upload-time = 2025-11-26T15:11:46Z, size = 821591, hashes = { sha256 = "4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", upload-time = 2025-11-26T15:11:44Z, size = 463580, hashes = { sha256 = "e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d" } }] + +[[packages]] +name = "pydantic-core" +version = "2.41.5" +sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", upload-time = 2025-11-04T13:43:49Z, size = 460952, hashes = { sha256 = "08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-04T13:40:09Z, size = 2075366, hashes = { sha256 = "eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c" } }] + +[[packages]] +name = "pydantic-settings" +version = "2.14.2" +sdist = { url = "https://files.pythonhosted.org/packages/5c/b5/8f48e906c3e0205276e8bd8cb7512217a87b2685304d64be27cad5b3019f/pydantic_settings-2.14.2.tar.gz", upload-time = 2026-06-19T13:44:56Z, size = 237700, hashes = { sha256 = "c19dd64b19097f1de80184f0cc7b0272a13ae6e170cbf240a3e27e381ed14a5f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/77/c1/6e422f34e569cf8e18df68d1939c81c099d2b61e4f7d9621c8a77560799c/pydantic_settings-2.14.2-py3-none-any.whl", upload-time = 2026-06-19T13:44:55Z, size = 61715, hashes = { sha256 = "a20c97b37910b6550d5ea50fbcc2d4187defe58cd57070b73863d069419c9440" } }] + +[[packages]] +name = "pygments" +version = "2.20.0" +sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", upload-time = 2026-03-29T13:29:33Z, size = 4955991, hashes = { sha256 = "6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", upload-time = 2026-03-29T13:29:30Z, size = 1231151, hashes = { sha256 = "81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176" } }] + +[[packages]] +name = "pylatexenc" +version = "2.10" +sdist = { url = "https://files.pythonhosted.org/packages/5d/ab/34ec41718af73c00119d0351b7a2531d2ebddb51833a36448fc7b862be60/pylatexenc-2.10.tar.gz", upload-time = 2021-04-06T07:56:07Z, size = 162597, hashes = { sha256 = "3dd8fd84eb46dc30bee1e23eaab8d8fb5a7f507347b23e5f38ad9675c84f40d3" } } + +[[packages]] +name = "pypdfium2" +version = "5.7.1" +sdist = { url = "https://files.pythonhosted.org/packages/bc/13/ee794b8a810b7226426c8b50d6c28637c059e7da0caf9936164f352ef858/pypdfium2-5.7.1.tar.gz", upload-time = 2026-04-20T15:01:02Z, size = 266791, hashes = { sha256 = "3b3b20a56048dbe3fd4bf397f9bec854c834668bc47ef6a7d9041b23bb04317b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/03/4b/fff16a831a6f07aad02da0d02b620c455310b8bf4e2642909175dcb7ccae/pypdfium2-5.7.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-04-20T15:00:38Z, size = 3657630, hashes = { sha256 = "fc2cdf603ac766b91b7c1b455197ec1c3471089d75f999b046edb65ed6cedd80" } }] + +[[packages]] +name = "python-dateutil" +version = "2.9.0.post0" +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", upload-time = 2024-03-01T18:36:20Z, size = 342432, hashes = { sha256 = "37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", upload-time = 2024-03-01T18:36:18Z, size = 229892, hashes = { sha256 = "a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427" } }] + +[[packages]] +name = "python-docx" +version = "1.2.0" +sdist = { url = "https://files.pythonhosted.org/packages/a9/f7/eddfe33871520adab45aaa1a71f0402a2252050c14c7e3009446c8f4701c/python_docx-1.2.0.tar.gz", upload-time = 2025-06-16T20:46:27Z, size = 5723256, hashes = { sha256 = "7bc9d7b7d8a69c9c02ca09216118c86552704edc23bac179283f2e38f86220ce" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d0/00/1e03a4989fa5795da308cd774f05b704ace555a70f9bf9d3be057b680bcf/python_docx-1.2.0-py3-none-any.whl", upload-time = 2025-06-16T20:46:22Z, size = 252987, hashes = { sha256 = "3fd478f3250fbbbfd3b94fe1e985955737c145627498896a8a6bf81f4baf66c7" } }] + +[[packages]] +name = "python-dotenv" +version = "1.2.2" +sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", upload-time = 2026-03-01T16:00:26Z, size = 50135, hashes = { sha256 = "2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", upload-time = 2026-03-01T16:00:25Z, size = 22101, hashes = { sha256 = "1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a" } }] + +[[packages]] +name = "python-pptx" +version = "1.0.2" +sdist = { url = "https://files.pythonhosted.org/packages/52/a9/0c0db8d37b2b8a645666f7fd8accea4c6224e013c42b1d5c17c93590cd06/python_pptx-1.0.2.tar.gz", upload-time = 2024-08-07T17:33:37Z, size = 10109297, hashes = { sha256 = "479a8af0eaf0f0d76b6f00b0887732874ad2e3188230315290cd1f9dd9cc7095" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d9/4f/00be2196329ebbff56ce564aa94efb0fbc828d00de250b1980de1a34ab49/python_pptx-1.0.2-py3-none-any.whl", upload-time = 2024-08-07T17:33:28Z, size = 472788, hashes = { sha256 = "160838e0b8565a8b1f67947675886e9fea18aa5e795db7ae531606d68e785cba" } }] + +[[packages]] +name = "pytz" +version = "2026.1.post1" +sdist = { url = "https://files.pythonhosted.org/packages/56/db/b8721d71d945e6a8ac63c0fc900b2067181dbb50805958d4d4661cf7d277/pytz-2026.1.post1.tar.gz", upload-time = 2026-03-03T07:47:50Z, size = 321088, hashes = { sha256 = "3378dde6a0c3d26719182142c56e60c7f9af7e968076f31aae569d72a0358ee1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/10/99/781fe0c827be2742bcc775efefccb3b048a3a9c6ce9aec0cbf4a101677e5/pytz-2026.1.post1-py2.py3-none-any.whl", upload-time = 2026-03-03T07:47:49Z, size = 510489, hashes = { sha256 = "f2fd16142fda348286a75e1a524be810bb05d444e5a081f37f7affc635035f7a" } }] + +[[packages]] +name = "pyyaml" +version = "6.0.3" +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", upload-time = 2025-09-25T21:33:16Z, size = 130960, hashes = { sha256 = "d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-09-25T21:32:16Z, size = 807870, hashes = { sha256 = "ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc" } }] + +[[packages]] +name = "rapidocr" +version = "3.8.1" +wheels = [{ url = "https://files.pythonhosted.org/packages/ea/4a/fa521d947f0fc7bb304bf11bec4cb66266bd81494588b4cb48dc01001719/rapidocr-3.8.1-py3-none-any.whl", upload-time = 2026-04-11T07:13:22Z, size = 15080319, hashes = { sha256 = "650044b1fbce9e6bae5cae462dcf8be754cde11e2f23fc51f65dcc08deae2c46" } }] + +[[packages]] +name = "referencing" +version = "0.37.0" +sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", upload-time = 2025-10-13T15:30:48Z, size = 78036, hashes = { sha256 = "44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", upload-time = 2025-10-13T15:30:47Z, size = 26766, hashes = { sha256 = "381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231" } }] + +[[packages]] +name = "regex" +version = "2026.4.4" +sdist = { url = "https://files.pythonhosted.org/packages/cb/0e/3a246dbf05666918bd3664d9d787f84a9108f6f43cc953a077e4a7dfdb7e/regex-2026.4.4.tar.gz", upload-time = 2026-04-03T20:56:28Z, size = 416000, hashes = { sha256 = "e08270659717f6973523ce3afbafa53515c4dc5dcad637dc215b6fd50f689423" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/11/0e/a9f6f81013e0deaf559b25711623864970fe6a098314e374ccb1540a4152/regex-2026.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-03T20:53:51Z, size = 801126, hashes = { sha256 = "993f657a7c1c6ec51b5e0ba97c9817d06b84ea5fa8d82e43b9405de0defdc2b9" } }] + +[[packages]] +name = "requests" +version = "2.33.1" +sdist = { url = "https://files.pythonhosted.org/packages/5f/a4/98b9c7c6428a668bf7e42ebb7c79d576a1c3c1e3ae2d47e674b468388871/requests-2.33.1.tar.gz", upload-time = 2026-03-30T16:09:15Z, size = 134120, hashes = { sha256 = "18817f8c57c6263968bc123d237e3b8b08ac046f5456bd1e307ee8f4250d3517" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", upload-time = 2026-03-30T16:09:13Z, size = 64947, hashes = { sha256 = "4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a" } }] + +[[packages]] +name = "rich" +version = "13.9.4" +sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", upload-time = 2024-11-01T16:43:57Z, size = 223149, hashes = { sha256 = "439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", upload-time = 2024-11-01T16:43:55Z, size = 242424, hashes = { sha256 = "6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90" } }] + +[[packages]] +name = "rpds-py" +version = "0.30.0" +sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", upload-time = 2025-11-30T20:24:38Z, size = 69469, hashes = { sha256 = "dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/60/1b/6f8f29f3f995c7ffdde46a626ddccd7c63aefc0efae881dc13b6e5d5bb16/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-30T20:22:27Z, size = 394080, hashes = { sha256 = "47f236970bccb2233267d89173d3ad2703cd36a0e2a6e92d0560d333871a3d23" } }] + +[[packages]] +name = "rtree" +version = "1.4.1" +sdist = { url = "https://files.pythonhosted.org/packages/95/09/7302695875a019514de9a5dd17b8320e7a19d6e7bc8f85dcfb79a4ce2da3/rtree-1.4.1.tar.gz", upload-time = 2025-08-13T19:32:01Z, size = 52425, hashes = { sha256 = "c6b1b3550881e57ebe530cc6cffefc87cd9bf49c30b37b894065a9f810875e46" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d1/75/e5d44be90525cd28503e7f836d077ae6663ec0687a13ba7810b4114b3668/rtree-1.4.1-py3-none-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-08-13T19:31:55Z, size = 507644, hashes = { sha256 = "12de4578f1b3381a93a655846900be4e3d5f4cd5e306b8b00aa77c1121dc7e8c" } }] + +[[packages]] +name = "safetensors" +version = "0.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/29/9c/6e74567782559a63bd040a236edca26fd71bc7ba88de2ef35d75df3bca5e/safetensors-0.7.0.tar.gz", upload-time = 2025-11-19T15:18:43Z, size = 200878, hashes = { sha256 = "07663963b67e8bd9f0b8ad15bb9163606cd27cc5a1b96235a50d8369803b96b0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a0/60/429e9b1cb3fc651937727befe258ea24122d9663e4d5709a48c9cbfceecb/safetensors-0.7.0-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-19T15:18:33Z, size = 507152, hashes = { sha256 = "dac7252938f0696ddea46f5e855dd3138444e82236e3be475f54929f0c510d48" } }] + +[[packages]] +name = "scikit-learn" +version = "1.8.0" +sdist = { url = "https://files.pythonhosted.org/packages/0e/d4/40988bf3b8e34feec1d0e6a051446b1f66225f8529b9309becaeef62b6c4/scikit_learn-1.8.0.tar.gz", upload-time = 2025-12-10T07:08:53Z, size = 7335585, hashes = { sha256 = "9bccbb3b40e3de10351f8f5068e105d0f4083b1a65fa07b6634fbc401a6287fd" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/97/74/b7a304feb2b49df9fafa9382d4d09061a96ee9a9449a7cbea7988dda0828/scikit_learn-1.8.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-12-10T07:07:57Z, size = 8931904, hashes = { sha256 = "a0bcfe4d0d14aec44921545fd2af2338c7471de9cb701f1da4c9d85906ab847a" } }] + +[[packages]] +name = "scipy" +version = "1.17.1" +sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", upload-time = 2026-02-23T00:26:24Z, size = 30573822, hashes = { sha256 = "95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/01/8e/1e35281b8ab6d5d72ebe9911edcdffa3f36b04ed9d51dec6dd140396e220/scipy-1.17.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-02-23T00:18:49Z, size = 35235890, hashes = { sha256 = "02ae3b274fde71c5e92ac4d54bc06c42d80e399fec704383dcd99b301df37458" } }] + +[[packages]] +name = "semchunk" +version = "3.2.5" +sdist = { url = "https://files.pythonhosted.org/packages/a9/a0/ce7e3d6cc76498fd594e667d10a03f17d7cced129e46869daec23523bf5a/semchunk-3.2.5.tar.gz", upload-time = 2025-10-28T02:12:38Z, size = 17667, hashes = { sha256 = "ee15e9a06a69a411937dd8fcf0a25d7ef389c5195863140436872a02c95b0218" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f8/95/12d226ee4d207cb1f77a216baa7e1a8bae2639733c140abe8d0316d23a18/semchunk-3.2.5-py3-none-any.whl", upload-time = 2025-10-28T02:12:36Z, size = 13048, hashes = { sha256 = "fd09cc5f380bd010b8ca773bd81893f7eaf11d37dd8362a83d46cedaf5dae076" } }] + +[[packages]] +name = "sentence-transformers" +version = "5.4.1" +sdist = { url = "https://files.pythonhosted.org/packages/4d/68/7f98c221940ce783b492ad6140384daf2e2918cd7175009d6a362c22b9ee/sentence_transformers-5.4.1.tar.gz", upload-time = 2026-04-14T13:34:59Z, size = 428910, hashes = { sha256 = "436bcb1182a0ff42a8fb2b1c43498a70d0a75b688d182f2cd0d1dd115af61ddc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c5/d9/3a9b6f2ccdedc9dc00fe37b2fc58f58f8efbff44565cf4bf39d8568bb13a/sentence_transformers-5.4.1-py3-none-any.whl", upload-time = 2026-04-14T13:34:57Z, size = 571311, hashes = { sha256 = "a6d640fc363849b63affb8e140e9d328feabab86f83d58ac3e16b1c28140b790" } }] + +[[packages]] +name = "sentencepiece" +version = "0.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/15/15/2e7a025fc62d764b151ae6d0f2a92f8081755ebe8d4a64099accc6f77ba6/sentencepiece-0.2.1.tar.gz", upload-time = 2025-08-12T07:00:51Z, size = 3228515, hashes = { sha256 = "8138cec27c2f2282f4a34d9a016e3374cd40e5c6e9cb335063db66a0a3b71fad" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/04/88/14f2f4a2b922d8b39be45bf63d79e6cd3a9b2f248b2fcb98a69b12af12f5/sentencepiece-0.2.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-08-12T06:59:46Z, size = 1387881, hashes = { sha256 = "0cdfecef430d985f1c2bcbfff3defd1d95dae876fbd0173376012d2d7d24044b" } }] + +[[packages]] +name = "seqeval" +version = "1.2.2" +sdist = { url = "https://files.pythonhosted.org/packages/9d/2d/233c79d5b4e5ab1dbf111242299153f3caddddbb691219f363ad55ce783d/seqeval-1.2.2.tar.gz", upload-time = 2020-10-24T00:24:54Z, size = 43605, hashes = { sha256 = "f28e97c3ab96d6fcd32b648f6438ff2e09cfba87f05939da9b3970713ec56e6f" } } + +[[packages]] +name = "setuptools" +version = "83.0.0" +marker = "python_full_version >= '3.12'" +sdist = { url = "https://files.pythonhosted.org/packages/34/26/f5d29e25ffdb535afef2d35cdb55b325298f96debd670da4c325e08d70f4/setuptools-83.0.0.tar.gz", upload-time = 2026-07-04T15:31:22Z, size = 1154254, hashes = { sha256 = "025bccbbf0fa05b6192bc64ae1e7b16e001fd6d6d4d5de03c97b1c1ade523bef" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5d/40/e1e72872c6354b306daef1703549e8e83b4d43cfea356311bf722a043752/setuptools-83.0.0-py3-none-any.whl", upload-time = 2026-07-04T15:31:20Z, size = 1008090, hashes = { sha256 = "29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3" } }] + +[[packages]] +name = "shapely" +version = "2.1.2" +sdist = { url = "https://files.pythonhosted.org/packages/4d/bc/0989043118a27cccb4e906a46b7565ce36ca7b57f5a18b78f4f1b0f72d9d/shapely-2.1.2.tar.gz", upload-time = 2025-09-24T13:51:41Z, size = 315489, hashes = { sha256 = "2ed4ecb28320a433db18a5bf029986aa8afcfd740745e78847e330d5d94922a9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b9/37/e781683abac55dde9771e086b790e554811a71ed0b2b8a1e789b7430dd44/shapely-2.1.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-09-24T13:50:35Z, size = 3099844, hashes = { sha256 = "1e7d4d7ad262a48bb44277ca12c7c78cb1b0f56b32c10734ec9a1d30c0b0c54b" } }] + +[[packages]] +name = "shellingham" +version = "1.5.4" +sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", upload-time = 2023-10-24T04:13:40Z, size = 10310, hashes = { sha256 = "8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", upload-time = 2023-10-24T04:13:38Z, size = 9755, hashes = { sha256 = "7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686" } }] + +[[packages]] +name = "six" +version = "1.17.0" +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", upload-time = 2024-12-04T17:35:28Z, size = 34031, hashes = { sha256 = "ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", upload-time = 2024-12-04T17:35:26Z, size = 11050, hashes = { sha256 = "4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274" } }] + +[[packages]] +name = "soupsieve" +version = "2.9" +sdist = { url = "https://files.pythonhosted.org/packages/80/f1/93422647dd7e461f23d254e6b2bfa687a85b53aeb4903fcdbb74474d4584/soupsieve-2.9.tar.gz", upload-time = 2026-07-19T01:35:18Z, size = 122122, hashes = { sha256 = "acee8417325c5653e1377dc31eccad59eb82cbc65942afe6174c53b3aaad63fc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7b/d6/3185ab5ad1280319b31986898f3206dd7227cd75e293d4dba2a5e6bf27a0/soupsieve-2.9-py3-none-any.whl", upload-time = 2026-07-19T01:35:17Z, size = 37387, hashes = { sha256 = "a2b2c76d67df2382d245409fd71e321a571717e58463efa32ace87dcadac2c12" } }] + +[[packages]] +name = "sympy" +version = "1.14.0" +sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", upload-time = 2025-04-27T18:05:01Z, size = 7793921, hashes = { sha256 = "d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", upload-time = 2025-04-27T18:04:59Z, size = 6299353, hashes = { sha256 = "e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5" } }] + +[[packages]] +name = "tabulate" +version = "0.10.0" +sdist = { url = "https://files.pythonhosted.org/packages/46/58/8c37dea7bbf769b20d58e7ace7e5edfe65b849442b00ffcdd56be88697c6/tabulate-0.10.0.tar.gz", upload-time = 2026-03-04T18:55:34Z, size = 91754, hashes = { sha256 = "e2cfde8f79420f6deeffdeda9aaec3b6bc5abce947655d17ac662b126e48a60d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/99/55/db07de81b5c630da5cbf5c7df646580ca26dfaefa593667fc6f2fe016d2e/tabulate-0.10.0-py3-none-any.whl", upload-time = 2026-03-04T18:55:31Z, size = 39814, hashes = { sha256 = "f0b0622e567335c8fabaaa659f1b33bcb6ddfe2e496071b743aa113f8774f2d3" } }] + +[[packages]] +name = "threadpoolctl" +version = "3.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/b7/4d/08c89e34946fce2aec4fbb45c9016efd5f4d7f24af8e5d93296e935631d8/threadpoolctl-3.6.0.tar.gz", upload-time = 2025-03-13T13:49:23Z, size = 21274, hashes = { sha256 = "8ab8b4aa3491d812b623328249fab5302a68d2d71745c8a4c719a2fcaba9f44e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", upload-time = 2025-03-13T13:49:21Z, size = 18638, hashes = { sha256 = "43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb" } }] + +[[packages]] +name = "timm" +version = "0.9.16" +sdist = { url = "https://files.pythonhosted.org/packages/c5/ba/3d5f3381dc291d21114e707b39791f483431361f61402483d9839b61350d/timm-0.9.16.tar.gz", upload-time = 2024-02-19T19:33:45Z, size = 2121824, hashes = { sha256 = "891e54f375d55adf31a71ab0c117761f0e472f9f3971858ecdd1e7376b7071e6" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/68/99/2018622d268f6017ddfa5ee71f070bad5d07590374793166baa102849d17/timm-0.9.16-py3-none-any.whl", upload-time = 2024-02-19T19:33:42Z, size = 2249737, hashes = { sha256 = "bf5704014476ab011589d3c14172ee4c901fd18f9110a928019cac5be2945914" } }] + +[[packages]] +name = "tokenizers" +version = "0.22.2" +sdist = { url = "https://files.pythonhosted.org/packages/73/6f/f80cfef4a312e1fb34baf7d85c72d4411afde10978d4657f8cdd811d3ccc/tokenizers-0.22.2.tar.gz", upload-time = 2026-01-05T10:45:15Z, size = 372115, hashes = { sha256 = "473b83b915e547aa366d1eee11806deaf419e17be16310ac0a14077f1e28f917" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2e/76/932be4b50ef6ccedf9d3c6639b056a967a86258c6d9200643f01269211ca/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-01-05T10:40:58Z, size = 3274982, hashes = { sha256 = "369cc9fc8cc10cb24143873a0d95438bb8ee257bb80c71989e3ee290e8d72c67" } }] + +[[packages]] +name = "torch" +version = "2.9.1+cpu" +wheels = [{ url = "https://download-r2.pytorch.org/whl/cpu/torch-2.9.1%2Bcpu-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-01-23T15:13:04Z, hashes = { sha256 = "7417d8c565f219d3455654cb431c6d892a3eb40246055e14d645422de13b9ea1" } }] + +[[packages]] +name = "torchvision" +version = "0.24.1+cpu" +wheels = [{ url = "https://download-r2.pytorch.org/whl/cpu/torchvision-0.24.1%2Bcpu-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2025-11-15T18:12:45Z, hashes = { sha256 = "48ff40694812292f1f75cddb517f9eef224a2e8388798a0aa191e27bf159fc5d" } }] + +[[packages]] +name = "tqdm" +version = "4.67.3" +sdist = { url = "https://files.pythonhosted.org/packages/09/a9/6ba95a270c6f1fbcd8dac228323f2777d886cb206987444e4bce66338dd4/tqdm-4.67.3.tar.gz", upload-time = 2026-02-03T17:35:53Z, size = 169598, hashes = { sha256 = "7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", upload-time = 2026-02-03T17:35:50Z, size = 78374, hashes = { sha256 = "ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf" } }] + +[[packages]] +name = "transformers" +version = "4.57.6" +sdist = { url = "https://files.pythonhosted.org/packages/c4/35/67252acc1b929dc88b6602e8c4a982e64f31e733b804c14bc24b47da35e6/transformers-4.57.6.tar.gz", upload-time = 2026-01-16T10:38:39Z, size = 10134912, hashes = { sha256 = "55e44126ece9dc0a291521b7e5492b572e6ef2766338a610b9ab5afbb70689d3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/03/b8/e484ef633af3887baeeb4b6ad12743363af7cce68ae51e938e00aaa0529d/transformers-4.57.6-py3-none-any.whl", upload-time = 2026-01-16T10:38:31Z, size = 11993498, hashes = { sha256 = "4c9e9de11333ddfe5114bc872c9f370509198acf0b87a832a0ab9458e2bd0550" } }] + +[[packages]] +name = "trec-car-tools" +version = "2.6" +sdist = { url = "https://files.pythonhosted.org/packages/d4/71/7b62e2e56de6cdf0c648f0033a9faa41b8f712bacd71968af96277185400/trec-car-tools-2.6.tar.gz", upload-time = 2022-02-01T16:37:20Z, size = 7513, hashes = { sha256 = "2fce2de120224fd569b151d5bed358a4ed334e643889b9e3dfe3e5a3d15d21c8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/36/75/661b406371f96622975eb25f9e70945d97fbe6b8e5af40342c59191962a3/trec_car_tools-2.6-py3-none-any.whl", upload-time = 2022-02-01T16:37:22Z, size = 8414, hashes = { sha256 = "e6f0373259e1c234222da7270ab54ca7af7a6f8d0dd32b13e158c1659d3991cf" } }] + +[[packages]] +name = "tree-sitter" +version = "0.25.2" +sdist = { url = "https://files.pythonhosted.org/packages/66/7c/0350cfc47faadc0d3cf7d8237a4e34032b3014ddf4a12ded9933e1648b55/tree-sitter-0.25.2.tar.gz", upload-time = 2025-09-25T17:37:59Z, size = 177961, hashes = { sha256 = "fe43c158555da46723b28b52e058ad444195afd1db3ca7720c59a254544e9c20" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/39/d1/b95f545e9fc5001b8a78636ef942a4e4e536580caa6a99e73dd0a02e87aa/tree_sitter-0.25.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-09-25T17:37:38Z, size = 635418, hashes = { sha256 = "b43a9e4c89d4d0839de27cd4d6902d33396de700e9ff4c5ab7631f277a85ead9" } }] + +[[packages]] +name = "tree-sitter-c" +version = "0.24.2" +sdist = { url = "https://files.pythonhosted.org/packages/a6/c9/3834f3d9278251aea7312274971bc4c45b17aec2490fd4b884d93bd7019a/tree_sitter_c-0.24.2.tar.gz", upload-time = 2026-04-22T08:06:14Z, size = 228397, hashes = { sha256 = "1628584df0299b5a340aa63f8e67b6c97c91517f52fa7e7a4c557e40adb330a9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e9/8c/0dfb88d726f8821d1c4c36042f092be974a800afd734307a595b8604190c/tree_sitter_c-0.24.2-cp310-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2026-04-22T08:06:08Z, size = 94264, hashes = { sha256 = "5041ef67eb68ce6bc8bb0b1f8ef3a5585ce523dae0c7eec109ab0627dd75aede" } }] + +[[packages]] +name = "tree-sitter-javascript" +version = "0.25.0" +sdist = { url = "https://files.pythonhosted.org/packages/59/e0/e63103c72a9d3dfd89a31e02e660263ad84b7438e5f44ee82e443e65bbde/tree_sitter_javascript-0.25.0.tar.gz", upload-time = 2025-09-01T07:13:44Z, size = 132338, hashes = { sha256 = "329b5414874f0588a98f1c291f1b28138286617aa907746ffe55adfdcf963f38" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5f/c4/7da74ecdcd8a398f88bd003a87c65403b5fe0e958cdd43fbd5fd4a398fcf/tree_sitter_javascript-0.25.0-cp310-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2025-09-01T07:13:38Z, size = 99728, hashes = { sha256 = "9dc04ba91fc8583344e57c1f1ed5b2c97ecaaf47480011b92fbeab8dda96db75" } }] + +[[packages]] +name = "tree-sitter-python" +version = "0.25.0" +sdist = { url = "https://files.pythonhosted.org/packages/b8/8b/c992ff0e768cb6768d5c96234579bf8842b3a633db641455d86dd30d5dac/tree_sitter_python-0.25.0.tar.gz", upload-time = 2025-09-11T06:47:58Z, size = 159845, hashes = { sha256 = "b13e090f725f5b9c86aa455a268553c65cadf325471ad5b65cd29cac8a1a68ac" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/aa/cb/d9b0b67d037922d60cbe0359e0c86457c2da721bc714381a63e2c8e35eba/tree_sitter_python-0.25.0-cp310-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2025-09-11T06:47:50Z, size = 108133, hashes = { sha256 = "86f118e5eecad616ecdb81d171a36dde9bef5a0b21ed71ea9c3e390813c3baf5" } }] + +[[packages]] +name = "tree-sitter-typescript" +version = "0.23.2" +sdist = { url = "https://files.pythonhosted.org/packages/1e/fc/bb52958f7e399250aee093751e9373a6311cadbe76b6e0d109b853757f35/tree_sitter_typescript-0.23.2.tar.gz", upload-time = 2024-11-11T02:36:11Z, size = 773053, hashes = { sha256 = "7b167b5827c882261cb7a50dfa0fb567975f9b315e87ed87ad0a0a3aedb3834d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/49/d1/a71c36da6e2b8a4ed5e2970819b86ef13ba77ac40d9e333cb17df6a2c5db/tree_sitter_typescript-0.23.2-cp39-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2024-11-11T02:36:04Z, size = 344960, hashes = { sha256 = "e96d36b85bcacdeb8ff5c2618d75593ef12ebaf1b4eace3477e2bdb2abb1752c" } }] + +[[packages]] +name = "typer" +version = "0.21.2" +sdist = { url = "https://files.pythonhosted.org/packages/f2/1e/a27cc02a0cd715118c71fa2aef2c687fdefc3c28d90fd0dd789c5118154c/typer-0.21.2.tar.gz", upload-time = 2026-02-10T19:33:46Z, size = 120426, hashes = { sha256 = "1abd95a3b675e17ff61b0838ac637fe9478d446d62ad17fa4bb81ea57cc54028" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b8/cc/d59f893fbdfb5f58770c05febfc4086a46875f1084453621c35605cec946/typer-0.21.2-py3-none-any.whl", upload-time = 2026-02-10T19:33:48Z, size = 56728, hashes = { sha256 = "c3d8de54d00347ef90b82131ca946274f017cffb46683ae3883c360fa958f55c" } }] + +[[packages]] +name = "typing-extensions" +version = "4.15.0" +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", upload-time = 2025-08-25T13:49:26Z, size = 109391, hashes = { sha256 = "0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", upload-time = 2025-08-25T13:49:24Z, size = 44614, hashes = { sha256 = "f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548" } }] + +[[packages]] +name = "typing-inspection" +version = "0.4.2" +sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", upload-time = 2025-10-01T02:14:41Z, size = 75949, hashes = { sha256 = "ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", upload-time = 2025-10-01T02:14:40Z, size = 14611, hashes = { sha256 = "4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7" } }] + +[[packages]] +name = "tzdata" +version = "2026.2" +sdist = { url = "https://files.pythonhosted.org/packages/ba/19/1b9b0e29f30c6d35cb345486df41110984ea67ae69dddbc0e8a100999493/tzdata-2026.2.tar.gz", upload-time = 2026-04-24T15:22:08Z, size = 198254, hashes = { sha256 = "9173fde7d80d9018e02a662e168e5a2d04f87c41ea174b139fbef642eda62d10" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ce/e4/dccd7f47c4b64213ac01ef921a1337ee6e30e8c6466046018326977efd95/tzdata-2026.2-py2.py3-none-any.whl", upload-time = 2026-04-24T15:22:05Z, size = 349321, hashes = { sha256 = "bbe9af844f658da81a5f95019480da3a89415801f6cc966806612cc7169bffe7" } }] + +[[packages]] +name = "unlzw3" +version = "0.2.3" +sdist = { url = "https://files.pythonhosted.org/packages/08/f1/72b313366285263aaba21a17714fbef597d7662a8737a928b2b4784eb46e/unlzw3-0.2.3.tar.gz", upload-time = 2024-12-20T16:05:55Z, size = 5426, hashes = { sha256 = "ede5d928c792fff9da406f20334f9739693327f448f383ae1df1774627197bbb" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/4d/fb/617af9b317ac75f5663285d3a3cc38903a76d63c6e7397768307545f4ff4/unlzw3-0.2.3-py3-none-any.whl", upload-time = 2024-12-20T16:05:53Z, size = 6729, hashes = { sha256 = "7760fb4f3afa1225623944c061991d89a061f7fb78665dbc4cddfdb562bb4a8b" } }] + +[[packages]] +name = "urllib3" +version = "2.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", upload-time = 2026-05-07T16:13:18Z, size = 433602, hashes = { sha256 = "231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", upload-time = 2026-05-07T16:13:17Z, size = 131087, hashes = { sha256 = "9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897" } }] + +[[packages]] +name = "warc3-wet" +version = "0.2.5" +sdist = { url = "https://files.pythonhosted.org/packages/21/c6/24c9b4a2b2b1741b57d7f44ff9790eb4ef28de898c17c2b1ca1efabf8c96/warc3_wet-0.2.5.tar.gz", upload-time = 2024-07-17T08:33:51Z, size = 17937, hashes = { sha256 = "15e50402dabaa1e95307f1e2a6169cfd5f137b70761d9f0b16a10aa6de227970" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f4/99/0a5582a106679fd9439af51631b6c6cb627fd96cbc85a02927e6812605b8/warc3_wet-0.2.5-py3-none-any.whl", upload-time = 2024-07-17T08:33:50Z, size = 18657, hashes = { sha256 = "5a9a525383fb1af159734baa75f349a7c4ec7bccd1b938681b5748515d2bf624" } }] + +[[packages]] +name = "warc3-wet-clueweb09" +version = "0.2.5" +sdist = { url = "https://files.pythonhosted.org/packages/9f/c1/dd817bf57e0274dacb10e0ac868cb6cd70876950cf361c41879c030a2b8b/warc3-wet-clueweb09-0.2.5.tar.gz", upload-time = 2020-12-07T23:59:04Z, size = 17853, hashes = { sha256 = "3054bfc07da525d5967df8ca3175f78fa3f78514c82643f8c81fbca96300b836" } } + +[[packages]] +name = "wcwidth" +version = "0.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/35/a2/8e3becb46433538a38726c948d3399905a4c7cabd0df578ede5dc51f0ec2/wcwidth-0.6.0.tar.gz", upload-time = 2026-02-06T19:19:40Z, size = 159684, hashes = { sha256 = "cdc4e4262d6ef9a1a57e018384cbeb1208d8abbc64176027e2c2455c81313159" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/68/5a/199c59e0a824a3db2b89c5d2dade7ab5f9624dbf6448dc291b46d5ec94d3/wcwidth-0.6.0-py3-none-any.whl", upload-time = 2026-02-06T19:19:39Z, size = 94189, hashes = { sha256 = "1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad" } }] + +[[packages]] +name = "websockets" +version = "14.2" +sdist = { url = "https://files.pythonhosted.org/packages/94/54/8359678c726243d19fae38ca14a334e740782336c9f19700858c4eb64a1e/websockets-14.2.tar.gz", upload-time = 2025-01-19T21:00:56Z, size = 164394, hashes = { sha256 = "5059ed9c54945efb321f097084b4c7e52c246f2c869815876a69d1efc4ad6eb5" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/da/72f7caabd94652e6eb7e92ed2d3da818626e70b4f2b15a854ef60bf501ec/websockets-14.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-01-19T20:59:40Z, size = 170178, hashes = { sha256 = "a39d7eceeea35db85b85e1169011bb4321c32e673920ae9c1b6e0978590012a3" } }, + { url = "https://files.pythonhosted.org/packages/7b/c8/d529f8a32ce40d98309f4470780631e971a5a842b60aec864833b3615786/websockets-14.2-py3-none-any.whl", upload-time = 2025-01-19T21:00:54Z, size = 157416, hashes = { sha256 = "7a6ceec4ea84469f15cf15807a747e9efe57e369c384fa86e022b3bea679b79b" } }, +] + +[[packages]] +name = "xlsxwriter" +version = "3.2.9" +sdist = { url = "https://files.pythonhosted.org/packages/46/2c/c06ef49dc36e7954e55b802a8b231770d286a9758b3d936bd1e04ce5ba88/xlsxwriter-3.2.9.tar.gz", upload-time = 2025-09-16T00:16:21Z, size = 215940, hashes = { sha256 = "254b1c37a368c444eac6e2f867405cc9e461b0ed97a3233b2ac1e574efb4140c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3a/0c/3662f4a66880196a590b202f0db82d919dd2f89e99a27fadef91c4a33d41/xlsxwriter-3.2.9-py3-none-any.whl", upload-time = 2025-09-16T00:16:20Z, size = 175315, hashes = { sha256 = "9a5db42bc5dff014806c58a20b9eae7322a134abb6fce3c92c181bfb275ec5b3" } }] + +[[packages]] +name = "xxhash" +version = "3.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/24/2f/e183a1b407002f5af81822bee18b61cdb94b8670208ef34734d8d2b8ebe9/xxhash-3.7.0.tar.gz", upload-time = 2026-04-25T11:10:32Z, size = 82022, hashes = { sha256 = "6cc4eefbb542a5d6ffd6d70ea9c502957c925e800f998c5630ecc809d6702bae" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/40/37/558f5a90c0672fc9b4402dc25d87ac5b7406616e8969430c9ca4e52ee74d/xxhash-3.7.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-25T11:06:31Z, size = 193932, hashes = { sha256 = "13805f0461cba0a857924e70ff91ae6d52d2598f79a884e788db80532614a4a1" } }] + +[[packages]] +name = "yarl" +version = "1.23.0" +sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", upload-time = 2026-03-01T22:07:53Z, size = 194676, hashes = { sha256 = "53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-01T22:05:23Z, size = 100132, hashes = { sha256 = "a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51" } }, + { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", upload-time = 2026-03-01T22:07:51Z, size = 48288, hashes = { sha256 = "a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f" } }, +] + +[[packages]] +name = "zlib-state" +version = "0.1.12" +sdist = { url = "https://files.pythonhosted.org/packages/53/f2/c1b3dfb76ff3eac8eb2a96eb1e8e05c13534c73f0d1d582dfadadb5a863a/zlib_state-0.1.12.tar.gz", upload-time = 2026-04-14T19:08:30Z, size = 9618, hashes = { sha256 = "ccbb06321daf165b022aa4d22d62effb7df76f55035d50bbe8b93696db416cf0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/bb/20/b26f462b948ea8e66f878502c9594a32eda4e8ad96d9943667f4fe0f7a91/zlib_state-0.1.12-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-14T19:09:45Z, size = 22006, hashes = { sha256 = "91a0b6c7007ed4bd3162ac33114ceea62c28b24cd585efe3a10d2626576b445a" } }] diff --git a/packages/sie_server/bundle-locks/cpu-default-arm64/manifest.json b/packages/sie_server/bundle-locks/cpu-default-arm64/manifest.json new file mode 100644 index 000000000..08794a5a0 --- /dev/null +++ b/packages/sie_server/bundle-locks/cpu-default-arm64/manifest.json @@ -0,0 +1,39 @@ +{ + "completed_artifact_hashes": [ + { + "bytes": 134899, + "sha256": "85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", + "url": "https://download.pytorch.org/whl/jinja2-3.1.6-py3-none-any.whl" + }, + { + "bytes": 24332, + "sha256": "3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", + "url": "https://download.pytorch.org/whl/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl" + } + ], + "exceptions_sha256": "037ef3a52730b5f0ee32112a4cd6e2d48cbce1b165744c98d460d28d72d02287", + "exclude_newer": "2026-10-18T00:00:00Z", + "indexes": [ + "--default-index", + "https://pypi.org/simple", + "--index", + "https://download.pytorch.org/whl/cpu", + "--index-strategy", + "unsafe-best-match" + ], + "inputs": { + "requirements_sha256": "397c01d0c898fe61f36cd06392478cf6dd42a41190a7516767b7cfe3dde5bb6e", + "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" + }, + "lock_sha256": "49f489165b533576418ef6d0c7d86cacc968e57e335d76f145988392cb56a663", + "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "schema_version": 1, + "target": { + "architecture": "arm64", + "bundle": "default", + "platform": "cpu", + "python_platform": "aarch64-manylinux_2_35", + "python_version": "3.12" + }, + "uv_version": "0.9.28" +} diff --git a/packages/sie_server/bundle-locks/cpu-default-arm64/pylock.toml b/packages/sie_server/bundle-locks/cpu-default-arm64/pylock.toml new file mode 100644 index 000000000..2e2be9afe --- /dev/null +++ b/packages/sie_server/bundle-locks/cpu-default-arm64/pylock.toml @@ -0,0 +1,888 @@ +lock-version = "1.0" +created-by = "uv" +requires-python = ">=3.12" + +[[packages]] +name = "accelerate" +version = "1.15.0" +sdist = { url = "https://files.pythonhosted.org/packages/f5/b5/1d3ed029ac71d3f2961346829a268da923698e9fd63f218f78841f216bfd/accelerate-1.15.0.tar.gz", upload-time = 2026-09-09T13:04:49Z, size = 422615, hashes = { sha256 = "5654f8c5eaa0d4fa68b33e287a97765da6849bf6d51dcac874e73fbbddfb6134" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8a/4c/34f0450479d01195027260da68d8a3880683f1640c3ca5adf64acb3185f1/accelerate-1.15.0-py3-none-any.whl", upload-time = 2026-09-09T13:04:47Z, size = 394295, hashes = { sha256 = "97eacca0b73e45cb867dbf8c5d5d4dc32219544300e0c8992c7334dc2ef33cec" } }] + +[[packages]] +name = "aiohappyeyeballs" +version = "2.6.1" +sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", upload-time = 2025-03-12T01:42:48Z, size = 22760, hashes = { sha256 = "c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", upload-time = 2025-03-12T01:42:47Z, size = 15265, hashes = { sha256 = "f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8" } }] + +[[packages]] +name = "aiohttp" +version = "3.14.3" +sdist = { url = "https://files.pythonhosted.org/packages/58/d9/22ce5786ac0c1653ae8b6c23bded02c1686d11f0dbb45b31ce128e0df985/aiohttp-3.14.3.tar.gz", upload-time = 2026-07-23T01:57:27Z, size = 7971213, hashes = { sha256 = "9491196535a88924a60afd5b5f434b5b203b6cc616250878dbdb223a8f7844bc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/54/b9/42e74c46b7b7c794b995bbc1f573fb48950c38b19d8600c62a6804ee2d67/aiohttp-3.14.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-07-23T01:53:59Z, size = 1765282, hashes = { sha256 = "f631fe87a6f30df5fbe6d79640b25e4cffb38c31c7fb6f10871517b84b0f8c1a" } }] + +[[packages]] +name = "aiosignal" +version = "1.4.0" +sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", upload-time = 2025-07-03T22:54:43Z, size = 25007, hashes = { sha256 = "f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", upload-time = 2025-07-03T22:54:42Z, size = 7490, hashes = { sha256 = "053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e" } }] + +[[packages]] +name = "annotated-doc" +version = "0.0.4" +sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", upload-time = 2025-11-10T22:07:42Z, size = 7288, hashes = { sha256 = "fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", upload-time = 2025-11-10T22:07:40Z, size = 5303, hashes = { sha256 = "571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320" } }] + +[[packages]] +name = "annotated-types" +version = "0.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", upload-time = 2024-05-20T21:33:25Z, size = 16081, hashes = { sha256 = "aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", upload-time = 2024-05-20T21:33:24Z, size = 13643, hashes = { sha256 = "1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53" } }] + +[[packages]] +name = "antlr4-python3-runtime" +version = "4.9.3" +sdist = { url = "https://files.pythonhosted.org/packages/3e/38/7859ff46355f76f8d19459005ca000b6e7012f2f1ca597746cbcd1fbfe5e/antlr4-python3-runtime-4.9.3.tar.gz", upload-time = 2021-11-06T17:52:23Z, size = 117034, hashes = { sha256 = "f224469b4168294902bb1efa80a8bf7855f24c99aef99cbefc1bcd3cce77881b" } } + +[[packages]] +name = "anyio" +version = "4.14.2" +sdist = { url = "https://files.pythonhosted.org/packages/61/cc/a381afa6efea9f496eff839d4a6a1aed3bfafc7b3ab4b0d1b243a12573dd/anyio-4.14.2.tar.gz", upload-time = 2026-07-12T20:29:07Z, size = 260176, hashes = { sha256 = "cfa139f3ed1a23ee8f88a145ddb5ac7605b8bbfd8592baacd7ce3d8bb4313c7f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/da/35/f2287558c17e29fafc8ef3daf819bb9834061cfa43bff8014f7df7f63bdc/anyio-4.14.2-py3-none-any.whl", upload-time = 2026-07-12T20:29:05Z, size = 125813, hashes = { sha256 = "9f505dda5ac9f0c8309b5e8bd445a8c2bf7246f3ce950121e45ea15bc41d1494" } }] + +[[packages]] +name = "attrs" +version = "26.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", upload-time = 2026-03-19T14:22:25Z, size = 952055, hashes = { sha256 = "d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", upload-time = 2026-03-19T14:22:23Z, size = 67548, hashes = { sha256 = "c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309" } }] + +[[packages]] +name = "beautifulsoup4" +version = "4.14.3" +sdist = { url = "https://files.pythonhosted.org/packages/c3/b0/1c6a16426d389813b48d95e26898aff79abbde42ad353958ad95cc8c9b21/beautifulsoup4-4.14.3.tar.gz", upload-time = 2025-11-30T15:08:26Z, size = 627737, hashes = { sha256 = "6292b1c5186d356bba669ef9f7f051757099565ad9ada5dd630bd9de5fa7fb86" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1a/39/47f9197bdd44df24d67ac8893641e16f386c984a0619ef2ee4c51fbbc019/beautifulsoup4-4.14.3-py3-none-any.whl", upload-time = 2025-11-30T15:08:24Z, size = 107721, hashes = { sha256 = "0918bfe44902e6ad8d57732ba310582e98da931428d231a5ecb9e7c703a735bb" } }] + +[[packages]] +name = "cbor" +version = "1.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/9b/99/01c6a987c920500189eb74a291bd3a388e6c7cf85736bb6b066d9833315e/cbor-1.0.0.tar.gz", upload-time = 2016-02-09T23:11:12Z, size = 20096, hashes = { sha256 = "13225a262ddf5615cbd9fd55a76a0d53069d18b07d2e9f19c39e6acb8609bbb6" } } + +[[packages]] +name = "certifi" +version = "2026.4.22" +sdist = { url = "https://files.pythonhosted.org/packages/25/ee/6caf7a40c36a1220410afe15a1cc64993a1f864871f698c0f93acb72842a/certifi-2026.4.22.tar.gz", upload-time = 2026-04-22T11:26:11Z, size = 137077, hashes = { sha256 = "8d455352a37b71bf76a79caa83a3d6c25afee4a385d632127b6afb3963f1c580" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/22/30/7cd8fdcdfbc5b869528b079bfb76dcdf6056b1a2097a662e5e8c04f42965/certifi-2026.4.22-py3-none-any.whl", upload-time = 2026-04-22T11:26:09Z, size = 135707, hashes = { sha256 = "3cb2210c8f88ba2318d29b0388d1023c8492ff72ecdde4ebdaddbb13a31b1c4a" } }] + +[[packages]] +name = "charset-normalizer" +version = "3.4.7" +sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", upload-time = 2026-04-02T09:28:39Z, size = 144271, hashes = { sha256 = "ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f8/e3/0fadc706008ac9d7b9b5be6dc767c05f9d3e5df51744ce4cc9605de7b9f4/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-04-02T09:26:25Z, size = 208061, hashes = { sha256 = "6178f72c5508bfc5fd446a5905e698c6212932f25bcdd4b47a757a50605a90e2" } }, + { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", upload-time = 2026-04-02T09:28:37Z, size = 61958, hashes = { sha256 = "3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d" } }, +] + +[[packages]] +name = "click" +version = "8.1.8" +sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", upload-time = 2024-12-21T18:38:44Z, size = 226593, hashes = { sha256 = "ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", upload-time = 2024-12-21T18:38:41Z, size = 98188, hashes = { sha256 = "63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2" } }] + +[[packages]] +name = "colorlog" +version = "6.10.1" +sdist = { url = "https://files.pythonhosted.org/packages/a2/61/f083b5ac52e505dfc1c624eafbf8c7589a0d7f32daa398d2e7590efa5fda/colorlog-6.10.1.tar.gz", upload-time = 2025-10-16T16:14:11Z, size = 17162, hashes = { sha256 = "eb4ae5cb65fe7fec7773c2306061a8e63e02efc2c72eba9d27b0fa23c94f1321" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/6d/c1/e419ef3723a074172b68aaa89c9f3de486ed4c2399e2dbd8113a4fdcaf9e/colorlog-6.10.1-py3-none-any.whl", upload-time = 2025-10-16T16:14:10Z, size = 11743, hashes = { sha256 = "2d7e8348291948af66122cff006c9f8da6255d224e7cf8e37d8de2df3bad8c9c" } }] + +[[packages]] +name = "datasets" +version = "3.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/1a/89/d3d6fef58a488f8569c82fd293ab7cbd4250244d67f425dcae64c63800ea/datasets-3.6.0.tar.gz", upload-time = 2025-05-07T15:15:02Z, size = 569336, hashes = { sha256 = "1b2bf43b19776e2787e181cfd329cb0ca1a358ea014780c3581e0f276375e041" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/20/34/a08b0ee99715eaba118cbe19a71f7b5e2425c2718ef96007c325944a1152/datasets-3.6.0-py3-none-any.whl", upload-time = 2025-05-07T15:14:59Z, size = 491546, hashes = { sha256 = "25000c4a2c0873a710df127d08a202a06eab7bf42441a6bc278b499c2f72cd1b" } }] + +[[packages]] +name = "defusedxml" +version = "0.7.1" +sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", upload-time = 2021-03-08T10:59:26Z, size = 75520, hashes = { sha256 = "1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", upload-time = 2021-03-08T10:59:24Z, size = 25604, hashes = { sha256 = "a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61" } }] + +[[packages]] +name = "dill" +version = "0.3.8" +sdist = { url = "https://files.pythonhosted.org/packages/17/4d/ac7ffa80c69ea1df30a8aa11b3578692a5118e7cd1aa157e3ef73b092d15/dill-0.3.8.tar.gz", upload-time = 2024-01-27T23:42:16Z, size = 184847, hashes = { sha256 = "3ebe3c479ad625c4553aca177444d89b486b1d84982eeacded644afc0cf797ca" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c9/7a/cef76fd8438a42f96db64ddaa85280485a9c395e7df3db8158cfec1eee34/dill-0.3.8-py3-none-any.whl", upload-time = 2024-01-27T23:42:14Z, size = 116252, hashes = { sha256 = "c36ca9ffb54365bdd2f8eb3eff7d2a21237f8452b57ace88b1ac615b7e815bd7" } }] + +[[packages]] +name = "docling" +version = "2.99.0" +sdist = { url = "https://files.pythonhosted.org/packages/61/73/f6a0d6ada626281c1914dfb2de30c6e0067b1f8e3993e77eabb05fb08bf6/docling-2.99.0.tar.gz", upload-time = 2026-06-08T15:14:20Z, size = 8755, hashes = { sha256 = "306ea071d935f3852f75c873fe1b8663da580d2c359b8de162da52a6151c4c91" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/05/cc/cd8bea43057e64ec7755a18e009270500263f513e058649b909e83e2c0a7/docling-2.99.0-py3-none-any.whl", upload-time = 2026-06-08T15:14:19Z, size = 4798, hashes = { sha256 = "a78d4fd34e4ca495cd50003288b4de4a9b040dbff59f8ca5624aa8fa37d43728" } }] + +[[packages]] +name = "docling-core" +version = "2.79.0" +sdist = { url = "https://files.pythonhosted.org/packages/4d/b3/9196498f28c5a872b76b356df3ccefc20f2978eea12b8459a3398d036a2e/docling_core-2.79.0.tar.gz", upload-time = 2026-06-05T17:48:55Z, size = 334965, hashes = { sha256 = "3a5c6f757a95b93a1bb4c2c46efbe580f35a390f762a4b4105d97b7fca7cdfeb" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d0/f2/2cbf2b8ba8f2ebdefa5ebed29cf1d2eb4306a57ebf6c8b98703b7d4e2054/docling_core-2.79.0-py3-none-any.whl", upload-time = 2026-06-05T17:48:53Z, size = 286672, hashes = { sha256 = "42540cbd7ff8bca264e8e8fda9a66ad4446613f520bee8e130588193bc3e0212" } }] + +[[packages]] +name = "docling-ibm-models" +version = "3.13.2" +sdist = { url = "https://files.pythonhosted.org/packages/c1/25/84166f5751d7837612138966669019a4ef67c09bf6d3ef8d3cc1aa0e6268/docling_ibm_models-3.13.2.tar.gz", upload-time = 2026-04-23T11:04:23Z, size = 98655, hashes = { sha256 = "195e02dd119df34d2ce5f76ac614da82825851013e4898db7b0468cdf8740a3d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a4/fc/584f75ca31aa6694fed5338ecb54dc4c8341704b1e5b7b6a4528651f12fa/docling_ibm_models-3.13.2-py3-none-any.whl", upload-time = 2026-04-23T11:04:22Z, size = 94013, hashes = { sha256 = "5fa0838bf15a4e06d2fcb686d756a6f4c329ea0a8820d085f06d07abe96269ed" } }] + +[[packages]] +name = "docling-parse" +version = "6.2.0" +sdist = { url = "https://files.pythonhosted.org/packages/64/46/2c9c0738452368ad63018f380f4ad6fad8c69b64f04222aa012190bc8a4f/docling_parse-6.2.0.tar.gz", upload-time = 2026-05-28T04:31:53Z, size = 6670444, hashes = { sha256 = "f13d6c49e3b5f9caaf0d626e0dcc7948c5b4700d0eae0559ec353ed07c4f2f50" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d0/e0/3ed96ada48b96670a0817bd3fc11f7e6808aaf7d491354dd3b3deddb0725/docling_parse-6.2.0-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-05-28T04:31:25Z, size = 9808832, hashes = { sha256 = "33093dfb3c8105feb618887a127b19327e09fae7bf374eecbf5d10663d474a1e" } }] + +[[packages]] +name = "docling-slim" +version = "2.99.0" +sdist = { url = "https://files.pythonhosted.org/packages/a3/10/42e81debe1b7db6ae6dbbcd41f90f2aaa59501a1089fe9f304821783c409/docling_slim-2.99.0.tar.gz", upload-time = 2026-06-08T15:12:53Z, size = 410480, hashes = { sha256 = "b05150cda69e4c24c85aa32d2e329f21188dd4304547928eab32d8bb8b645bba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1c/d8/caa986a093c89238cc4019e10885677ffe4ee7aeb46a807626ac18654dfb/docling_slim-2.99.0-py3-none-any.whl", upload-time = 2026-06-08T15:12:51Z, size = 530895, hashes = { sha256 = "f67e31ca3cc39c5b19df3cfcb8fbe7bcc5ef29ffff320bbafca56e3b9ce40f24" } }] + +[[packages]] +name = "einops" +version = "0.8.2" +sdist = { url = "https://files.pythonhosted.org/packages/2c/77/850bef8d72ffb9219f0b1aac23fbc1bf7d038ee6ea666f331fa273031aa2/einops-0.8.2.tar.gz", upload-time = 2026-01-26T04:13:17Z, size = 56261, hashes = { sha256 = "609da665570e5e265e27283aab09e7f279ade90c4f01bcfca111f3d3e13f2827" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/09/f8d8f8f31e4483c10a906437b4ce31bdf3d6d417b73fe33f1a8b59e34228/einops-0.8.2-py3-none-any.whl", upload-time = 2026-01-26T04:13:18Z, size = 65638, hashes = { sha256 = "54058201ac7087911181bfec4af6091bb59380360f069276601256a76af08193" } }] + +[[packages]] +name = "et-xmlfile" +version = "2.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/d3/38/af70d7ab1ae9d4da450eeec1fa3918940a5fafb9055e934af8d6eb0c2313/et_xmlfile-2.0.0.tar.gz", upload-time = 2024-10-25T17:25:40Z, size = 17234, hashes = { sha256 = "dab3f4764309081ce75662649be815c4c9081e88f0837825f90fd28317d4da54" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c1/8b/5fe2cc11fee489817272089c4203e679c63b570a5aaeb18d852ae3cbba6a/et_xmlfile-2.0.0-py3-none-any.whl", upload-time = 2024-10-25T17:25:39Z, size = 18059, hashes = { sha256 = "7a91720bc756843502c3b7504c77b8fe44217c85c537d85037f0f536151b2caa" } }] + +[[packages]] +name = "faker" +version = "40.15.0" +sdist = { url = "https://files.pythonhosted.org/packages/7f/13/6741787bd91c4109c7bed047d68273965cd52ce8a5f773c471b949334b6d/faker-40.15.0.tar.gz", upload-time = 2026-04-17T20:05:27Z, size = 1967447, hashes = { sha256 = "20f3a6ec8c266b74d4c554e34118b21c3c2056c0b4a519d15c8decb3a4e6e795" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a7/a7/a600f8f30d4505e89166de51dd121bd540ab8e560e8cf0901de00a81de8c/faker-40.15.0-py3-none-any.whl", upload-time = 2026-04-17T20:05:25Z, size = 2004447, hashes = { sha256 = "71ab3c3370da9d2205ab74ffb0fd51273063ad562b3a3bb69d0026a20923e318" } }] + +[[packages]] +name = "filelock" +version = "3.29.0" +sdist = { url = "https://files.pythonhosted.org/packages/b5/fe/997687a931ab51049acce6fa1f23e8f01216374ea81374ddee763c493db5/filelock-3.29.0.tar.gz", upload-time = 2026-04-19T15:39:10Z, size = 57571, hashes = { sha256 = "69974355e960702e789734cb4871f884ea6fe50bd8404051a3530bc07809cf90" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/81/47/dd9a212ef6e343a6857485ffe25bba537304f1913bdbed446a23f7f592e1/filelock-3.29.0-py3-none-any.whl", upload-time = 2026-04-19T15:39:08Z, size = 39812, hashes = { sha256 = "96f5f6344709aa1572bbf631c640e4ebeeb519e08da902c39a001882f30ac258" } }] + +[[packages]] +name = "filetype" +version = "1.2.0" +sdist = { url = "https://files.pythonhosted.org/packages/bb/29/745f7d30d47fe0f251d3ad3dc2978a23141917661998763bebb6da007eb1/filetype-1.2.0.tar.gz", upload-time = 2022-11-02T17:34:04Z, size = 998020, hashes = { sha256 = "66b56cd6474bf41d8c54660347d37afcc3f7d1970648de365c102ef77548aadb" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/18/79/1b8fa1bb3568781e84c9200f951c735f3f157429f44be0495da55894d620/filetype-1.2.0-py2.py3-none-any.whl", upload-time = 2022-11-02T17:34:01Z, size = 19970, hashes = { sha256 = "7ce71b6880181241cf7ac8697a2f1eb6a8bd9b429f7ad6d27b8db9ba5f1c2d25" } }] + +[[packages]] +name = "flagembedding" +version = "1.4.0" +sdist = { url = "https://files.pythonhosted.org/packages/07/51/22dc9c448577542b3c3d75ae48eda0a97dfa29552a56cddd87437fec5940/flagembedding-1.4.0.tar.gz", upload-time = 2026-04-22T16:09:54Z, size = 175024, hashes = { sha256 = "2079c14ecf0341d64519785e53c0401122a752e5b6a0ac497f23c02f0d21b3b9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/73/70/3593ccb1299f8440369fd3c542ef2f5c09718eb8c7628614303e65dd38f8/flagembedding-1.4.0-py3-none-any.whl", upload-time = 2026-04-22T16:09:52Z, size = 247714, hashes = { sha256 = "fb1856b312851591341cf4533187350e9ce43f66bbf195c66f25a73266ff7db9" } }] + +[[packages]] +name = "flatbuffers" +version = "25.12.19" +wheels = [{ url = "https://files.pythonhosted.org/packages/e8/2d/d2a548598be01649e2d46231d151a6c56d10b964d94043a335ae56ea2d92/flatbuffers-25.12.19-py2.py3-none-any.whl", upload-time = 2025-12-19T23:16:13Z, size = 26661, hashes = { sha256 = "7634f50c427838bb021c2d66a3d1168e9d199b0607e6329399f04846d42e20b4" } }] + +[[packages]] +name = "frozenlist" +version = "1.8.0" +sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", upload-time = 2025-10-06T05:38:17Z, size = 45875, hashes = { sha256 = "3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2025-10-06T05:36:11Z, size = 243014, hashes = { sha256 = "96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4" } }, + { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", upload-time = 2025-10-06T05:38:16Z, size = 13409, hashes = { sha256 = "0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d" } }, +] + +[[packages]] +name = "fsspec" +version = "2025.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/34/f4/5721faf47b8c499e776bc34c6a8fc17efdf7fdef0b00f398128bc5dcb4ac/fsspec-2025.3.0.tar.gz", upload-time = 2025-03-07T21:47:56Z, size = 298491, hashes = { sha256 = "a935fd1ea872591f2b5148907d103488fc523295e6c64b835cfad8c3eca44972" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/56/53/eb690efa8513166adef3e0669afd31e95ffde69fb3c52ec2ac7223ed6018/fsspec-2025.3.0-py3-none-any.whl", upload-time = 2025-03-07T21:47:54Z, size = 193615, hashes = { sha256 = "efb87af3efa9103f94ca91a7f8cb7a4df91af9f74fc106c9c7ea0efd7277c1b3" } }] + +[[packages]] +name = "ftfy" +version = "6.3.1" +sdist = { url = "https://files.pythonhosted.org/packages/a5/d3/8650919bc3c7c6e90ee3fa7fd618bf373cbbe55dff043bd67353dbb20cd8/ftfy-6.3.1.tar.gz", upload-time = 2024-10-26T00:50:35Z, size = 308927, hashes = { sha256 = "9b3c3d90f84fb267fe64d375a07b7f8912d817cf86009ae134aa03e1819506ec" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ab/6e/81d47999aebc1b155f81eca4477a616a70f238a2549848c38983f3c22a82/ftfy-6.3.1-py3-none-any.whl", upload-time = 2024-10-26T00:50:33Z, size = 44821, hashes = { sha256 = "7c70eb532015cd2f9adb53f101fb6c7945988d023a085d127d1573dc49dd0083" } }] + +[[packages]] +name = "gliclass" +version = "0.1.17" +sdist = { url = "https://files.pythonhosted.org/packages/f5/4d/a14af220823eccbd4f2edfff303b24f0e2acf1a0f4177318347bf0c8524e/gliclass-0.1.17.tar.gz", upload-time = 2026-04-30T14:35:58Z, size = 47472, hashes = { sha256 = "17d2ec477da2270337cad9d8ae4ae90b8c675d1bfed9c73bc77d44996d36b522" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/52/3f/0b4e6253a14af7bd1e7306f0b1a8dc6af607caa4a9868015234ee94ad27c/gliclass-0.1.17-py3-none-any.whl", upload-time = 2026-04-30T14:35:57Z, size = 48821, hashes = { sha256 = "330c89e4fb39b50cc9c62d52c44dc7c5a13303883680706c71b598ecf88ab354" } }] + +[[packages]] +name = "gliformer" +version = "0.1.2" +sdist = { url = "https://files.pythonhosted.org/packages/5e/a7/c0e8c23f576de77c3fd323a045cb56fb4d8821e7c13be7b06ca5c0435d5d/gliformer-0.1.2.tar.gz", upload-time = 2026-09-15T15:40:35Z, size = 422264, hashes = { sha256 = "7b1ae88206dcddce33dacf60f750f509d4188d07f6aa82a7df40d4a1134f800b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3c/06/49c0c4eefd7672025909359ed534a862ea8217fc1e08460ee8957d5cc25b/gliformer-0.1.2-py3-none-any.whl", upload-time = 2026-09-15T15:40:33Z, size = 435508, hashes = { sha256 = "b9a1194b56fc0ab193fef919ad68d0b3086ce2fe3f0b4392ce26873139ac8768" } }] + +[[packages]] +name = "gliner" +version = "0.2.26" +sdist = { url = "https://files.pythonhosted.org/packages/49/18/e199cb97147c4a9260c75e4caf51e17be6ff969b0604a029c9c62810cbe0/gliner-0.2.26.tar.gz", upload-time = 2026-03-19T15:07:22Z, size = 181224, hashes = { sha256 = "6783be92b4b81caa878dcc4269ba37800207c37118d8ff9be028b93bddd6813d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7c/6e/d54d3d2867e29b68a22b144f570c8204209647fccc7879cec5218d6ed5fb/gliner-0.2.26-py3-none-any.whl", upload-time = 2026-03-19T15:07:19Z, size = 170429, hashes = { sha256 = "b9baa47641efb90b9d069add0528ed2464d137991ff097f42b0cab37a91ba991" } }] + +[[packages]] +name = "gliner2" +version = "2.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/b2/a8/2dcfdb8862dbeb488b6b86047075a213cc101ca592eae1a43b824cca74dd/gliner2-2.0.0.tar.gz", upload-time = 2026-08-24T15:13:43Z, size = 565826, hashes = { sha256 = "82b149f893ba0f6adf75ef1db599b6dbecd9811cca34dbd0bac7cd9e90b90ce4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/00/44/87d2803c5c5c6c0bd22bce4d52c66c965dacae29e0121d7e04c9883711df/gliner2-2.0.0-py3-none-any.whl", upload-time = 2026-08-24T15:13:41Z, size = 326214, hashes = { sha256 = "6f7c4cba0ef3173636d8bd9404aa94d4e0ccf36d4b4b9a0d27d740dd2d3236c3" } }] + +[[packages]] +name = "glirel" +version = "1.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/aa/17/366a8bcdf3631af9f11b989c3387b952cf3fd3b786df95952e826d64374a/glirel-1.2.1.tar.gz", upload-time = 2025-04-11T10:10:58Z, size = 49623, hashes = { sha256 = "96e0636810c6f020707a515d4f08aa36b7950c7d06030b5fe149b86d716e00e4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2f/62/fce91d0f41f493d1fb69db3df828aa6c2a76390a4a38db5db6a40b3b2150/glirel-1.2.1-py3-none-any.whl", upload-time = 2025-04-11T10:10:57Z, size = 54298, hashes = { sha256 = "ecbe2f955d8f2a406931022a10753e889761de7a736ec4090187830e49689aaf" } }] + +[[packages]] +name = "h11" +version = "0.16.0" +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", upload-time = 2025-04-24T03:35:25Z, size = 101250, hashes = { sha256 = "4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", upload-time = 2025-04-24T03:35:24Z, size = 37515, hashes = { sha256 = "63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86" } }] + +[[packages]] +name = "hf-xet" +version = "1.4.3" +marker = "platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" +sdist = { url = "https://files.pythonhosted.org/packages/53/92/ec9ad04d0b5728dca387a45af7bc98fbb0d73b2118759f5f6038b61a57e8/hf_xet-1.4.3.tar.gz", upload-time = 2026-03-31T22:40:07Z, size = 670477, hashes = { sha256 = "8ddedb73c8c08928c793df2f3401ec26f95be7f7e516a7bee2fbb546f6676113" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/53/60/46d493db155d2ee2801b71fb1b0fd67696359047fdd8caee2c914cc50c79/hf_xet-1.4.3-cp37-abi3-manylinux_2_28_aarch64.whl", upload-time = 2026-03-31T22:39:41Z, size = 3991546, hashes = { sha256 = "39f2d2e9654cd9b4319885733993807aab6de9dfbd34c42f0b78338d6617421f" } }] + +[[packages]] +name = "httpcore" +version = "1.0.9" +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", upload-time = 2025-04-24T22:06:22Z, size = 85484, hashes = { sha256 = "6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", upload-time = 2025-04-24T22:06:20Z, size = 78784, hashes = { sha256 = "2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55" } }] + +[[packages]] +name = "httpx" +version = "0.28.1" +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", upload-time = 2024-12-06T15:37:23Z, size = 141406, hashes = { sha256 = "75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", upload-time = 2024-12-06T15:37:21Z, size = 73517, hashes = { sha256 = "d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad" } }] + +[[packages]] +name = "huggingface-hub" +version = "0.36.2" +sdist = { url = "https://files.pythonhosted.org/packages/7c/b7/8cb61d2eece5fb05a83271da168186721c450eb74e3c31f7ef3169fa475b/huggingface_hub-0.36.2.tar.gz", upload-time = 2026-02-06T09:24:13Z, size = 649782, hashes = { sha256 = "1934304d2fb224f8afa3b87007d58501acfda9215b334eed53072dd5e815ff7a" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a8/af/48ac8483240de756d2438c380746e7130d1c6f75802ef22f3c6d49982787/huggingface_hub-0.36.2-py3-none-any.whl", upload-time = 2026-02-06T09:24:11Z, size = 566395, hashes = { sha256 = "48f0c8eac16145dfce371e9d2d7772854a4f591bcb56c9cf548accf531d54270" } }] + +[[packages]] +name = "idna" +version = "3.17" +sdist = { url = "https://files.pythonhosted.org/packages/b9/28/99c51f664567218d824af024c0251650fb27e4ca066df188dab0769c5b91/idna-3.17.tar.gz", upload-time = 2026-05-28T14:32:38Z, size = 196048, hashes = { sha256 = "5eb0cb53bc467c12eadcf6de83163ad8527cec9416f44b9b61b19caedad2b87f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/de/a7/f76514cc40ad6234098ecdebda08732d75964776c51a42845b7da10649e2/idna-3.17-py3-none-any.whl", upload-time = 2026-05-28T14:32:37Z, size = 65316, hashes = { sha256 = "466e48829084efe2548012b855df21540b96f2e20e51bd124c851536556a592c" } }] + +[[packages]] +name = "ijson" +version = "3.5.0" +sdist = { url = "https://files.pythonhosted.org/packages/f4/57/60d1a6a512f2f0508d0bc8b4f1cc5616fd3196619b66bd6a01f9155a1292/ijson-3.5.0.tar.gz", upload-time = 2026-02-24T03:58:30Z, size = 68658, hashes = { sha256 = "94688760720e3f5212731b3cb8d30267f9a045fb38fb3870254e7b9504246f31" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/11/be/bbc983059e48a54b0121ee60042979faed7674490bbe7b2c41560db3f436/ijson-3.5.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-02-24T03:57:13Z, size = 149785, hashes = { sha256 = "f1e73a44844d9adbca9cf2c4132cd875933e83f3d4b23881fcaf82be83644c7d" } }] + +[[packages]] +name = "inscriptis" +version = "2.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/23/f0/77b6eeaa0cde44b8ef0d5d0c2c0ee7ddeb6e6e4aebec33e15b8d0abbf3ed/inscriptis-2.6.0.tar.gz", upload-time = 2025-03-22T18:23:26Z, size = 41620, hashes = { sha256 = "6f164bf45ea6972d61fd048a8e074d5125d215eaa837f8e70c158c97c31c3181" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5e/c4/e1a68d42fa4609231da5f14e159c3d6256fb9e2951928592cebf7c899379/inscriptis-2.6.0-py3-none-any.whl", upload-time = 2025-03-22T18:23:24Z, size = 45120, hashes = { sha256 = "654dbcd0551c2f6004f8069a05cafff3eed2d327d5057adc6e657ba2610f52af" } }] + +[[packages]] +name = "ir-datasets" +version = "0.5.11" +sdist = { url = "https://files.pythonhosted.org/packages/80/c6/f02811c51fec845ee87a10bb3675516a2d71935b203e5ddb80b7eb59b1da/ir_datasets-0.5.11.tar.gz", upload-time = 2025-06-24T07:58:31Z, size = 758463, hashes = { sha256 = "06c90af634ae5063c813286b35065debca1a974d26e136403d899f3ecd7ad463" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/81/38/73fa582d6997362d9b4901b2a8ba1177b2d2896aa59ab8d069a3884e2e0d/ir_datasets-0.5.11-py3-none-any.whl", upload-time = 2025-06-24T07:58:29Z, size = 866095, hashes = { sha256 = "ae78549e5a7fa45e50462b7acb9f0765fc344fec6054108bf3dd063050555206" } }] + +[[packages]] +name = "jinja2" +version = "3.1.6" +wheels = [{ url = "https://download.pytorch.org/whl/jinja2-3.1.6-py3-none-any.whl", upload-time = 2025-10-14T18:38:59Z, hashes = { sha256 = "85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67" } }] + +[[packages]] +name = "joblib" +version = "1.5.3" +sdist = { url = "https://files.pythonhosted.org/packages/41/f2/d34e8b3a08a9cc79a50b2208a93dce981fe615b64d5a4d4abee421d898df/joblib-1.5.3.tar.gz", upload-time = 2025-12-15T08:41:46Z, size = 331603, hashes = { sha256 = "8561a3269e6801106863fd0d6d84bb737be9e7631e33aaed3fb9ce5953688da3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7b/91/984aca2ec129e2757d1e4e3c81c3fcda9d0f85b74670a094cc443d9ee949/joblib-1.5.3-py3-none-any.whl", upload-time = 2025-12-15T08:41:44Z, size = 309071, hashes = { sha256 = "5fc3c5039fc5ca8c0276333a188bbd59d6b7ab37fe6632daa76bc7f9ec18e713" } }] + +[[packages]] +name = "jsonlines" +version = "4.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/35/87/bcda8e46c88d0e34cad2f09ee2d0c7f5957bccdb9791b0b934ec84d84be4/jsonlines-4.0.0.tar.gz", upload-time = 2023-09-01T12:34:44Z, size = 11359, hashes = { sha256 = "0c6d2c09117550c089995247f605ae4cf77dd1533041d366351f6f298822ea74" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f8/62/d9ba6323b9202dd2fe166beab8a86d29465c41a0288cbe229fac60c1ab8d/jsonlines-4.0.0-py3-none-any.whl", upload-time = 2023-09-01T12:34:42Z, size = 8701, hashes = { sha256 = "185b334ff2ca5a91362993f42e83588a360cf95ce4b71a73548502bda52a7c55" } }] + +[[packages]] +name = "jsonref" +version = "1.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/aa/0d/c1f3277e90ccdb50d33ed5ba1ec5b3f0a242ed8c1b1a85d3afeb68464dca/jsonref-1.1.0.tar.gz", upload-time = 2023-01-16T16:10:04Z, size = 8814, hashes = { sha256 = "32fe8e1d85af0fdefbebce950af85590b22b60f9e95443176adbde4e1ecea552" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0c/ec/e1db9922bceb168197a558a2b8c03a7963f1afe93517ddd3cf99f202f996/jsonref-1.1.0-py3-none-any.whl", upload-time = 2023-01-16T16:10:02Z, size = 9425, hashes = { sha256 = "590dc7773df6c21cbf948b5dac07a72a251db28b0238ceecce0a2abfa8ec30a9" } }] + +[[packages]] +name = "jsonschema" +version = "4.23.0" +sdist = { url = "https://files.pythonhosted.org/packages/38/2e/03362ee4034a4c917f697890ccd4aec0800ccf9ded7f511971c75451deec/jsonschema-4.23.0.tar.gz", upload-time = 2024-07-08T18:40:05Z, size = 325778, hashes = { sha256 = "d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/69/4a/4f9dbeb84e8850557c02365a0eee0649abe5eb1d84af92a25731c6c0f922/jsonschema-4.23.0-py3-none-any.whl", upload-time = 2024-07-08T18:40:00Z, size = 88462, hashes = { sha256 = "fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566" } }] + +[[packages]] +name = "jsonschema-specifications" +version = "2025.9.1" +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", upload-time = 2025-09-08T01:34:59Z, size = 32855, hashes = { sha256 = "b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", upload-time = 2025-09-08T01:34:57Z, size = 18437, hashes = { sha256 = "98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe" } }] + +[[packages]] +name = "latex2mathml" +version = "3.81.0" +sdist = { url = "https://files.pythonhosted.org/packages/3b/62/35bb816c5c19d4d0cde5bdfb82ebb996306243d5f94e03f201658c629960/latex2mathml-3.81.0.tar.gz", upload-time = 2026-04-15T00:55:27Z, size = 77584, hashes = { sha256 = "4b959cdc3cac8686bc0e3e5aece8127dfb1b81ca1241bed8e00ef31b82bb4022" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e8/b1/c488b530994c4f68e46efa99a4d6ca6741aaf158e35779fe6c4d8a9a427d/latex2mathml-3.81.0-py3-none-any.whl", upload-time = 2026-04-15T00:55:29Z, size = 79185, hashes = { sha256 = "d317710393fe20579aea39cfe8928fa2ad9b8780896e585326c75e89c1d1d1a4" } }] + +[[packages]] +name = "loguru" +version = "0.7.3" +sdist = { url = "https://files.pythonhosted.org/packages/3a/05/a1dae3dffd1116099471c643b8924f5aa6524411dc6c63fdae648c4f1aca/loguru-0.7.3.tar.gz", upload-time = 2024-12-06T11:20:56Z, size = 63559, hashes = { sha256 = "19480589e77d47b8d85b2c827ad95d49bf31b0dcde16593892eb51dd18706eb6" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl", upload-time = 2024-12-06T11:20:54Z, size = 61595, hashes = { sha256 = "31a33c10c8e1e10422bfd431aeb5d351c7cf7fa671e3c4df004162264b28220c" } }] + +[[packages]] +name = "lxml" +version = "6.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/28/30/9abc9e34c657c33834eaf6cd02124c61bdf5944d802aa48e69be8da3585d/lxml-6.1.0.tar.gz", upload-time = 2026-04-18T04:32:51Z, size = 4197006, hashes = { sha256 = "bfd57d8008c4965709a919c3e9a98f76c2c7cb319086b3d26858250620023b13" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/90/97/a517944b20f8fd0932ad2109482bee4e29fe721416387a363306667941f6/lxml-6.1.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", upload-time = 2026-04-18T04:32:56Z, size = 4930895, hashes = { sha256 = "fc46da94826188ed45cb53bd8e3fc076ae22675aea2087843d4735627f867c6d" } }, + { url = "https://files.pythonhosted.org/packages/88/ee/2a5c2aa2c32016a226ca25d3e1056a8102ea6e1fe308bf50213586635400/lxml-6.1.0-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-04-18T04:33:01Z, size = 5005790, hashes = { sha256 = "5715e0e28736a070f3f34a7ccc09e2fdcba0e3060abbcf61a1a5718ff6d6b105" } }, +] + +[[packages]] +name = "lz4" +version = "4.4.5" +sdist = { url = "https://files.pythonhosted.org/packages/57/51/f1b86d93029f418033dddf9b9f79c8d2641e7454080478ee2aab5123173e/lz4-4.4.5.tar.gz", upload-time = 2025-11-03T13:02:36Z, size = 172886, hashes = { sha256 = "5f0b9e53c1e82e88c10d7c180069363980136b9d7a8306c4dca4f760d60c39f0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/90/1c/b1d8e3741e9fc89ed3b5f7ef5f22586c07ed6bb04e8343c2e98f0fa7ff04/lz4-4.4.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2025-11-03T13:01:50Z, size = 1279546, hashes = { sha256 = "2c3ea562c3af274264444819ae9b14dbbf1ab070aff214a05e97db6896c7597e" } }] + +[[packages]] +name = "mail-parser" +version = "4.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/01/6b/55b188888abccfc1dba0617a6d99da1c39dc355822900ae9d5bccf8756b2/mail_parser-4.3.0.tar.gz", upload-time = 2026-05-27T22:15:14Z, size = 2792149, hashes = { sha256 = "fb4c64ec0a74ed095b3bad274ab08f6fca024ad5fbf72ff9ccc501ba654ba3b2" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8d/4f/38717202a3be94a37c262907adca700498fbb435a8356cfaed38387469c8/mail_parser-4.3.0-py3-none-any.whl", upload-time = 2026-05-27T22:15:13Z, size = 33895, hashes = { sha256 = "e4092a15023b7075f4666f5040e2fca71fa35a7020753b7e90359c357ed3a099" } }] + +[[packages]] +name = "markdown-it-py" +version = "4.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", upload-time = 2025-08-11T12:57:52Z, size = 73070, hashes = { sha256 = "cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", upload-time = 2025-08-11T12:57:51Z, size = 87321, hashes = { sha256 = "87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147" } }] + +[[packages]] +name = "marko" +version = "2.2.2" +sdist = { url = "https://files.pythonhosted.org/packages/e3/2f/050b6d485f052ddf17d76a41f9334d6fb2a8a85df35347a12d97ed3bc5c1/marko-2.2.2.tar.gz", upload-time = 2026-01-05T11:04:41Z, size = 143641, hashes = { sha256 = "6940308e655f63733ca518c47a68ec9510279dbb916c83616e4c4b5829f052e8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/83/f8/36d79bac5701e6786f9880c61bbe57574760a13c1af84ab71e5ed21faecc/marko-2.2.2-py3-none-any.whl", upload-time = 2026-01-05T11:04:40Z, size = 42701, hashes = { sha256 = "f064ae8c10416285ad1d96048dc11e98ef04e662d3342ae416f662b70aa7959e" } }] + +[[packages]] +name = "markupsafe" +version = "3.0.3" +wheels = [{ url = "https://download.pytorch.org/whl/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-03-27T13:54:33Z, hashes = { sha256 = "3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d" } }] + +[[packages]] +name = "mdurl" +version = "0.1.2" +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", upload-time = 2022-08-14T12:40:10Z, size = 8729, hashes = { sha256 = "bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", upload-time = 2022-08-14T12:40:09Z, size = 9979, hashes = { sha256 = "84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8" } }] + +[[packages]] +name = "mpire" +version = "2.10.2" +sdist = { url = "https://files.pythonhosted.org/packages/3a/93/80ac75c20ce54c785648b4ed363c88f148bf22637e10c9863db4fbe73e74/mpire-2.10.2.tar.gz", upload-time = 2024-05-07T14:00:31Z, size = 271270, hashes = { sha256 = "f66a321e93fadff34585a4bfa05e95bd946cf714b442f51c529038eb45773d97" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/20/14/1db1729ad6db4999c3a16c47937d601fcb909aaa4224f5eca5a2f145a605/mpire-2.10.2-py3-none-any.whl", upload-time = 2024-05-07T14:00:29Z, size = 272756, hashes = { sha256 = "d627707f7a8d02aa4c7f7d59de399dec5290945ddf7fbd36cbb1d6ebb37a51fb" } }] + +[[packages]] +name = "mpmath" +version = "1.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", upload-time = 2023-03-07T16:47:11Z, size = 508106, hashes = { sha256 = "7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", upload-time = 2023-03-07T16:47:09Z, size = 536198, hashes = { sha256 = "a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c" } }] + +[[packages]] +name = "multidict" +version = "6.7.1" +sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", upload-time = 2026-01-26T02:46:45Z, size = 102010, hashes = { sha256 = "ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/80/c959c5933adedb9ac15152e4067c702a808ea183a8b64cf8f31af8ad3155/multidict-6.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-01-26T02:43:57Z, size = 258883, hashes = { sha256 = "eb0ce7b2a32d09892b3dd6cc44877a0d02a33241fafca5f25c8b6b62374f8b75" } }, + { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", upload-time = 2026-01-26T02:46:44Z, size = 12319, hashes = { sha256 = "55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56" } }, +] + +[[packages]] +name = "multiprocess" +version = "0.70.16" +sdist = { url = "https://files.pythonhosted.org/packages/b5/ae/04f39c5d0d0def03247c2893d6f2b83c136bf3320a2154d7b8858f2ba72d/multiprocess-0.70.16.tar.gz", upload-time = 2024-01-28T18:52:34Z, size = 1772603, hashes = { sha256 = "161af703d4652a0e1410be6abccecde4a7ddffd19341be0a7011b94aeb171ac1" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bc/f7/7ec7fddc92e50714ea3745631f79bd9c96424cb2702632521028e57d3a36/multiprocess-0.70.16-py310-none-any.whl", upload-time = 2024-01-28T18:52:26Z, size = 134824, hashes = { sha256 = "c4a9944c67bd49f823687463660a2d6daae94c289adff97e0f9d696ba6371d02" } }, + { url = "https://files.pythonhosted.org/packages/50/15/b56e50e8debaf439f44befec5b2af11db85f6e0f344c3113ae0be0593a91/multiprocess-0.70.16-py311-none-any.whl", upload-time = 2024-01-28T18:52:28Z, size = 143519, hashes = { sha256 = "af4cabb0dac72abfb1e794fa7855c325fd2b55a10a44628a3c1ad3311c04127a" } }, + { url = "https://files.pythonhosted.org/packages/0a/7d/a988f258104dcd2ccf1ed40fdc97e26c4ac351eeaf81d76e266c52d84e2f/multiprocess-0.70.16-py312-none-any.whl", upload-time = 2024-01-28T18:52:29Z, size = 146741, hashes = { sha256 = "fc0544c531920dde3b00c29863377f87e1632601092ea2daca74e4beb40faa2e" } }, + { url = "https://files.pythonhosted.org/packages/ea/89/38df130f2c799090c978b366cfdf5b96d08de5b29a4a293df7f7429fa50b/multiprocess-0.70.16-py38-none-any.whl", upload-time = 2024-01-28T18:52:30Z, size = 132628, hashes = { sha256 = "a71d82033454891091a226dfc319d0cfa8019a4e888ef9ca910372a446de4435" } }, + { url = "https://files.pythonhosted.org/packages/da/d9/f7f9379981e39b8c2511c9e0326d212accacb82f12fbfdc1aa2ce2a7b2b6/multiprocess-0.70.16-py39-none-any.whl", upload-time = 2024-01-28T18:52:31Z, size = 133351, hashes = { sha256 = "a0bafd3ae1b732eac64be2e72038231c1ba97724b60b09400d68f229fcc2fbf3" } }, +] + +[[packages]] +name = "networkx" +version = "3.6.1" +sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", upload-time = 2025-12-08T17:02:39Z, size = 2517025, hashes = { sha256 = "26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", upload-time = 2025-12-08T17:02:38Z, size = 2068504, hashes = { sha256 = "d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762" } }] + +[[packages]] +name = "numpy" +version = "2.4.4" +sdist = { url = "https://files.pythonhosted.org/packages/d7/9f/b8cef5bffa569759033adda9481211426f12f53299629b410340795c2514/numpy-2.4.4.tar.gz", upload-time = 2026-03-29T13:22:01Z, size = 20731587, hashes = { sha256 = "2d390634c5182175533585cc89f3608a4682ccb173cc9bb940b2881c8d6f8fa0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7f/37/eed308a8f56cba4d1fdf467a4fc67ef4ff4bf1c888f5fc980481890104b1/numpy-2.4.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-03-29T13:19:00Z, size = 15670666, hashes = { sha256 = "f9e75681b59ddaa5e659898085ae0eaea229d054f2ac0c7e563a62205a700121" } }] + +[[packages]] +name = "omegaconf" +version = "2.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/09/48/6388f1bb9da707110532cb70ec4d2822858ddfb44f1cdf1233c20a80ea4b/omegaconf-2.3.0.tar.gz", upload-time = 2022-12-08T20:59:22Z, size = 3298120, hashes = { sha256 = "d5d4b6d29955cc50ad50c46dc269bcd92c6e00f5f90d23ab5fee7bfca4ba4cc7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e3/94/1843518e420fa3ed6919835845df698c7e27e183cb997394e4a670973a65/omegaconf-2.3.0-py3-none-any.whl", upload-time = 2022-12-08T20:59:19Z, size = 79500, hashes = { sha256 = "7b4df175cdb08ba400f45cae3bdcae7ba8365db4d165fc65fd04b050ab63b46b" } }] + +[[packages]] +name = "onnxruntime" +version = "1.25.0" +wheels = [{ url = "https://files.pythonhosted.org/packages/5a/c6/19c5bfbc60396791e975652f982bcff9ff4b27947c8e2bf0064ac5d5727b/onnxruntime-1.25.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-04-22T17:19:31Z, size = 15841110, hashes = { sha256 = "9c99238d20bfa80ac68c7b03c2c936d389189ae40997f78a30d151570d7e18bf" } }] + +[[packages]] +name = "open-clip-torch" +version = "2.32.0" +sdist = { url = "https://files.pythonhosted.org/packages/6d/7b/fd38dfd522968135dce71d0b543c2ae776f9c8e27df6ad46b63bab09eef7/open_clip_torch-2.32.0.tar.gz", upload-time = 2025-04-05T21:55:24Z, size = 1491248, hashes = { sha256 = "0220bc111162527eb738c1fe20dbfd6ea45dfe44726b54a4de18d3945d8f2f00" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/32/f9/0458745c1d299411161ee3b6c32228a3de0be1d8497d779fd7f17a8e96aa/open_clip_torch-2.32.0-py3-none-any.whl", upload-time = 2025-04-05T21:55:22Z, size = 1528783, hashes = { sha256 = "80b35b43e37afc2b6173aa5ab0ad68744ab3a3211e624f72dfe743a162707637" } }] + +[[packages]] +name = "opencv-python" +version = "4.13.0.92" +wheels = [ + { url = "https://files.pythonhosted.org/packages/3e/51/82fed528b45173bf629fa44effb76dff8bc9f4eeaee759038362dfa60237/opencv_python-4.13.0.92-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", upload-time = 2026-02-05T06:59:11Z, size = 47685527, hashes = { sha256 = "0bc2596e68f972ca452d80f444bc404e08807d021fbba40df26b61b18e01838a" } }, + { url = "https://files.pythonhosted.org/packages/02/6d/7a9cc719b3eaf4377b9c2e3edeb7ed3a81de41f96421510c0a169ca3cfd4/opencv_python-4.13.0.92-cp37-abi3-manylinux_2_28_aarch64.whl", upload-time = 2026-02-05T06:59:15Z, size = 46708208, hashes = { sha256 = "bccaabf9eb7f897ca61880ce2869dcd9b25b72129c28478e7f2a5e8dee945616" } }, +] + +[[packages]] +name = "openpyxl" +version = "3.1.5" +sdist = { url = "https://files.pythonhosted.org/packages/3d/f9/88d94a75de065ea32619465d2f77b29a0469500e99012523b91cc4141cd1/openpyxl-3.1.5.tar.gz", upload-time = 2024-06-28T14:03:44Z, size = 186464, hashes = { sha256 = "cf0e3cf56142039133628b5acffe8ef0c12bc902d2aadd3e0fe5878dc08d1050" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c0/da/977ded879c29cbd04de313843e76868e6e13408a94ed6b987245dc7c8506/openpyxl-3.1.5-py2.py3-none-any.whl", upload-time = 2024-06-28T14:03:41Z, size = 250910, hashes = { sha256 = "5282c12b107bffeef825f4617dc029afaf41d0ea60823bbb665ef3079dc79de2" } }] + +[[packages]] +name = "packaging" +version = "24.2" +sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", upload-time = 2024-11-08T09:47:47Z, size = 163950, hashes = { sha256 = "c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", upload-time = 2024-11-08T09:47:44Z, size = 65451, hashes = { sha256 = "09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759" } }] + +[[packages]] +name = "pandas" +version = "2.3.3" +sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", upload-time = 2025-09-29T23:34:51Z, size = 4495223, hashes = { sha256 = "e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/57/56/cf2dbe1a3f5271370669475ead12ce77c61726ffd19a35546e31aa8edf4e/pandas-2.3.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2025-09-29T23:19:59Z, size = 11737212, hashes = { sha256 = "ecaf1e12bdc03c86ad4a7ea848d66c685cb6851d807a26aa245ca3d2017a1908" } }] + +[[packages]] +name = "peft" +version = "0.19.1" +sdist = { url = "https://files.pythonhosted.org/packages/86/cf/037f1e3d5186496c05513a6754639e2dab3038a05f384284d49a9bd06a2d/peft-0.19.1.tar.gz", upload-time = 2026-04-16T15:46:45Z, size = 763738, hashes = { sha256 = "0d97542fe96dcdaa20d3b81c06f26f988618f416a73544ab23c3618ccb674a40" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e8/b6/f54d676ed93cc2dd2234c3b172ea9c8c3d7d29361e66b1b23dec57a67465/peft-0.19.1-py3-none-any.whl", upload-time = 2026-04-16T15:46:42Z, size = 680692, hashes = { sha256 = "2113f72a81621b5913ef28f9022204c742df111890c5f49d812716a4a301e356" } }] + +[[packages]] +name = "pillow" +version = "12.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/1c/3d/bb7fca845737cf9d7dbde16ed1843984665ff2e0a518f5db43e77ec540b9/pillow-12.3.0.tar.gz", upload-time = 2026-07-01T11:56:38Z, size = 47025035, hashes = { sha256 = "3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/25/27/ac8f99618ffd3dde21db0f4d4b1d2ab00c0880595bfd17df103f7f39fd0c/pillow-12.3.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-07-01T11:54:11Z, size = 6266838, hashes = { sha256 = "d9c7f76c0673154f044e9d78c8655fb4213f6ca31a836df48b40fe5d187717b9" } }] + +[[packages]] +name = "pluggy" +version = "1.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", upload-time = 2025-05-15T12:30:07Z, size = 69412, hashes = { sha256 = "7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", upload-time = 2025-05-15T12:30:06Z, size = 20538, hashes = { sha256 = "e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746" } }] + +[[packages]] +name = "polyfactory" +version = "3.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/85/68/7717bd9e63ed254617a7d3dc9260904fb736d6ea203e58ffddcb186c64e4/polyfactory-3.3.0.tar.gz", upload-time = 2026-02-22T09:46:28Z, size = 348668, hashes = { sha256 = "237258b6ff43edf362ffd1f68086bb796466f786adfa002b0ac256dbf2246e9a" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/dd/34/b6f19941adcdaf415b5e8a8d577499f5b6a76b59cbae37f9b125a9ffe9f2/polyfactory-3.3.0-py3-none-any.whl", upload-time = 2026-02-22T09:46:25Z, size = 62707, hashes = { sha256 = "686abcaa761930d3df87b91e95b26b8d8cb9fdbbbe0b03d5f918acff5c72606e" } }] + +[[packages]] +name = "propcache" +version = "0.4.1" +sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", upload-time = 2025-10-08T19:49:02Z, size = 46442, hashes = { sha256 = "f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/d3/6c7ee328b39a81ee877c962469f1e795f9db87f925251efeb0545e0020d0/propcache-0.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2025-10-08T19:46:50Z, size = 225505, hashes = { sha256 = "ec17c65562a827bba85e3872ead335f95405ea1674860d96483a02f5c698fa72" } }, + { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", upload-time = 2025-10-08T19:49:00Z, size = 13305, hashes = { sha256 = "af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237" } }, +] + +[[packages]] +name = "protobuf" +version = "6.33.6" +sdist = { url = "https://files.pythonhosted.org/packages/66/70/e908e9c5e52ef7c3a6c7902c9dfbb34c7e29c25d2f81ade3856445fd5c94/protobuf-6.33.6.tar.gz", upload-time = 2026-03-18T19:05:00Z, size = 444531, hashes = { sha256 = "a6768d25248312c297558af96a9f9c929e8c4cee0659cb07e780731095f38135" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ee/90/b3c01fdec7d2f627b3a6884243ba328c1217ed2d978def5c12dc50d328a3/protobuf-6.33.6-cp39-abi3-manylinux2014_aarch64.whl", upload-time = 2026-03-18T19:04:53Z, size = 324610, hashes = { sha256 = "e2afbae9b8e1825e3529f88d514754e094278bb95eadc0e199751cdd9a2e82a2" } }, + { url = "https://files.pythonhosted.org/packages/c4/72/02445137af02769918a93807b2b7890047c32bfb9f90371cbc12688819eb/protobuf-6.33.6-py3-none-any.whl", upload-time = 2026-03-18T19:04:59Z, size = 170656, hashes = { sha256 = "77179e006c476e69bf8e8ce866640091ec42e1beb80b213c3900006ecfba6901" } }, +] + +[[packages]] +name = "psutil" +version = "7.2.2" +sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", upload-time = 2026-01-28T18:14:54Z, size = 493740, hashes = { sha256 = "0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/63/65/37648c0c158dc222aba51c089eb3bdfa238e621674dc42d48706e639204f/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-01-28T18:15:27Z, size = 156997, hashes = { sha256 = "b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e" } }] + +[[packages]] +name = "pyarrow" +version = "23.0.1" +sdist = { url = "https://files.pythonhosted.org/packages/88/22/134986a4cc224d593c1afde5494d18ff629393d74cc2eddb176669f234a4/pyarrow-23.0.1.tar.gz", upload-time = 2026-02-16T10:14:12Z, size = 1167336, hashes = { sha256 = "b8c5873e33440b2bc2f4a79d2b47017a89c5a24116c055625e6f2ee50523f019" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/88/7c/3d841c366620e906d54430817531b877ba646310296df42ef697308c2705/pyarrow-23.0.1-cp312-cp312-manylinux_2_28_aarch64.whl", upload-time = 2026-02-16T10:10:10Z, size = 44470940, hashes = { sha256 = "86ff03fb9f1a320266e0de855dee4b17da6794c595d207f89bba40d16b5c78b9" } }] + +[[packages]] +name = "pyclipper" +version = "1.4.0" +sdist = { url = "https://files.pythonhosted.org/packages/f6/21/3c06205bb407e1f79b73b7b4dfb3950bd9537c4f625a68ab5cc41177f5bc/pyclipper-1.4.0.tar.gz", upload-time = 2025-12-01T13:15:35Z, size = 54489, hashes = { sha256 = "9882bd889f27da78add4dd6f881d25697efc740bf840274e749988d25496c8e1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/cf/f4/3418c1cd5eea640a9fa2501d4bc0b3655fa8d40145d1a4f484b987990a75/pyclipper-1.4.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2025-12-01T13:15:08Z, size = 961388, hashes = { sha256 = "ce1f83c9a4e10ea3de1959f0ae79e9a5bd41346dff648fee6228ba9eaf8b3872" } }] + +[[packages]] +name = "pydantic" +version = "2.12.5" +sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", upload-time = 2025-11-26T15:11:46Z, size = 821591, hashes = { sha256 = "4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", upload-time = 2025-11-26T15:11:44Z, size = 463580, hashes = { sha256 = "e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d" } }] + +[[packages]] +name = "pydantic-core" +version = "2.41.5" +sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", upload-time = 2025-11-04T13:43:49Z, size = 460952, hashes = { sha256 = "08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2025-11-04T13:40:02Z, size = 1919200, hashes = { sha256 = "e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69" } }] + +[[packages]] +name = "pydantic-settings" +version = "2.14.2" +sdist = { url = "https://files.pythonhosted.org/packages/5c/b5/8f48e906c3e0205276e8bd8cb7512217a87b2685304d64be27cad5b3019f/pydantic_settings-2.14.2.tar.gz", upload-time = 2026-06-19T13:44:56Z, size = 237700, hashes = { sha256 = "c19dd64b19097f1de80184f0cc7b0272a13ae6e170cbf240a3e27e381ed14a5f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/77/c1/6e422f34e569cf8e18df68d1939c81c099d2b61e4f7d9621c8a77560799c/pydantic_settings-2.14.2-py3-none-any.whl", upload-time = 2026-06-19T13:44:55Z, size = 61715, hashes = { sha256 = "a20c97b37910b6550d5ea50fbcc2d4187defe58cd57070b73863d069419c9440" } }] + +[[packages]] +name = "pygments" +version = "2.20.0" +sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", upload-time = 2026-03-29T13:29:33Z, size = 4955991, hashes = { sha256 = "6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", upload-time = 2026-03-29T13:29:30Z, size = 1231151, hashes = { sha256 = "81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176" } }] + +[[packages]] +name = "pylatexenc" +version = "2.10" +sdist = { url = "https://files.pythonhosted.org/packages/5d/ab/34ec41718af73c00119d0351b7a2531d2ebddb51833a36448fc7b862be60/pylatexenc-2.10.tar.gz", upload-time = 2021-04-06T07:56:07Z, size = 162597, hashes = { sha256 = "3dd8fd84eb46dc30bee1e23eaab8d8fb5a7f507347b23e5f38ad9675c84f40d3" } } + +[[packages]] +name = "pypdfium2" +version = "5.7.1" +sdist = { url = "https://files.pythonhosted.org/packages/bc/13/ee794b8a810b7226426c8b50d6c28637c059e7da0caf9936164f352ef858/pypdfium2-5.7.1.tar.gz", upload-time = 2026-04-20T15:01:02Z, size = 266791, hashes = { sha256 = "3b3b20a56048dbe3fd4bf397f9bec854c834668bc47ef6a7d9041b23bb04317b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5b/98/6d62723e1f58d66e7e0073c4f12048f9d5dcd478369da0990db08e677dd5/pypdfium2-5.7.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2026-04-20T15:00:30Z, size = 3610098, hashes = { sha256 = "18a15ad0918acc3ea98778394f0331b9ad2a1b7384ab3d8d8c63422ffd01ed13" } }] + +[[packages]] +name = "python-dateutil" +version = "2.9.0.post0" +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", upload-time = 2024-03-01T18:36:20Z, size = 342432, hashes = { sha256 = "37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", upload-time = 2024-03-01T18:36:18Z, size = 229892, hashes = { sha256 = "a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427" } }] + +[[packages]] +name = "python-docx" +version = "1.2.0" +sdist = { url = "https://files.pythonhosted.org/packages/a9/f7/eddfe33871520adab45aaa1a71f0402a2252050c14c7e3009446c8f4701c/python_docx-1.2.0.tar.gz", upload-time = 2025-06-16T20:46:27Z, size = 5723256, hashes = { sha256 = "7bc9d7b7d8a69c9c02ca09216118c86552704edc23bac179283f2e38f86220ce" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d0/00/1e03a4989fa5795da308cd774f05b704ace555a70f9bf9d3be057b680bcf/python_docx-1.2.0-py3-none-any.whl", upload-time = 2025-06-16T20:46:22Z, size = 252987, hashes = { sha256 = "3fd478f3250fbbbfd3b94fe1e985955737c145627498896a8a6bf81f4baf66c7" } }] + +[[packages]] +name = "python-dotenv" +version = "1.2.2" +sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", upload-time = 2026-03-01T16:00:26Z, size = 50135, hashes = { sha256 = "2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", upload-time = 2026-03-01T16:00:25Z, size = 22101, hashes = { sha256 = "1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a" } }] + +[[packages]] +name = "python-pptx" +version = "1.0.2" +sdist = { url = "https://files.pythonhosted.org/packages/52/a9/0c0db8d37b2b8a645666f7fd8accea4c6224e013c42b1d5c17c93590cd06/python_pptx-1.0.2.tar.gz", upload-time = 2024-08-07T17:33:37Z, size = 10109297, hashes = { sha256 = "479a8af0eaf0f0d76b6f00b0887732874ad2e3188230315290cd1f9dd9cc7095" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d9/4f/00be2196329ebbff56ce564aa94efb0fbc828d00de250b1980de1a34ab49/python_pptx-1.0.2-py3-none-any.whl", upload-time = 2024-08-07T17:33:28Z, size = 472788, hashes = { sha256 = "160838e0b8565a8b1f67947675886e9fea18aa5e795db7ae531606d68e785cba" } }] + +[[packages]] +name = "pytz" +version = "2026.1.post1" +sdist = { url = "https://files.pythonhosted.org/packages/56/db/b8721d71d945e6a8ac63c0fc900b2067181dbb50805958d4d4661cf7d277/pytz-2026.1.post1.tar.gz", upload-time = 2026-03-03T07:47:50Z, size = 321088, hashes = { sha256 = "3378dde6a0c3d26719182142c56e60c7f9af7e968076f31aae569d72a0358ee1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/10/99/781fe0c827be2742bcc775efefccb3b048a3a9c6ce9aec0cbf4a101677e5/pytz-2026.1.post1-py2.py3-none-any.whl", upload-time = 2026-03-03T07:47:49Z, size = 510489, hashes = { sha256 = "f2fd16142fda348286a75e1a524be810bb05d444e5a081f37f7affc635035f7a" } }] + +[[packages]] +name = "pyyaml" +version = "6.0.3" +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", upload-time = 2025-09-25T21:33:16Z, size = 130960, hashes = { sha256 = "d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2025-09-25T21:32:13Z, size = 775116, hashes = { sha256 = "9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28" } }] + +[[packages]] +name = "rapidocr" +version = "3.8.1" +wheels = [{ url = "https://files.pythonhosted.org/packages/ea/4a/fa521d947f0fc7bb304bf11bec4cb66266bd81494588b4cb48dc01001719/rapidocr-3.8.1-py3-none-any.whl", upload-time = 2026-04-11T07:13:22Z, size = 15080319, hashes = { sha256 = "650044b1fbce9e6bae5cae462dcf8be754cde11e2f23fc51f65dcc08deae2c46" } }] + +[[packages]] +name = "referencing" +version = "0.37.0" +sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", upload-time = 2025-10-13T15:30:48Z, size = 78036, hashes = { sha256 = "44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", upload-time = 2025-10-13T15:30:47Z, size = 26766, hashes = { sha256 = "381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231" } }] + +[[packages]] +name = "regex" +version = "2026.4.4" +sdist = { url = "https://files.pythonhosted.org/packages/cb/0e/3a246dbf05666918bd3664d9d787f84a9108f6f43cc953a077e4a7dfdb7e/regex-2026.4.4.tar.gz", upload-time = 2026-04-03T20:56:28Z, size = 416000, hashes = { sha256 = "e08270659717f6973523ce3afbafa53515c4dc5dcad637dc215b6fd50f689423" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/31/87/3accf55634caad8c0acab23f5135ef7d4a21c39f28c55c816ae012931408/regex-2026.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-04-03T20:53:45Z, size = 796651, hashes = { sha256 = "760ef21c17d8e6a4fe8cf406a97cf2806a4df93416ccc82fc98d25b1c20425be" } }] + +[[packages]] +name = "requests" +version = "2.33.1" +sdist = { url = "https://files.pythonhosted.org/packages/5f/a4/98b9c7c6428a668bf7e42ebb7c79d576a1c3c1e3ae2d47e674b468388871/requests-2.33.1.tar.gz", upload-time = 2026-03-30T16:09:15Z, size = 134120, hashes = { sha256 = "18817f8c57c6263968bc123d237e3b8b08ac046f5456bd1e307ee8f4250d3517" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", upload-time = 2026-03-30T16:09:13Z, size = 64947, hashes = { sha256 = "4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a" } }] + +[[packages]] +name = "rich" +version = "13.9.4" +sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", upload-time = 2024-11-01T16:43:57Z, size = 223149, hashes = { sha256 = "439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", upload-time = 2024-11-01T16:43:55Z, size = 242424, hashes = { sha256 = "6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90" } }] + +[[packages]] +name = "rpds-py" +version = "0.30.0" +sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", upload-time = 2025-11-30T20:24:38Z, size = 69469, hashes = { sha256 = "dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/65/1c/ae157e83a6357eceff62ba7e52113e3ec4834a84cfe07fa4b0757a7d105f/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2025-11-30T20:22:21Z, size = 390763, hashes = { sha256 = "ca28829ae5f5d569bb62a79512c842a03a12576375d5ece7d2cadf8abe96ec28" } }] + +[[packages]] +name = "rtree" +version = "1.4.1" +sdist = { url = "https://files.pythonhosted.org/packages/95/09/7302695875a019514de9a5dd17b8320e7a19d6e7bc8f85dcfb79a4ce2da3/rtree-1.4.1.tar.gz", upload-time = 2025-08-13T19:32:01Z, size = 52425, hashes = { sha256 = "c6b1b3550881e57ebe530cc6cffefc87cd9bf49c30b37b894065a9f810875e46" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/55/e1/4d075268a46e68db3cac51846eb6a3ab96ed481c585c5a1ad411b3c23aad/rtree-1.4.1-py3-none-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2025-08-13T19:31:53Z, size = 459789, hashes = { sha256 = "efa8c4496e31e9ad58ff6c7df89abceac7022d906cb64a3e18e4fceae6b77f65" } }] + +[[packages]] +name = "safetensors" +version = "0.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/29/9c/6e74567782559a63bd040a236edca26fd71bc7ba88de2ef35d75df3bca5e/safetensors-0.7.0.tar.gz", upload-time = 2025-11-19T15:18:43Z, size = 200878, hashes = { sha256 = "07663963b67e8bd9f0b8ad15bb9163606cd27cc5a1b96235a50d8369803b96b0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f1/06/578ffed52c2296f93d7fd2d844cabfa92be51a587c38c8afbb8ae449ca89/safetensors-0.7.0-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2025-11-19T15:18:09Z, size = 491748, hashes = { sha256 = "e07d91d0c92a31200f25351f4acb2bc6aff7f48094e13ebb1d0fb995b54b6542" } }] + +[[packages]] +name = "scikit-learn" +version = "1.8.0" +sdist = { url = "https://files.pythonhosted.org/packages/0e/d4/40988bf3b8e34feec1d0e6a051446b1f66225f8529b9309becaeef62b6c4/scikit_learn-1.8.0.tar.gz", upload-time = 2025-12-10T07:08:53Z, size = 7335585, hashes = { sha256 = "9bccbb3b40e3de10351f8f5068e105d0f4083b1a65fa07b6634fbc401a6287fd" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/dd/47/f187b4636ff80cc63f21cd40b7b2d177134acaa10f6bb73746130ee8c2e5/scikit_learn-1.8.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2025-12-10T07:07:55Z, size = 8660492, hashes = { sha256 = "4496bb2cf7a43ce1a2d7524a79e40bc5da45cf598dbf9545b7e8316ccba47bb4" } }] + +[[packages]] +name = "scipy" +version = "1.17.1" +sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", upload-time = 2026-02-23T00:26:24Z, size = 30573822, hashes = { sha256 = "95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/da/34/16f10e3042d2f1d6b66e0428308ab52224b6a23049cb2f5c1756f713815f/scipy-1.17.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-02-23T00:18:35Z, size = 32927842, hashes = { sha256 = "e19ebea31758fac5893a2ac360fedd00116cbb7628e650842a6691ba7ca28a21" } }] + +[[packages]] +name = "semchunk" +version = "3.2.5" +sdist = { url = "https://files.pythonhosted.org/packages/a9/a0/ce7e3d6cc76498fd594e667d10a03f17d7cced129e46869daec23523bf5a/semchunk-3.2.5.tar.gz", upload-time = 2025-10-28T02:12:38Z, size = 17667, hashes = { sha256 = "ee15e9a06a69a411937dd8fcf0a25d7ef389c5195863140436872a02c95b0218" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f8/95/12d226ee4d207cb1f77a216baa7e1a8bae2639733c140abe8d0316d23a18/semchunk-3.2.5-py3-none-any.whl", upload-time = 2025-10-28T02:12:36Z, size = 13048, hashes = { sha256 = "fd09cc5f380bd010b8ca773bd81893f7eaf11d37dd8362a83d46cedaf5dae076" } }] + +[[packages]] +name = "sentence-transformers" +version = "5.4.1" +sdist = { url = "https://files.pythonhosted.org/packages/4d/68/7f98c221940ce783b492ad6140384daf2e2918cd7175009d6a362c22b9ee/sentence_transformers-5.4.1.tar.gz", upload-time = 2026-04-14T13:34:59Z, size = 428910, hashes = { sha256 = "436bcb1182a0ff42a8fb2b1c43498a70d0a75b688d182f2cd0d1dd115af61ddc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c5/d9/3a9b6f2ccdedc9dc00fe37b2fc58f58f8efbff44565cf4bf39d8568bb13a/sentence_transformers-5.4.1-py3-none-any.whl", upload-time = 2026-04-14T13:34:57Z, size = 571311, hashes = { sha256 = "a6d640fc363849b63affb8e140e9d328feabab86f83d58ac3e16b1c28140b790" } }] + +[[packages]] +name = "sentencepiece" +version = "0.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/15/15/2e7a025fc62d764b151ae6d0f2a92f8081755ebe8d4a64099accc6f77ba6/sentencepiece-0.2.1.tar.gz", upload-time = 2025-08-12T07:00:51Z, size = 3228515, hashes = { sha256 = "8138cec27c2f2282f4a34d9a016e3374cd40e5c6e9cb335063db66a0a3b71fad" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/89/fa/d3d5ebcba3cb9e6d3775a096251860c41a6bc53a1b9461151df83fe93255/sentencepiece-0.2.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2025-08-12T06:59:44Z, size = 1316273, hashes = { sha256 = "99f955df238021bf11f0fc37cdb54fd5e5b5f7fd30ecc3d93fb48b6815437167" } }] + +[[packages]] +name = "seqeval" +version = "1.2.2" +sdist = { url = "https://files.pythonhosted.org/packages/9d/2d/233c79d5b4e5ab1dbf111242299153f3caddddbb691219f363ad55ce783d/seqeval-1.2.2.tar.gz", upload-time = 2020-10-24T00:24:54Z, size = 43605, hashes = { sha256 = "f28e97c3ab96d6fcd32b648f6438ff2e09cfba87f05939da9b3970713ec56e6f" } } + +[[packages]] +name = "setuptools" +version = "83.0.0" +marker = "python_full_version >= '3.12'" +sdist = { url = "https://files.pythonhosted.org/packages/34/26/f5d29e25ffdb535afef2d35cdb55b325298f96debd670da4c325e08d70f4/setuptools-83.0.0.tar.gz", upload-time = 2026-07-04T15:31:22Z, size = 1154254, hashes = { sha256 = "025bccbbf0fa05b6192bc64ae1e7b16e001fd6d6d4d5de03c97b1c1ade523bef" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5d/40/e1e72872c6354b306daef1703549e8e83b4d43cfea356311bf722a043752/setuptools-83.0.0-py3-none-any.whl", upload-time = 2026-07-04T15:31:20Z, size = 1008090, hashes = { sha256 = "29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3" } }] + +[[packages]] +name = "shapely" +version = "2.1.2" +sdist = { url = "https://files.pythonhosted.org/packages/4d/bc/0989043118a27cccb4e906a46b7565ce36ca7b57f5a18b78f4f1b0f72d9d/shapely-2.1.2.tar.gz", upload-time = 2025-09-24T13:51:41Z, size = 315489, hashes = { sha256 = "2ed4ecb28320a433db18a5bf029986aa8afcfd740745e78847e330d5d94922a9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/26/29/a5397e75b435b9895cd53e165083faed5d12fd9626eadec15a83a2411f0f/shapely-2.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", upload-time = 2025-09-24T13:50:33Z, size = 2988308, hashes = { sha256 = "0bd308103340030feef6c111d3eb98d50dc13feea33affc8a6f9fa549e9458a3" } }] + +[[packages]] +name = "shellingham" +version = "1.5.4" +sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", upload-time = 2023-10-24T04:13:40Z, size = 10310, hashes = { sha256 = "8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", upload-time = 2023-10-24T04:13:38Z, size = 9755, hashes = { sha256 = "7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686" } }] + +[[packages]] +name = "six" +version = "1.17.0" +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", upload-time = 2024-12-04T17:35:28Z, size = 34031, hashes = { sha256 = "ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", upload-time = 2024-12-04T17:35:26Z, size = 11050, hashes = { sha256 = "4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274" } }] + +[[packages]] +name = "soupsieve" +version = "2.9" +sdist = { url = "https://files.pythonhosted.org/packages/80/f1/93422647dd7e461f23d254e6b2bfa687a85b53aeb4903fcdbb74474d4584/soupsieve-2.9.tar.gz", upload-time = 2026-07-19T01:35:18Z, size = 122122, hashes = { sha256 = "acee8417325c5653e1377dc31eccad59eb82cbc65942afe6174c53b3aaad63fc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7b/d6/3185ab5ad1280319b31986898f3206dd7227cd75e293d4dba2a5e6bf27a0/soupsieve-2.9-py3-none-any.whl", upload-time = 2026-07-19T01:35:17Z, size = 37387, hashes = { sha256 = "a2b2c76d67df2382d245409fd71e321a571717e58463efa32ace87dcadac2c12" } }] + +[[packages]] +name = "sympy" +version = "1.14.0" +sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", upload-time = 2025-04-27T18:05:01Z, size = 7793921, hashes = { sha256 = "d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", upload-time = 2025-04-27T18:04:59Z, size = 6299353, hashes = { sha256 = "e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5" } }] + +[[packages]] +name = "tabulate" +version = "0.10.0" +sdist = { url = "https://files.pythonhosted.org/packages/46/58/8c37dea7bbf769b20d58e7ace7e5edfe65b849442b00ffcdd56be88697c6/tabulate-0.10.0.tar.gz", upload-time = 2026-03-04T18:55:34Z, size = 91754, hashes = { sha256 = "e2cfde8f79420f6deeffdeda9aaec3b6bc5abce947655d17ac662b126e48a60d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/99/55/db07de81b5c630da5cbf5c7df646580ca26dfaefa593667fc6f2fe016d2e/tabulate-0.10.0-py3-none-any.whl", upload-time = 2026-03-04T18:55:31Z, size = 39814, hashes = { sha256 = "f0b0622e567335c8fabaaa659f1b33bcb6ddfe2e496071b743aa113f8774f2d3" } }] + +[[packages]] +name = "threadpoolctl" +version = "3.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/b7/4d/08c89e34946fce2aec4fbb45c9016efd5f4d7f24af8e5d93296e935631d8/threadpoolctl-3.6.0.tar.gz", upload-time = 2025-03-13T13:49:23Z, size = 21274, hashes = { sha256 = "8ab8b4aa3491d812b623328249fab5302a68d2d71745c8a4c719a2fcaba9f44e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", upload-time = 2025-03-13T13:49:21Z, size = 18638, hashes = { sha256 = "43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb" } }] + +[[packages]] +name = "timm" +version = "0.9.16" +sdist = { url = "https://files.pythonhosted.org/packages/c5/ba/3d5f3381dc291d21114e707b39791f483431361f61402483d9839b61350d/timm-0.9.16.tar.gz", upload-time = 2024-02-19T19:33:45Z, size = 2121824, hashes = { sha256 = "891e54f375d55adf31a71ab0c117761f0e472f9f3971858ecdd1e7376b7071e6" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/68/99/2018622d268f6017ddfa5ee71f070bad5d07590374793166baa102849d17/timm-0.9.16-py3-none-any.whl", upload-time = 2024-02-19T19:33:42Z, size = 2249737, hashes = { sha256 = "bf5704014476ab011589d3c14172ee4c901fd18f9110a928019cac5be2945914" } }] + +[[packages]] +name = "tokenizers" +version = "0.22.2" +sdist = { url = "https://files.pythonhosted.org/packages/73/6f/f80cfef4a312e1fb34baf7d85c72d4411afde10978d4657f8cdd811d3ccc/tokenizers-0.22.2.tar.gz", upload-time = 2026-01-05T10:45:15Z, size = 372115, hashes = { sha256 = "473b83b915e547aa366d1eee11806deaf419e17be16310ac0a14077f1e28f917" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d6/84/7990e799f1309a8b87af6b948f31edaa12a3ed22d11b352eaf4f4b2e5753/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2026-01-05T10:40:32Z, size = 3290736, hashes = { sha256 = "2249487018adec45d6e3554c71d46eb39fa8ea67156c640f7513eb26f318cec7" } }] + +[[packages]] +name = "torch" +version = "2.9.1+cpu" +wheels = [{ url = "https://download-r2.pytorch.org/whl/cpu/torch-2.9.1%2Bcpu-cp312-cp312-manylinux_2_28_aarch64.whl", upload-time = 2026-01-23T15:13:02Z, hashes = { sha256 = "3bf9b442a51a2948e41216a76d7ab00f0694cfcaaa51b6f9bcab57b7f89843e6" } }] + +[[packages]] +name = "torchvision" +version = "0.24.1" +wheels = [{ url = "https://download-r2.pytorch.org/whl/cpu/torchvision-0.24.1-cp312-cp312-manylinux_2_28_aarch64.whl", upload-time = 2025-11-15T18:12:46Z, hashes = { sha256 = "28157649758fb97491de0db478d5d6e73c23b508e54de20adbc35e6b3aa72443" } }] + +[[packages]] +name = "tqdm" +version = "4.67.3" +sdist = { url = "https://files.pythonhosted.org/packages/09/a9/6ba95a270c6f1fbcd8dac228323f2777d886cb206987444e4bce66338dd4/tqdm-4.67.3.tar.gz", upload-time = 2026-02-03T17:35:53Z, size = 169598, hashes = { sha256 = "7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", upload-time = 2026-02-03T17:35:50Z, size = 78374, hashes = { sha256 = "ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf" } }] + +[[packages]] +name = "transformers" +version = "4.57.6" +sdist = { url = "https://files.pythonhosted.org/packages/c4/35/67252acc1b929dc88b6602e8c4a982e64f31e733b804c14bc24b47da35e6/transformers-4.57.6.tar.gz", upload-time = 2026-01-16T10:38:39Z, size = 10134912, hashes = { sha256 = "55e44126ece9dc0a291521b7e5492b572e6ef2766338a610b9ab5afbb70689d3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/03/b8/e484ef633af3887baeeb4b6ad12743363af7cce68ae51e938e00aaa0529d/transformers-4.57.6-py3-none-any.whl", upload-time = 2026-01-16T10:38:31Z, size = 11993498, hashes = { sha256 = "4c9e9de11333ddfe5114bc872c9f370509198acf0b87a832a0ab9458e2bd0550" } }] + +[[packages]] +name = "trec-car-tools" +version = "2.6" +sdist = { url = "https://files.pythonhosted.org/packages/d4/71/7b62e2e56de6cdf0c648f0033a9faa41b8f712bacd71968af96277185400/trec-car-tools-2.6.tar.gz", upload-time = 2022-02-01T16:37:20Z, size = 7513, hashes = { sha256 = "2fce2de120224fd569b151d5bed358a4ed334e643889b9e3dfe3e5a3d15d21c8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/36/75/661b406371f96622975eb25f9e70945d97fbe6b8e5af40342c59191962a3/trec_car_tools-2.6-py3-none-any.whl", upload-time = 2022-02-01T16:37:22Z, size = 8414, hashes = { sha256 = "e6f0373259e1c234222da7270ab54ca7af7a6f8d0dd32b13e158c1659d3991cf" } }] + +[[packages]] +name = "tree-sitter" +version = "0.25.2" +sdist = { url = "https://files.pythonhosted.org/packages/66/7c/0350cfc47faadc0d3cf7d8237a4e34032b3014ddf4a12ded9933e1648b55/tree-sitter-0.25.2.tar.gz", upload-time = 2025-09-25T17:37:59Z, size = 177961, hashes = { sha256 = "fe43c158555da46723b28b52e058ad444195afd1db3ca7720c59a254544e9c20" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/47/8a/d48c0414db19307b0fb3bb10d76a3a0cbe275bb293f145ee7fba2abd668e/tree_sitter-0.25.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2025-09-25T17:37:37Z, size = 607125, hashes = { sha256 = "dd12d80d91d4114ca097626eb82714618dcdfacd6a5e0955216c6485c350ef99" } }] + +[[packages]] +name = "tree-sitter-c" +version = "0.24.2" +sdist = { url = "https://files.pythonhosted.org/packages/a6/c9/3834f3d9278251aea7312274971bc4c45b17aec2490fd4b884d93bd7019a/tree_sitter_c-0.24.2.tar.gz", upload-time = 2026-04-22T08:06:14Z, size = 228397, hashes = { sha256 = "1628584df0299b5a340aa63f8e67b6c97c91517f52fa7e7a4c557e40adb330a9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/87/78/47dc570e7aee6b0a1ecc2520b30639cc2b06003154c9ab0672d86bf720d5/tree_sitter_c-0.24.2-cp310-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-04-22T08:06:09Z, size = 94560, hashes = { sha256 = "c098bedcd5ac86ff93fa734d51d1dd86aed40fd5ed7d634c7af11380a0469969" } }] + +[[packages]] +name = "tree-sitter-javascript" +version = "0.25.0" +sdist = { url = "https://files.pythonhosted.org/packages/59/e0/e63103c72a9d3dfd89a31e02e660263ad84b7438e5f44ee82e443e65bbde/tree_sitter_javascript-0.25.0.tar.gz", upload-time = 2025-09-01T07:13:44Z, size = 132338, hashes = { sha256 = "329b5414874f0588a98f1c291f1b28138286617aa907746ffe55adfdcf963f38" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/96/c8/97da3af4796495e46421e9344738addb3602fa6426ea695be3fcbadbee37/tree_sitter_javascript-0.25.0-cp310-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2025-09-01T07:13:39Z, size = 106072, hashes = { sha256 = "199d09985190852e0912da2b8d26c932159be314bc04952cf917ed0e4c633e6b" } }] + +[[packages]] +name = "tree-sitter-python" +version = "0.25.0" +sdist = { url = "https://files.pythonhosted.org/packages/b8/8b/c992ff0e768cb6768d5c96234579bf8842b3a633db641455d86dd30d5dac/tree_sitter_python-0.25.0.tar.gz", upload-time = 2025-09-11T06:47:58Z, size = 159845, hashes = { sha256 = "b13e090f725f5b9c86aa455a268553c65cadf325471ad5b65cd29cac8a1a68ac" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/40/bd/bf4787f57e6b2860f3f1c8c62f045b39fb32d6bac4b53d7a9e66de968440/tree_sitter_python-0.25.0-cp310-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2025-09-11T06:47:51Z, size = 110603, hashes = { sha256 = "be71650ca2b93b6e9649e5d65c6811aad87a7614c8c1003246b303f6b150f61b" } }] + +[[packages]] +name = "tree-sitter-typescript" +version = "0.23.2" +sdist = { url = "https://files.pythonhosted.org/packages/1e/fc/bb52958f7e399250aee093751e9373a6311cadbe76b6e0d109b853757f35/tree_sitter_typescript-0.23.2.tar.gz", upload-time = 2024-11-11T02:36:11Z, size = 773053, hashes = { sha256 = "7b167b5827c882261cb7a50dfa0fb567975f9b315e87ed87ad0a0a3aedb3834d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/96/2d/975c2dad292aa9994f982eb0b69cc6fda0223e4b6c4ea714550477d8ec3a/tree_sitter_typescript-0.23.2-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2024-11-11T02:36:02Z, size = 351987, hashes = { sha256 = "4b1eed5b0b3a8134e86126b00b743d667ec27c63fc9de1b7bb23168803879e31" } }] + +[[packages]] +name = "typer" +version = "0.21.2" +sdist = { url = "https://files.pythonhosted.org/packages/f2/1e/a27cc02a0cd715118c71fa2aef2c687fdefc3c28d90fd0dd789c5118154c/typer-0.21.2.tar.gz", upload-time = 2026-02-10T19:33:46Z, size = 120426, hashes = { sha256 = "1abd95a3b675e17ff61b0838ac637fe9478d446d62ad17fa4bb81ea57cc54028" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b8/cc/d59f893fbdfb5f58770c05febfc4086a46875f1084453621c35605cec946/typer-0.21.2-py3-none-any.whl", upload-time = 2026-02-10T19:33:48Z, size = 56728, hashes = { sha256 = "c3d8de54d00347ef90b82131ca946274f017cffb46683ae3883c360fa958f55c" } }] + +[[packages]] +name = "typing-extensions" +version = "4.15.0" +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", upload-time = 2025-08-25T13:49:26Z, size = 109391, hashes = { sha256 = "0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", upload-time = 2025-08-25T13:49:24Z, size = 44614, hashes = { sha256 = "f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548" } }] + +[[packages]] +name = "typing-inspection" +version = "0.4.2" +sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", upload-time = 2025-10-01T02:14:41Z, size = 75949, hashes = { sha256 = "ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", upload-time = 2025-10-01T02:14:40Z, size = 14611, hashes = { sha256 = "4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7" } }] + +[[packages]] +name = "tzdata" +version = "2026.2" +sdist = { url = "https://files.pythonhosted.org/packages/ba/19/1b9b0e29f30c6d35cb345486df41110984ea67ae69dddbc0e8a100999493/tzdata-2026.2.tar.gz", upload-time = 2026-04-24T15:22:08Z, size = 198254, hashes = { sha256 = "9173fde7d80d9018e02a662e168e5a2d04f87c41ea174b139fbef642eda62d10" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ce/e4/dccd7f47c4b64213ac01ef921a1337ee6e30e8c6466046018326977efd95/tzdata-2026.2-py2.py3-none-any.whl", upload-time = 2026-04-24T15:22:05Z, size = 349321, hashes = { sha256 = "bbe9af844f658da81a5f95019480da3a89415801f6cc966806612cc7169bffe7" } }] + +[[packages]] +name = "unlzw3" +version = "0.2.3" +sdist = { url = "https://files.pythonhosted.org/packages/08/f1/72b313366285263aaba21a17714fbef597d7662a8737a928b2b4784eb46e/unlzw3-0.2.3.tar.gz", upload-time = 2024-12-20T16:05:55Z, size = 5426, hashes = { sha256 = "ede5d928c792fff9da406f20334f9739693327f448f383ae1df1774627197bbb" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/4d/fb/617af9b317ac75f5663285d3a3cc38903a76d63c6e7397768307545f4ff4/unlzw3-0.2.3-py3-none-any.whl", upload-time = 2024-12-20T16:05:53Z, size = 6729, hashes = { sha256 = "7760fb4f3afa1225623944c061991d89a061f7fb78665dbc4cddfdb562bb4a8b" } }] + +[[packages]] +name = "urllib3" +version = "2.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", upload-time = 2026-05-07T16:13:18Z, size = 433602, hashes = { sha256 = "231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", upload-time = 2026-05-07T16:13:17Z, size = 131087, hashes = { sha256 = "9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897" } }] + +[[packages]] +name = "warc3-wet" +version = "0.2.5" +sdist = { url = "https://files.pythonhosted.org/packages/21/c6/24c9b4a2b2b1741b57d7f44ff9790eb4ef28de898c17c2b1ca1efabf8c96/warc3_wet-0.2.5.tar.gz", upload-time = 2024-07-17T08:33:51Z, size = 17937, hashes = { sha256 = "15e50402dabaa1e95307f1e2a6169cfd5f137b70761d9f0b16a10aa6de227970" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f4/99/0a5582a106679fd9439af51631b6c6cb627fd96cbc85a02927e6812605b8/warc3_wet-0.2.5-py3-none-any.whl", upload-time = 2024-07-17T08:33:50Z, size = 18657, hashes = { sha256 = "5a9a525383fb1af159734baa75f349a7c4ec7bccd1b938681b5748515d2bf624" } }] + +[[packages]] +name = "warc3-wet-clueweb09" +version = "0.2.5" +sdist = { url = "https://files.pythonhosted.org/packages/9f/c1/dd817bf57e0274dacb10e0ac868cb6cd70876950cf361c41879c030a2b8b/warc3-wet-clueweb09-0.2.5.tar.gz", upload-time = 2020-12-07T23:59:04Z, size = 17853, hashes = { sha256 = "3054bfc07da525d5967df8ca3175f78fa3f78514c82643f8c81fbca96300b836" } } + +[[packages]] +name = "wcwidth" +version = "0.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/35/a2/8e3becb46433538a38726c948d3399905a4c7cabd0df578ede5dc51f0ec2/wcwidth-0.6.0.tar.gz", upload-time = 2026-02-06T19:19:40Z, size = 159684, hashes = { sha256 = "cdc4e4262d6ef9a1a57e018384cbeb1208d8abbc64176027e2c2455c81313159" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/68/5a/199c59e0a824a3db2b89c5d2dade7ab5f9624dbf6448dc291b46d5ec94d3/wcwidth-0.6.0-py3-none-any.whl", upload-time = 2026-02-06T19:19:39Z, size = 94189, hashes = { sha256 = "1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad" } }] + +[[packages]] +name = "websockets" +version = "14.2" +sdist = { url = "https://files.pythonhosted.org/packages/94/54/8359678c726243d19fae38ca14a334e740782336c9f19700858c4eb64a1e/websockets-14.2.tar.gz", upload-time = 2025-01-19T21:00:56Z, size = 164394, hashes = { sha256 = "5059ed9c54945efb321f097084b4c7e52c246f2c869815876a69d1efc4ad6eb5" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a6/bc/f6678a0ff17246df4f06765e22fc9d98d1b11a258cc50c5968b33d6742a1/websockets-14.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2025-01-19T20:59:35Z, size = 170815, hashes = { sha256 = "091ab63dfc8cea748cc22c1db2814eadb77ccbf82829bac6b2fbe3401d548eda" } }, + { url = "https://files.pythonhosted.org/packages/7b/c8/d529f8a32ce40d98309f4470780631e971a5a842b60aec864833b3615786/websockets-14.2-py3-none-any.whl", upload-time = 2025-01-19T21:00:54Z, size = 157416, hashes = { sha256 = "7a6ceec4ea84469f15cf15807a747e9efe57e369c384fa86e022b3bea679b79b" } }, +] + +[[packages]] +name = "xlsxwriter" +version = "3.2.9" +sdist = { url = "https://files.pythonhosted.org/packages/46/2c/c06ef49dc36e7954e55b802a8b231770d286a9758b3d936bd1e04ce5ba88/xlsxwriter-3.2.9.tar.gz", upload-time = 2025-09-16T00:16:21Z, size = 215940, hashes = { sha256 = "254b1c37a368c444eac6e2f867405cc9e461b0ed97a3233b2ac1e574efb4140c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3a/0c/3662f4a66880196a590b202f0db82d919dd2f89e99a27fadef91c4a33d41/xlsxwriter-3.2.9-py3-none-any.whl", upload-time = 2025-09-16T00:16:20Z, size = 175315, hashes = { sha256 = "9a5db42bc5dff014806c58a20b9eae7322a134abb6fce3c92c181bfb275ec5b3" } }] + +[[packages]] +name = "xxhash" +version = "3.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/24/2f/e183a1b407002f5af81822bee18b61cdb94b8670208ef34734d8d2b8ebe9/xxhash-3.7.0.tar.gz", upload-time = 2026-04-25T11:10:32Z, size = 82022, hashes = { sha256 = "6cc4eefbb542a5d6ffd6d70ea9c502957c925e800f998c5630ecc809d6702bae" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/87/ee/2f9f2ed993e77206d1e66991290a1ebe22e843351ca3ebec8e49e01ba186/xxhash-3.7.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-04-25T11:06:25Z, size = 212977, hashes = { sha256 = "f3e7b689c3bce16699efcf736066f5c6cc4472c3840fe4b22bd8279daf4abdac" } }] + +[[packages]] +name = "yarl" +version = "1.23.0" +sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", upload-time = 2026-03-01T22:07:53Z, size = 194676, hashes = { sha256 = "53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/30/58260ed98e6ff7f90ba84442c1ddd758c9170d70327394a6227b310cd60f/yarl-1.23.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-03-01T22:05:17Z, size = 97587, hashes = { sha256 = "9cbf44c5cb4a7633d078788e1b56387e3d3cf2b8139a3be38040b22d6c3221c8" } }, + { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", upload-time = 2026-03-01T22:07:51Z, size = 48288, hashes = { sha256 = "a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f" } }, +] + +[[packages]] +name = "zlib-state" +version = "0.1.12" +sdist = { url = "https://files.pythonhosted.org/packages/53/f2/c1b3dfb76ff3eac8eb2a96eb1e8e05c13534c73f0d1d582dfadadb5a863a/zlib_state-0.1.12.tar.gz", upload-time = 2026-04-14T19:08:30Z, size = 9618, hashes = { sha256 = "ccbb06321daf165b022aa4d22d62effb7df76f55035d50bbe8b93696db416cf0" } } diff --git a/packages/sie_server/bundle-locks/cpu-sglang-amd64/manifest.json b/packages/sie_server/bundle-locks/cpu-sglang-amd64/manifest.json new file mode 100644 index 000000000..4c9361eed --- /dev/null +++ b/packages/sie_server/bundle-locks/cpu-sglang-amd64/manifest.json @@ -0,0 +1,44 @@ +{ + "completed_artifact_hashes": [ + { + "bytes": 7532, + "sha256": "926acba49b2c0a0374c61b7c98f337c085199cf51cdfe4d6423c4129c20547a7", + "url": "https://download.pytorch.org/whl/cuda_python-12.9.0-py3-none-any.whl" + }, + { + "bytes": 134899, + "sha256": "85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", + "url": "https://download.pytorch.org/whl/jinja2-3.1.6-py3-none-any.whl" + }, + { + "bytes": 22947, + "sha256": "d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", + "url": "https://download.pytorch.org/whl/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl" + } + ], + "exceptions_sha256": "0e328649e4e2f0ec96af06111b7024deb59751882ddfe4c5fb70fc4c9dc30c1c", + "exclude_newer": "2026-10-18T00:00:00Z", + "indexes": [ + "--default-index", + "https://pypi.org/simple", + "--index", + "https://download.pytorch.org/whl/cpu", + "--index-strategy", + "unsafe-best-match" + ], + "inputs": { + "requirements_sha256": "943a74a3f4565e0b7b3bab2f87080526604d1e3923a39ed287d444630d33b94c", + "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" + }, + "lock_sha256": "9ad62d85b2dea1cedb4cde7256aa85e9f500ae1f00c5bcc2214b8cde7820514f", + "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "schema_version": 1, + "target": { + "architecture": "amd64", + "bundle": "sglang", + "platform": "cpu", + "python_platform": "x86_64-manylinux_2_35", + "python_version": "3.12" + }, + "uv_version": "0.9.28" +} diff --git a/packages/sie_server/bundle-locks/cpu-sglang-amd64/pylock.toml b/packages/sie_server/bundle-locks/cpu-sglang-amd64/pylock.toml new file mode 100644 index 000000000..00738cf72 --- /dev/null +++ b/packages/sie_server/bundle-locks/cpu-sglang-amd64/pylock.toml @@ -0,0 +1,1224 @@ +lock-version = "1.0" +created-by = "uv" +requires-python = ">=3.12" + +[[packages]] +name = "aiohappyeyeballs" +version = "2.6.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", upload-time = 2025-03-12T01:42:48Z, size = 22760, hashes = { sha256 = "c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", upload-time = 2025-03-12T01:42:47Z, size = 15265, hashes = { sha256 = "f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8" } }] + +[[packages]] +name = "aiohttp" +version = "3.14.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/58/d9/22ce5786ac0c1653ae8b6c23bded02c1686d11f0dbb45b31ce128e0df985/aiohttp-3.14.3.tar.gz", upload-time = 2026-07-23T01:57:27Z, size = 7971213, hashes = { sha256 = "9491196535a88924a60afd5b5f434b5b203b6cc616250878dbdb223a8f7844bc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/52/b7/7cd31f29d6055bd711ae6e669367fba6f5ae9de463910a793e30556a8db7/aiohttp-3.14.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-23T01:54:15Z, size = 1792122, hashes = { sha256 = "543906c127fb1d929b95076db19b83fa2d46751006ff1e23b093aa5ac4d8db42" } }] + +[[packages]] +name = "aiosignal" +version = "1.4.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", upload-time = 2025-07-03T22:54:43Z, size = 25007, hashes = { sha256 = "f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", upload-time = 2025-07-03T22:54:42Z, size = 7490, hashes = { sha256 = "053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e" } }] + +[[packages]] +name = "airportsdata" +version = "20260905" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/a5/c2/69ec4b992746c4c7b076a7afffb11fc64267d684ed0cd3db00035f0f682b/airportsdata-20260905.tar.gz", upload-time = 2026-09-05T06:02:21Z, size = 929470, hashes = { sha256 = "a7e17469458ca356a5ca9971f49864b934a559d43e1587e19219cb981d364c45" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/45/f8/65e9d476f84bb60ac7ff1fe525acdd60fe6b4b585ae6f074c947c6ad0fc1/airportsdata-20260905-py3-none-any.whl", upload-time = 2026-09-05T06:02:19Z, size = 931164, hashes = { sha256 = "d7eaa9a57d373b0adaaae0d52da2af0bb0edf73f7baa170f7c415d3342bf4868" } }] + +[[packages]] +name = "annotated-doc" +version = "0.0.4" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", upload-time = 2025-11-10T22:07:42Z, size = 7288, hashes = { sha256 = "fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", upload-time = 2025-11-10T22:07:40Z, size = 5303, hashes = { sha256 = "571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320" } }] + +[[packages]] +name = "annotated-types" +version = "0.7.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", upload-time = 2024-05-20T21:33:25Z, size = 16081, hashes = { sha256 = "aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", upload-time = 2024-05-20T21:33:24Z, size = 13643, hashes = { sha256 = "1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53" } }] + +[[packages]] +name = "anthropic" +version = "1.15.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/10/37/5a2a4316df8babd28f096477a707cd75f240b4264c97fb128c32375105d6/anthropic-1.15.0.tar.gz", upload-time = 2026-10-15T19:45:34Z, size = 1726101, hashes = { sha256 = "90caa9df83e2fc8bddb4ddeb83b7191bce255f635c03eae055deec521741df08" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d1/65/54437e7edea49a3be9ef56f6b5965999bfdc52b9dadc9b448124ca51a594/anthropic-1.15.0-py3-none-any.whl", upload-time = 2026-10-15T19:45:32Z, size = 2047755, hashes = { sha256 = "10189a7993c5c71a0a2d4bb80020ca6a2fd27679f51e627405da37251d15ff49" } }] + +[[packages]] +name = "anyio" +version = "4.14.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/61/cc/a381afa6efea9f496eff839d4a6a1aed3bfafc7b3ab4b0d1b243a12573dd/anyio-4.14.2.tar.gz", upload-time = 2026-07-12T20:29:07Z, size = 260176, hashes = { sha256 = "cfa139f3ed1a23ee8f88a145ddb5ac7605b8bbfd8592baacd7ce3d8bb4313c7f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/da/35/f2287558c17e29fafc8ef3daf819bb9834061cfa43bff8014f7df7f63bdc/anyio-4.14.2-py3-none-any.whl", upload-time = 2026-07-12T20:29:05Z, size = 125813, hashes = { sha256 = "9f505dda5ac9f0c8309b5e8bd445a8c2bf7246f3ce950121e45ea15bc41d1494" } }] + +[[packages]] +name = "apache-tvm-ffi" +version = "0.1.14.post1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ed/50/2b9d308f34843b99e763ac7d510ba6400dbb3e86b3f04fd206be0dc9cd46/apache_tvm_ffi-0.1.14.post1.tar.gz", upload-time = 2026-09-24T07:52:45Z, size = 3232883, hashes = { sha256 = "8ebd92dc97cdcb22ab494aa252c868ddd6a9b6c89be69188562e0f236652429f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e8/db/68786fdc0bfb3a9782df7304c1e577b9c5a7d14c75e98e06571cc1869b3f/apache_tvm_ffi-0.1.14.post1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-09-24T07:52:14Z, size = 3251763, hashes = { sha256 = "eb759c039866b541ec2cb07d498082f8ba6ded74d58d9196180a5932f365c077" } }] + +[[packages]] +name = "asttokens" +version = "3.0.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/be/a5/8e3f9b6771b0b408517c82d97aed8f2036509bc247d46114925e32fe33f0/asttokens-3.0.1.tar.gz", upload-time = 2025-11-15T16:43:48Z, size = 62308, hashes = { sha256 = "71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d2/39/e7eaf1799466a4aef85b6a4fe7bd175ad2b1c6345066aa33f1f58d4b18d0/asttokens-3.0.1-py3-none-any.whl", upload-time = 2025-11-15T16:43:16Z, size = 27047, hashes = { sha256 = "15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a" } }] + +[[packages]] +name = "attrs" +version = "26.1.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", upload-time = 2026-03-19T14:22:25Z, size = 952055, hashes = { sha256 = "d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", upload-time = 2026-03-19T14:22:23Z, size = 67548, hashes = { sha256 = "c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309" } }] + +[[packages]] +name = "blobfile" +version = "3.0.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/9d/a9/a34e8153b0203d9060ff7aa5dfcd175e161117949697a83c4cc003b523ff/blobfile-3.0.0.tar.gz", upload-time = 2024-08-27T00:02:53Z, size = 77863, hashes = { sha256 = "32ec777414de7bb2a76ca812a838f0d33327ca28ae844a253503cde625cdf2f1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ed/4d/1392562369b1139e741b30d624f09fe7091d17dd5579fae5732f044b12bb/blobfile-3.0.0-py3-none-any.whl", upload-time = 2024-08-27T00:02:51Z, size = 75413, hashes = { sha256 = "48ecc3307e622804bd8fe13bf6f40e6463c4439eba7a1f9ad49fd78aa63cc658" } }] + +[[packages]] +name = "build" +version = "1.4.4" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/02/ec/bf5ae0a7e5ab57abe8aabdd0759c971883895d1a20c49ae99f8146840c3c/build-1.4.4.tar.gz", upload-time = 2026-04-22T20:53:44Z, size = 89220, hashes = { sha256 = "f832ae053061f3fb524af812dc94b8b84bac6880cd587630e3b5d91a6a9c1703" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/fa/88/6764e7a109dd84294850741501145da90d13cdeac9d4e614929464a37420/build-1.4.4-py3-none-any.whl", upload-time = 2026-04-22T20:53:43Z, size = 25921, hashes = { sha256 = "8c3f48a6090b39edec1a273d2d57949aaf13723b01e02f9d518396887519f64d" } }] + +[[packages]] +name = "certifi" +version = "2026.4.22" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/25/ee/6caf7a40c36a1220410afe15a1cc64993a1f864871f698c0f93acb72842a/certifi-2026.4.22.tar.gz", upload-time = 2026-04-22T11:26:11Z, size = 137077, hashes = { sha256 = "8d455352a37b71bf76a79caa83a3d6c25afee4a385d632127b6afb3963f1c580" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/22/30/7cd8fdcdfbc5b869528b079bfb76dcdf6056b1a2097a662e5e8c04f42965/certifi-2026.4.22-py3-none-any.whl", upload-time = 2026-04-22T11:26:09Z, size = 135707, hashes = { sha256 = "3cb2210c8f88ba2318d29b0388d1023c8492ff72ecdde4ebdaddbb13a31b1c4a" } }] + +[[packages]] +name = "cffi" +version = "2.0.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", upload-time = 2025-09-08T23:24:04Z, size = 523588, hashes = { sha256 = "44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-09-08T23:22:52Z, size = 219572, hashes = { sha256 = "3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba" } }] + +[[packages]] +name = "charset-normalizer" +version = "3.4.7" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", upload-time = 2026-04-02T09:28:39Z, size = 144271, hashes = { sha256 = "ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4b/f8/d0118a2f5f23b02cd166fa385c60f9b0d4f9194f574e2b31cef350ad7223/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-02T09:26:29Z, size = 216589, hashes = { sha256 = "5649fd1c7bade02f320a462fdefd0b4bd3ce036065836d4f42e0de958038e116" } }, + { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", upload-time = 2026-04-02T09:28:37Z, size = 61958, hashes = { sha256 = "3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d" } }, +] + +[[packages]] +name = "click" +version = "8.1.8" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", upload-time = 2024-12-21T18:38:44Z, size = 226593, hashes = { sha256 = "ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", upload-time = 2024-12-21T18:38:41Z, size = 98188, hashes = { sha256 = "63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2" } }] + +[[packages]] +name = "cloudpickle" +version = "3.1.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/27/fb/576f067976d320f5f0114a8d9fa1215425441bb35627b1993e5afd8111e5/cloudpickle-3.1.2.tar.gz", upload-time = 2025-11-03T09:25:26Z, size = 22330, hashes = { sha256 = "7fda9eb655c9c230dab534f1983763de5835249750e85fbcef43aaa30a9a2414" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl", upload-time = 2025-11-03T09:25:25Z, size = 22228, hashes = { sha256 = "9acb47f6afd73f60dc1df93bb801b472f05ff42fa6c84167d25cb206be1fbf4a" } }] + +[[packages]] +name = "compressed-tensors" +version = "0.15.0.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/41/1b/c3c4a98ec5f2727656336f07a0c35862195c310d8eb0b2fa5b4be6848680/compressed_tensors-0.15.0.1.tar.gz", upload-time = 2026-04-10T14:23:54Z, size = 229412, hashes = { sha256 = "a8e93054e8a5ec49c980b09ed36c4c1249b4a8ee167920a8e461c4da26e78d99" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a8/52/93833dc1610e017ac5b7dcd59b8304d8ef67d1114c2d124e728a2cbbea12/compressed_tensors-0.15.0.1-py3-none-any.whl", upload-time = 2026-04-10T14:23:53Z, size = 194260, hashes = { sha256 = "e1b1f322e82e475715e242bad46925a304ea8e5c98b5055a15b8eb22fb6bfea9" } }] + +[[packages]] +name = "cryptography" +version = "50.0.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/de/41/6cbdcf9142d00fe82836fbb51e503e58088575cf7a0fe1dbff6695bf0840/cryptography-50.0.0.tar.gz", upload-time = 2026-07-31T14:25:10Z, size = 880201, hashes = { sha256 = "eeac2acb5a20ed25e0ad6d1df9891a520b78b404266b6d11778f25d5d691a6c9" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/41/029086c34d91052fc3b88bcc8056f709a7c915c7a23b235a54eb800b1c97/cryptography-50.0.0-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-07-31T14:23:37Z, size = 4702130, hashes = { sha256 = "06a32a980526a6ab9a4b9bf8f7385800791e2bb960903cb6b530e4817509a3b7" } }, + { url = "https://files.pythonhosted.org/packages/6b/72/a1116d683a6d7ece94590013882515de087edf9ef0e6292aae615a44df73/cryptography-50.0.0-cp311-abi3-manylinux_2_28_x86_64.whl", upload-time = 2026-07-31T14:23:43Z, size = 4734609, hashes = { sha256 = "b42a28c1844fd9de8f3f7d540e36b66f3a9c83fceac7170ebc7a6a19edd9dcae" } }, + { url = "https://files.pythonhosted.org/packages/da/3a/f05e32c99d440c9bb891ea0e36c9091891e36be5a9a87ab2ee6ea20729f6/cryptography-50.0.0-cp311-abi3-manylinux_2_34_x86_64.whl", upload-time = 2026-07-31T14:23:50Z, size = 4734462, hashes = { sha256 = "82148ec5bddac30b51a5b3c1945075f896fa022cb93f8e4a01e9f6ee95292c5f" } }, + { url = "https://files.pythonhosted.org/packages/85/4f/0fa8c2f4428198f15d9ff8d63400e27afbf94ce833f6108da1eb3753f945/cryptography-50.0.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-07-31T14:24:27Z, size = 4728939, hashes = { sha256 = "a91296cb61e8df6f86d0c19cc4068228da256bf59bf86049fbd821084565327f" } }, + { url = "https://files.pythonhosted.org/packages/46/c9/f60aed34c013f317f92817b6c171c2d22a78270fa41109bd4b08af26b194/cryptography-50.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", upload-time = 2026-07-31T14:24:34Z, size = 4762647, hashes = { sha256 = "105110f43a471dbd0060b9c9516cb8a6a79233631a04cc2ba16f28323ac6e025" } }, + { url = "https://files.pythonhosted.org/packages/9c/f8/d97f9603efda3888187bfdb893f26c41be4735c10631d05d284ee6b047c4/cryptography-50.0.0-cp39-abi3-manylinux_2_34_x86_64.whl", upload-time = 2026-07-31T14:24:43Z, size = 4762400, hashes = { sha256 = "37fdb0d0111f1e2ff07139dfb79f1b49531f8e213c46f1163dd7642979b58c47" } }, +] + +[[packages]] +name = "cuda-bindings" +version = "12.9.10" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/7b/6e/0e07e8b3578547e1083a7ee105c5736033ecb189466f40e45283b46bc7c6/cuda_bindings-12.9.10-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-10-15T14:12:03Z, size = 7627380, hashes = { sha256 = "420e44cfcd939cd69d6cfe8efc5f08b44850994cae399a49b9299a464324ce97" } }] + +[[packages]] +name = "cuda-pathfinder" +version = "1.8.3" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/b9/fb/f8e1890428f9f590b4beebd63b068aac1ce32a3331510c847b9f9a78f261/cuda_pathfinder-1.8.3-py3-none-any.whl", upload-time = 2026-10-02T03:20:23Z, size = 62561, hashes = { sha256 = "e29e59829c297a7a5233bd9cc71094fc5bddbd076951482670178f9eade39b1f" } }] + +[[packages]] +name = "cuda-python" +version = "12.9.0" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://download.pytorch.org/whl/cuda_python-12.9.0-py3-none-any.whl", upload-time = 2026-01-20T19:36:06Z, hashes = { sha256 = "926acba49b2c0a0374c61b7c98f337c085199cf51cdfe4d6423c4129c20547a7" } }] + +[[packages]] +name = "cuda-tile" +version = "1.6.0" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/40/21/3dfeafbd3512e94a277a25ce022c10e7bdff5d43e364afffcc0928f7fcaf/cuda_tile-1.6.0-cp312-cp312-manylinux2014_x86_64.whl", upload-time = 2026-09-10T00:06:48Z, size = 382170, hashes = { sha256 = "7e38f97bfedff359c926710387a40fbfc8f36efb7fe9ad2cb759d5a098eedde3" } }] + +[[packages]] +name = "datasets" +version = "3.6.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/1a/89/d3d6fef58a488f8569c82fd293ab7cbd4250244d67f425dcae64c63800ea/datasets-3.6.0.tar.gz", upload-time = 2025-05-07T15:15:02Z, size = 569336, hashes = { sha256 = "1b2bf43b19776e2787e181cfd329cb0ca1a358ea014780c3581e0f276375e041" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/20/34/a08b0ee99715eaba118cbe19a71f7b5e2425c2718ef96007c325944a1152/datasets-3.6.0-py3-none-any.whl", upload-time = 2025-05-07T15:14:59Z, size = 491546, hashes = { sha256 = "25000c4a2c0873a710df127d08a202a06eab7bf42441a6bc278b499c2f72cd1b" } }] + +[[packages]] +name = "decorator" +version = "5.2.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", upload-time = 2025-02-24T04:41:34Z, size = 56711, hashes = { sha256 = "65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", upload-time = 2025-02-24T04:41:32Z, size = 9190, hashes = { sha256 = "d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a" } }] + +[[packages]] +name = "dill" +version = "0.3.8" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/17/4d/ac7ffa80c69ea1df30a8aa11b3578692a5118e7cd1aa157e3ef73b092d15/dill-0.3.8.tar.gz", upload-time = 2024-01-27T23:42:16Z, size = 184847, hashes = { sha256 = "3ebe3c479ad625c4553aca177444d89b486b1d84982eeacded644afc0cf797ca" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c9/7a/cef76fd8438a42f96db64ddaa85280485a9c395e7df3db8158cfec1eee34/dill-0.3.8-py3-none-any.whl", upload-time = 2024-01-27T23:42:14Z, size = 116252, hashes = { sha256 = "c36ca9ffb54365bdd2f8eb3eff7d2a21237f8452b57ace88b1ac615b7e815bd7" } }] + +[[packages]] +name = "diskcache" +version = "5.6.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/3f/21/1c1ffc1a039ddcc459db43cc108658f32c57d271d7289a2794e401d0fdb6/diskcache-5.6.3.tar.gz", upload-time = 2023-08-31T06:12:00Z, size = 67916, hashes = { sha256 = "2c3a3fa2743d8535d832ec61c2054a1641f41775aa7c556758a109941e33e4fc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3f/27/4570e78fc0bf5ea0ca45eb1de3818a23787af9b390c0b0a0033a1b8236f9/diskcache-5.6.3-py3-none-any.whl", upload-time = 2023-08-31T06:11:58Z, size = 45550, hashes = { sha256 = "5e31b2d5fbad117cc363ebaf6b689474db18a1f6438bc82358b024abd4c2ca19" } }] + +[[packages]] +name = "distro" +version = "1.9.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", upload-time = 2023-12-24T09:54:32Z, size = 60722, hashes = { sha256 = "2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", upload-time = 2023-12-24T09:54:30Z, size = 20277, hashes = { sha256 = "7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2" } }] + +[[packages]] +name = "docstring-parser" +version = "0.18.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/e0/4d/f332313098c1de1b2d2ff91cf2674415cc7cddab2ca1b01ae29774bd5fdf/docstring_parser-0.18.0.tar.gz", upload-time = 2026-04-14T04:09:19Z, size = 29341, hashes = { sha256 = "292510982205c12b1248696f44959db3cdd1740237a968ea1e2e7a900eeb2015" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a7/5f/ed01f9a3cdffbd5a008556fc7b2a08ddb1cc6ace7effa7340604b1d16699/docstring_parser-0.18.0-py3-none-any.whl", upload-time = 2026-04-14T04:09:18Z, size = 22484, hashes = { sha256 = "b3fcbed555c47d8479be0796ef7e19c2670d428d72e96da63f3a40122860374b" } }] + +[[packages]] +name = "einops" +version = "0.8.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/2c/77/850bef8d72ffb9219f0b1aac23fbc1bf7d038ee6ea666f331fa273031aa2/einops-0.8.2.tar.gz", upload-time = 2026-01-26T04:13:17Z, size = 56261, hashes = { sha256 = "609da665570e5e265e27283aab09e7f279ade90c4f01bcfca111f3d3e13f2827" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/09/f8d8f8f31e4483c10a906437b4ce31bdf3d6d417b73fe33f1a8b59e34228/einops-0.8.2-py3-none-any.whl", upload-time = 2026-01-26T04:13:18Z, size = 65638, hashes = { sha256 = "54058201ac7087911181bfec4af6091bb59380360f069276601256a76af08193" } }] + +[[packages]] +name = "executing" +version = "2.2.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", upload-time = 2025-09-01T09:48:10Z, size = 1129488, hashes = { sha256 = "3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", upload-time = 2025-09-01T09:48:08Z, size = 28317, hashes = { sha256 = "760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017" } }] + +[[packages]] +name = "fastapi" +version = "0.136.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/5d/45/c130091c2dfa061bbfe3150f2a5091ef1adf149f2a8d2ae769ecaf6e99a2/fastapi-0.136.1.tar.gz", upload-time = 2026-04-23T16:49:44Z, size = 397448, hashes = { sha256 = "7af665ad7acfa0a3baf8983d393b6b471b9da10ede59c60045f49fbc89a0fa7f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5a/ff/2e4eca3ade2c22fe1dea7043b8ee9dabe47753349eb1b56a202de8af6349/fastapi-0.136.1-py3-none-any.whl", upload-time = 2026-04-23T16:49:42Z, size = 117683, hashes = { sha256 = "a6e9d7eeada96c93a4d69cb03836b44fa34e2854accb7244a1ece36cd4781c3f" } }] + +[[packages]] +name = "filelock" +version = "3.29.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/b5/fe/997687a931ab51049acce6fa1f23e8f01216374ea81374ddee763c493db5/filelock-3.29.0.tar.gz", upload-time = 2026-04-19T15:39:10Z, size = 57571, hashes = { sha256 = "69974355e960702e789734cb4871f884ea6fe50bd8404051a3530bc07809cf90" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/81/47/dd9a212ef6e343a6857485ffe25bba537304f1913bdbed446a23f7f592e1/filelock-3.29.0-py3-none-any.whl", upload-time = 2026-04-19T15:39:08Z, size = 39812, hashes = { sha256 = "96f5f6344709aa1572bbf631c640e4ebeeb519e08da902c39a001882f30ac258" } }] + +[[packages]] +name = "flash-attn-4" +version = "4.0.0b19" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/93/63/6a00e1cd55765f5cf7d7a0100d1a5831824227ae3306275f3e6db420a76e/flash_attn_4-4.0.0b19.tar.gz", upload-time = 2026-06-24T09:15:14Z, size = 353141, hashes = { sha256 = "c904c9da0387c2ac0420cffdf61d6201d94cfeb354b6768fde794b04e9fc4e89" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e4/0e/5298d57e3efd5b7a07755fa9009fc1f6efc0f2d422915113eb7288a6552b/flash_attn_4-4.0.0b19-py3-none-any.whl", upload-time = 2026-06-24T09:15:13Z, size = 377662, hashes = { sha256 = "bc3856e018fa32e2b833726566641e51d02d45f2d444849937276a46c01653a2" } }] + +[[packages]] +name = "flashinfer-cubin" +version = "0.6.7.post3" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/91/64/f516081e983a35e3f52b7e525e2e62f1d6148c175eb24df32c8786776ba5/flashinfer_cubin-0.6.7.post3-py3-none-any.whl", upload-time = 2026-04-06T01:43:16Z, size = 294635743, hashes = { sha256 = "724cbce52f917dd06ebcb61fff2146c30b69cfdb341891d7c293249e414d6e35" } }] + +[[packages]] +name = "flashinfer-python" +version = "0.6.7.post3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/12/b5/466778818d195b96a062467ee389d0fcfa51fdfecad4a831922916d4c48a/flashinfer_python-0.6.7.post3.tar.gz", upload-time = 2026-04-06T01:43:00Z, size = 6508243, hashes = { sha256 = "defad86864e087f754ed0a632c2d15aa389a1dc8e3198fb6b7d7af4b36e3eaa5" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/01/6b/4117cd7cbeff07818ae7c6b8bf5a6d1ee3eed29356672b731b55af3d4453/flashinfer_python-0.6.7.post3-py3-none-any.whl", upload-time = 2026-04-06T01:42:58Z, size = 9187533, hashes = { sha256 = "9d3f1aa0313cf9e5cf99f7560b8e003c57876088c8abfe7a3d330cccd4873052" } }] + +[[packages]] +name = "frozenlist" +version = "1.8.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", upload-time = 2025-10-06T05:38:17Z, size = 45875, hashes = { sha256 = "3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2025-10-06T05:36:09Z, size = 242411, hashes = { sha256 = "494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383" } }, + { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", upload-time = 2025-10-06T05:38:16Z, size = 13409, hashes = { sha256 = "0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d" } }, +] + +[[packages]] +name = "fsspec" +version = "2025.3.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/34/f4/5721faf47b8c499e776bc34c6a8fc17efdf7fdef0b00f398128bc5dcb4ac/fsspec-2025.3.0.tar.gz", upload-time = 2025-03-07T21:47:56Z, size = 298491, hashes = { sha256 = "a935fd1ea872591f2b5148907d103488fc523295e6c64b835cfad8c3eca44972" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/56/53/eb690efa8513166adef3e0669afd31e95ffde69fb3c52ec2ac7223ed6018/fsspec-2025.3.0-py3-none-any.whl", upload-time = 2025-03-07T21:47:54Z, size = 193615, hashes = { sha256 = "efb87af3efa9103f94ca91a7f8cb7a4df91af9f74fc106c9c7ea0efd7277c1b3" } }] + +[[packages]] +name = "gguf" +version = "0.19.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/48/ae/17f1308ae45cd7b08ebb521747d5b23f4efc4d172038a4e228dd5106c3ff/gguf-0.19.0.tar.gz", upload-time = 2026-05-06T13:04:03Z, size = 111220, hashes = { sha256 = "dbadcd6cc7ccd44256f2229fe7c2dff5e8aa5cf0612ab987fd2b1a57e428923f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b3/bb/d71d6da82763528c2c2ed6b59a9d6142c6595545a4c448e2085d155e88c2/gguf-0.19.0-py3-none-any.whl", upload-time = 2026-05-06T13:04:02Z, size = 118475, hashes = { sha256 = "70bcd10edfe697fb2dad6e40af2234b9d8ece9a41a99761405121ebda1c3c1cd" } }] + +[[packages]] +name = "grpcio" +version = "1.78.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/06/8a/3d098f35c143a89520e568e6539cc098fcd294495910e359889ce8741c84/grpcio-1.78.0.tar.gz", upload-time = 2026-02-06T09:57:18Z, size = 12852416, hashes = { sha256 = "7382b95189546f375c174f53a5fa873cef91c4b8005faa05cc5b3beea9c4f1c5" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/54/bf/f4a3b9693e35d25b24b0b39fa46d7d8a3c439e0a3036c3451764678fec20/grpcio-1.78.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-02-06T09:55:36Z, size = 6690766, hashes = { sha256 = "12a771591ae40bc65ba67048fa52ef4f0e6db8279e595fd349f9dfddeef571f9" } }] + +[[packages]] +name = "grpcio-health-checking" +version = "1.78.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/8e/ac/8eb871f4e47b11abfe45497e6187a582ec680ccd7232706d228474a8c7a5/grpcio_health_checking-1.78.0.tar.gz", upload-time = 2026-02-06T10:01:47Z, size = 17008, hashes = { sha256 = "78526d5c60b9b99fd18954b89f86d70033c702e96ad6ccc9749baf16136979b3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8e/30/dbaf47e2210697e2923b49eb62a6a2c07d5ee55bb40cff1e6cc0c5bb22e1/grpcio_health_checking-1.78.0-py3-none-any.whl", upload-time = 2026-02-06T10:01:37Z, size = 19010, hashes = { sha256 = "309798c098c5de72a9bff7172d788fdf309d246d231db9955b32e7c1c773fbeb" } }] + +[[packages]] +name = "grpcio-reflection" +version = "1.78.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/31/06/337546aae558675f79cae2a8c1ce0c9b1952cbc5c28b01878f68d040f5bb/grpcio_reflection-1.78.0.tar.gz", upload-time = 2026-02-06T10:01:52Z, size = 19098, hashes = { sha256 = "e6e60c0b85dbcdf963b4d4d150c0f1d238ba891d805b575c52c0365d07fc0c40" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/df/6d/4d095d27ccd049865ecdafc467754e9e47ad0f677a30dda969c3590f6582/grpcio_reflection-1.78.0-py3-none-any.whl", upload-time = 2026-02-06T10:01:33Z, size = 22800, hashes = { sha256 = "06fcfde9e6888cdd12e9dd1cf6dc7c440c2e9acf420f696ccbe008672ed05b60" } }] + +[[packages]] +name = "h11" +version = "0.16.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", upload-time = 2025-04-24T03:35:25Z, size = 101250, hashes = { sha256 = "4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", upload-time = 2025-04-24T03:35:24Z, size = 37515, hashes = { sha256 = "63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86" } }] + +[[packages]] +name = "hf-xet" +version = "1.4.3" +marker = "(platform_machine == 'AMD64' and sys_platform == 'linux') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'amd64' and sys_platform == 'linux') or (platform_machine == 'arm64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" +sdist = { url = "https://files.pythonhosted.org/packages/53/92/ec9ad04d0b5728dca387a45af7bc98fbb0d73b2118759f5f6038b61a57e8/hf_xet-1.4.3.tar.gz", upload-time = 2026-03-31T22:40:07Z, size = 670477, hashes = { sha256 = "8ddedb73c8c08928c793df2f3401ec26f95be7f7e516a7bee2fbb546f6676113" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/df/9a/a24b26dc8a65f0ecc0fe5be981a19e61e7ca963b85e062c083f3a9100529/hf_xet-1.4.3-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-03-31T22:39:42Z, size = 4212320, hashes = { sha256 = "fc360b70c815bf340ed56c7b8c63aacf11762a4b099b2fe2c9bd6d6068668c08" } }] + +[[packages]] +name = "httpcore" +version = "1.0.9" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", upload-time = 2025-04-24T22:06:22Z, size = 85484, hashes = { sha256 = "6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", upload-time = 2025-04-24T22:06:20Z, size = 78784, hashes = { sha256 = "2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55" } }] + +[[packages]] +name = "httpcore2" +version = "2.3.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/e6/34/18f1c596e677962f040284246f393b10a1f8ce440b3a7e69c637d0f1c7ad/httpcore2-2.3.0.tar.gz", upload-time = 2026-06-01T13:15:02Z, size = 64300, hashes = { sha256 = "07327e251560960eea8e969d92d4c6a325feb13cca39e25340731336c3baf924" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c2/dd/3357218c69360d1cecc196c230c9a1d5c9afd5dba362056e23e60a5e64e5/httpcore2-2.3.0-py3-none-any.whl", upload-time = 2026-06-01T13:15:00Z, size = 80024, hashes = { sha256 = "477e9e334f74e5240dcac002e890580f36a57d40ff0fb14cc9655731d23b8415" } }] + +[[packages]] +name = "httpx" +version = "0.28.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", upload-time = 2024-12-06T15:37:23Z, size = 141406, hashes = { sha256 = "75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", upload-time = 2024-12-06T15:37:21Z, size = 73517, hashes = { sha256 = "d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad" } }] + +[[packages]] +name = "httpx2" +version = "2.3.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/9f/9a/cca0b9145f13d8ae34b885ae28d403a1469a433abc78e0f94f4ce94e650b/httpx2-2.3.0.tar.gz", upload-time = 2026-06-01T13:15:04Z, size = 81115, hashes = { sha256 = "227e7c41d95a76d4077a52640564132777215fc3394e07b66a3116c33d668fa9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/87/ce/ae2911859847f9ba1d6b23027e53481cbeb50b93234f355a968d300ca2cb/httpx2-2.3.0-py3-none-any.whl", upload-time = 2026-06-01T13:15:01Z, size = 74538, hashes = { sha256 = "6f393663bdf6dbe7fe90118e3eb5b2bd024a675cae0390ac08cec9198812d8b7" } }] + +[[packages]] +name = "huggingface-hub" +version = "1.16.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/48/0f/ed994dbade67a54407c28cab96ef845e0e6d25500be56aca6394f8bfc9dd/huggingface_hub-1.16.1.tar.gz", upload-time = 2026-05-21T18:40:00Z, size = 792534, hashes = { sha256 = "7f1dc4c5ec21aed69be630ad0c3378616be16f3de1a47b141c0e812965d9c832" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/49/79/621a7dbb80c70974f73a597275351ebe03ce5bc65cb5f8f4acb5859252bc/huggingface_hub-1.16.1-py3-none-any.whl", upload-time = 2026-05-21T18:39:58Z, size = 668176, hashes = { sha256 = "64340de934b9ce37857ef85a82de72f5629e8a270f9119eabb12bf495eb53c22" } }] + +[[packages]] +name = "idna" +version = "3.17" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/b9/28/99c51f664567218d824af024c0251650fb27e4ca066df188dab0769c5b91/idna-3.17.tar.gz", upload-time = 2026-05-28T14:32:38Z, size = 196048, hashes = { sha256 = "5eb0cb53bc467c12eadcf6de83163ad8527cec9416f44b9b61b19caedad2b87f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/de/a7/f76514cc40ad6234098ecdebda08732d75964776c51a42845b7da10649e2/idna-3.17-py3-none-any.whl", upload-time = 2026-05-28T14:32:37Z, size = 65316, hashes = { sha256 = "466e48829084efe2548012b855df21540b96f2e20e51bd124c851536556a592c" } }] + +[[packages]] +name = "importlib-metadata" +version = "8.5.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/cd/12/33e59336dca5be0c398a7482335911a33aa0e20776128f038019f1a95f1b/importlib_metadata-8.5.0.tar.gz", upload-time = 2024-09-11T14:56:08Z, size = 55304, hashes = { sha256 = "71522656f0abace1d072b9e5481a48f07c138e00f079c38c8f883823f9c26bd7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a0/d9/a1e041c5e7caa9a05c925f4bdbdfb7f006d1f74996af53467bc394c97be7/importlib_metadata-8.5.0-py3-none-any.whl", upload-time = 2024-09-11T14:56:07Z, size = 26514, hashes = { sha256 = "45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b" } }] + +[[packages]] +name = "interegular" +version = "0.3.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/dc/9d/8b6dde58a028a3962ce17e84d5fe73758df61378e00ef8ac3d85da34b0ff/interegular-0.3.3.tar.gz", upload-time = 2024-01-06T23:01:22Z, size = 24705, hashes = { sha256 = "d9b697b21b34884711399ba0f0376914b81899ce670032486d0d048344a76600" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c4/01/72d6472f80651673716d1deda2a5bbb633e563ecf94f4479da5519d69d25/interegular-0.3.3-py37-none-any.whl", upload-time = 2024-01-06T23:01:20Z, size = 23635, hashes = { sha256 = "b0c07007d48c89d6d19f7204972d369b2a77222722e126b6aa63aa721dc3b19c" } }] + +[[packages]] +name = "ipython" +version = "9.13.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/cd/c4/87cda5842cf5c31837c06ddb588e11c3c35d8ece89b7a0108c06b8c9b00a/ipython-9.13.0.tar.gz", upload-time = 2026-04-24T12:24:55Z, size = 4430549, hashes = { sha256 = "7e834b6afc99f020e3f05966ced34792f40267d64cb1ea9043886dab0dde5967" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b9/86/3060e8029b7cc505cce9a0137431dda81d0a3fde93a8f0f50ee0bf37a795/ipython-9.13.0-py3-none-any.whl", upload-time = 2026-04-24T12:24:53Z, size = 627274, hashes = { sha256 = "57f9d4639e20818d328d287c7b549af3d05f12486ea8f2e7f73e52a36ec4d201" } }] + +[[packages]] +name = "ipython-pygments-lexers" +version = "1.1.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", upload-time = 2025-01-17T11:24:34Z, size = 8393, hashes = { sha256 = "09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", upload-time = 2025-01-17T11:24:33Z, size = 8074, hashes = { sha256 = "a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c" } }] + +[[packages]] +name = "jedi" +version = "0.19.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", upload-time = 2024-11-11T01:41:42Z, size = 1231287, hashes = { sha256 = "4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", upload-time = 2024-11-11T01:41:40Z, size = 1572278, hashes = { sha256 = "a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9" } }] + +[[packages]] +name = "jinja2" +version = "3.1.6" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://download.pytorch.org/whl/jinja2-3.1.6-py3-none-any.whl", upload-time = 2025-10-14T18:38:59Z, hashes = { sha256 = "85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67" } }] + +[[packages]] +name = "jiter" +version = "0.13.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/0d/5e/4ec91646aee381d01cdb9974e30882c9cd3b8c5d1079d6b5ff4af522439a/jiter-0.13.0.tar.gz", upload-time = 2026-02-02T12:37:56Z, size = 164847, hashes = { sha256 = "f2839f9c2c7e2dffc1bc5929a510e14ce0a946be9365fd1219e7ef342dae14f4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f8/4c/09b93e30e984a187bc8aaa3510e1ec8dcbdcd71ca05d2f56aac0492453aa/jiter-0.13.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-02-02T12:36:06Z, size = 360735, hashes = { sha256 = "bdaba7d87e66f26a2c45d8cbadcbfc4bf7884182317907baf39cfe9775bb4d93" } }] + +[[packages]] +name = "jsonschema" +version = "4.23.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/38/2e/03362ee4034a4c917f697890ccd4aec0800ccf9ded7f511971c75451deec/jsonschema-4.23.0.tar.gz", upload-time = 2024-07-08T18:40:05Z, size = 325778, hashes = { sha256 = "d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/69/4a/4f9dbeb84e8850557c02365a0eee0649abe5eb1d84af92a25731c6c0f922/jsonschema-4.23.0-py3-none-any.whl", upload-time = 2024-07-08T18:40:00Z, size = 88462, hashes = { sha256 = "fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566" } }] + +[[packages]] +name = "jsonschema-specifications" +version = "2025.9.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", upload-time = 2025-09-08T01:34:59Z, size = 32855, hashes = { sha256 = "b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", upload-time = 2025-09-08T01:34:57Z, size = 18437, hashes = { sha256 = "98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe" } }] + +[[packages]] +name = "lark" +version = "1.3.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/da/34/28fff3ab31ccff1fd4f6c7c7b0ceb2b6968d8ea4950663eadcb5720591a0/lark-1.3.1.tar.gz", upload-time = 2025-10-27T18:25:56Z, size = 382732, hashes = { sha256 = "b426a7a6d6d53189d318f2b6236ab5d6429eaf09259f1ca33eb716eed10d2905" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl", upload-time = 2025-10-27T18:25:54Z, size = 113151, hashes = { sha256 = "c629b661023a014c37da873b4ff58a817398d12635d3bbb2c5a03be7fe5d1e12" } }] + +[[packages]] +name = "llguidance" +version = "0.7.30" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/bf/38/d1ef3ae08d8d857e5e0690c5b1e07bf7eb4a1cae5881d87215826dc6cadb/llguidance-0.7.30.tar.gz", upload-time = 2025-06-23T00:23:49Z, size = 1055528, hashes = { sha256 = "e93bf75f2b6e48afb86a5cee23038746975e1654672bf5ba0ae75f7d4d4a2248" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/af/80/5a40b9689f17612434b820854cba9b8cabd5142072c491b5280fe5f7a35e/llguidance-0.7.30-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-06-23T00:23:43Z, size = 15004926, hashes = { sha256 = "9edc409b9decd6cffba5f5bf3b4fbd7541f95daa8cbc9510cbf96c6ab1ffc153" } }] + +[[packages]] +name = "loguru" +version = "0.7.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/3a/05/a1dae3dffd1116099471c643b8924f5aa6524411dc6c63fdae648c4f1aca/loguru-0.7.3.tar.gz", upload-time = 2024-12-06T11:20:56Z, size = 63559, hashes = { sha256 = "19480589e77d47b8d85b2c827ad95d49bf31b0dcde16593892eb51dd18706eb6" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl", upload-time = 2024-12-06T11:20:54Z, size = 61595, hashes = { sha256 = "31a33c10c8e1e10422bfd431aeb5d351c7cf7fa671e3c4df004162264b28220c" } }] + +[[packages]] +name = "lxml" +version = "6.1.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/28/30/9abc9e34c657c33834eaf6cd02124c61bdf5944d802aa48e69be8da3585d/lxml-6.1.0.tar.gz", upload-time = 2026-04-18T04:32:51Z, size = 4197006, hashes = { sha256 = "bfd57d8008c4965709a919c3e9a98f76c2c7cb319086b3d26858250620023b13" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/7c/e08a970727d556caa040a44773c7b7e3ad0f0d73dedc863543e9a8b931f2/lxml-6.1.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-04-18T04:32:58Z, size = 5093820, hashes = { sha256 = "9147d8e386ec3b82c3b15d88927f734f565b0aaadef7def562b853adca45784a" } }, + { url = "https://files.pythonhosted.org/packages/31/ba/3c13d3fc24b7cacf675f808a3a1baabf43a30d0cd24c98f94548e9aa58eb/lxml-6.1.0-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-18T04:33:06Z, size = 5240445, hashes = { sha256 = "bc783ee3147e60a25aa0445ea82b3e8aabb83b240f2b95d32cb75587ff781814" } }, +] + +[[packages]] +name = "markdown-it-py" +version = "4.0.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", upload-time = 2025-08-11T12:57:52Z, size = 73070, hashes = { sha256 = "cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", upload-time = 2025-08-11T12:57:51Z, size = 87321, hashes = { sha256 = "87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147" } }] + +[[packages]] +name = "markupsafe" +version = "3.0.3" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://download.pytorch.org/whl/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-27T13:54:35Z, hashes = { sha256 = "d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d" } }] + +[[packages]] +name = "matplotlib-inline" +version = "0.2.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/c7/74/97e72a36efd4ae2bccb3463284300f8953f199b5ffbc04cbbb0ec78f74b1/matplotlib_inline-0.2.1.tar.gz", upload-time = 2025-10-23T09:00:22Z, size = 8110, hashes = { sha256 = "e1ee949c340d771fc39e241ea75683deb94762c8fa5f2927ec57c83c4dffa9fe" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/af/33/ee4519fa02ed11a94aef9559552f3b17bb863f2ecfe1a35dc7f548cde231/matplotlib_inline-0.2.1-py3-none-any.whl", upload-time = 2025-10-23T09:00:20Z, size = 9516, hashes = { sha256 = "d56ce5156ba6085e00a9d54fead6ed29a9c47e215cd1bba2e976ef39f5710a76" } }] + +[[packages]] +name = "mdurl" +version = "0.1.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", upload-time = 2022-08-14T12:40:10Z, size = 8729, hashes = { sha256 = "bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", upload-time = 2022-08-14T12:40:09Z, size = 9979, hashes = { sha256 = "84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8" } }] + +[[packages]] +name = "mistral-common" +version = "1.9.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/db/ce/685b8127a326478e05501cb4c9ca23d1cd9f37e16c465a1e832c75aea709/mistral_common-1.9.1.tar.gz", upload-time = 2026-02-12T10:53:41Z, size = 6338922, hashes = { sha256 = "550583d70a395c3586cfb748ffab53bd1d7c3409507f0efc0118bff30ffb26e9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ac/72/a38bb1fd9fd4d4ef990341c9dd1a7c8061f1951e10efa6d50c0a3f04eced/mistral_common-1.9.1-py3-none-any.whl", upload-time = 2026-02-12T10:53:39Z, size = 6518623, hashes = { sha256 = "9e2b2520b6f67bac2e2bb06fcf985b7a1277b01938da2b7cda8cf0fdbfa92e91" } }] + +[[packages]] +name = "modelscope" +version = "1.40.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/d7/af/f92c9824db46757dd1b0b5cbf3778daf54e7e44f0e1e6934d0b1bedfb286/modelscope-1.40.2.tar.gz", upload-time = 2026-10-09T09:09:10Z, size = 4566951, hashes = { sha256 = "7a642cef8c144c28c4ddcc37db5fd803f5481f0d78a7f26c2b9e0e2a225b528c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b9/8a/e85b79ee1c541f7bbf208fd7a6185c9b11e50c192b1071b0750db26b09e9/modelscope-1.40.2-py3-none-any.whl", upload-time = 2026-10-09T09:09:07Z, size = 6062299, hashes = { sha256 = "ea03e0ec4a73398a488d3d240cda4f0c5b62390377a134756d4074a3036cb909" } }] + +[[packages]] +name = "modelscope-hub" +version = "0.4.6" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/08/d9/ac46c39b957ff44b55c550c641ad5c625ffe3eb5c0b6f20a849b591e9d14/modelscope_hub-0.4.6.tar.gz", upload-time = 2026-10-09T08:08:21Z, size = 298574, hashes = { sha256 = "c54de09be2ccb27b9214f7c3ebe5751121f335f5016643f789589d0547e78c52" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/4d/74/8872ae511d8a336ca918a8d0234cfbccfff0e2304de672882b2768ff628f/modelscope_hub-0.4.6-py3-none-any.whl", upload-time = 2026-10-09T08:08:19Z, size = 237177, hashes = { sha256 = "361bcec229bfbed645a9291ec5b167d76cd94b795207dc2eceba628108f4023a" } }] + +[[packages]] +name = "mpmath" +version = "1.3.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", upload-time = 2023-03-07T16:47:11Z, size = 508106, hashes = { sha256 = "7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", upload-time = 2023-03-07T16:47:09Z, size = 536198, hashes = { sha256 = "a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c" } }] + +[[packages]] +name = "msgspec" +version = "0.21.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/e3/60/f79b9b013a16fa3a58350c9295ddc6789f2e335f36ea61ed10a21b215364/msgspec-0.21.1.tar.gz", upload-time = 2026-04-12T21:44:50Z, size = 319193, hashes = { sha256 = "2313508e394b0d208f8f56892ca9b2799e2561329de9763b19619595a6c0f72c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b5/d1/d4cd9fe89c7d400d7a18f86ccc94daa3f0927f53558846fcb60791dce5d6/msgspec-0.21.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-12T21:44:11Z, size = 225025, hashes = { sha256 = "21995e74b5c598c2e004110ad66ec7f1b8c20bf2bcf3b2de8fd9a3094422d3ff" } }] + +[[packages]] +name = "multidict" +version = "6.7.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", upload-time = 2026-01-26T02:46:45Z, size = 102010, hashes = { sha256 = "ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-01-26T02:44:03Z, size = 256322, hashes = { sha256 = "bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961" } }, + { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", upload-time = 2026-01-26T02:46:44Z, size = 12319, hashes = { sha256 = "55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56" } }, +] + +[[packages]] +name = "multiprocess" +version = "0.70.16" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/b5/ae/04f39c5d0d0def03247c2893d6f2b83c136bf3320a2154d7b8858f2ba72d/multiprocess-0.70.16.tar.gz", upload-time = 2024-01-28T18:52:34Z, size = 1772603, hashes = { sha256 = "161af703d4652a0e1410be6abccecde4a7ddffd19341be0a7011b94aeb171ac1" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bc/f7/7ec7fddc92e50714ea3745631f79bd9c96424cb2702632521028e57d3a36/multiprocess-0.70.16-py310-none-any.whl", upload-time = 2024-01-28T18:52:26Z, size = 134824, hashes = { sha256 = "c4a9944c67bd49f823687463660a2d6daae94c289adff97e0f9d696ba6371d02" } }, + { url = "https://files.pythonhosted.org/packages/50/15/b56e50e8debaf439f44befec5b2af11db85f6e0f344c3113ae0be0593a91/multiprocess-0.70.16-py311-none-any.whl", upload-time = 2024-01-28T18:52:28Z, size = 143519, hashes = { sha256 = "af4cabb0dac72abfb1e794fa7855c325fd2b55a10a44628a3c1ad3311c04127a" } }, + { url = "https://files.pythonhosted.org/packages/0a/7d/a988f258104dcd2ccf1ed40fdc97e26c4ac351eeaf81d76e266c52d84e2f/multiprocess-0.70.16-py312-none-any.whl", upload-time = 2024-01-28T18:52:29Z, size = 146741, hashes = { sha256 = "fc0544c531920dde3b00c29863377f87e1632601092ea2daca74e4beb40faa2e" } }, + { url = "https://files.pythonhosted.org/packages/ea/89/38df130f2c799090c978b366cfdf5b96d08de5b29a4a293df7f7429fa50b/multiprocess-0.70.16-py38-none-any.whl", upload-time = 2024-01-28T18:52:30Z, size = 132628, hashes = { sha256 = "a71d82033454891091a226dfc319d0cfa8019a4e888ef9ca910372a446de4435" } }, + { url = "https://files.pythonhosted.org/packages/da/d9/f7f9379981e39b8c2511c9e0326d212accacb82f12fbfdc1aa2ce2a7b2b6/multiprocess-0.70.16-py39-none-any.whl", upload-time = 2024-01-28T18:52:31Z, size = 133351, hashes = { sha256 = "a0bafd3ae1b732eac64be2e72038231c1ba97724b60b09400d68f229fcc2fbf3" } }, +] + +[[packages]] +name = "nest-asyncio" +version = "1.6.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", upload-time = 2024-01-21T14:25:19Z, size = 7418, hashes = { sha256 = "6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", upload-time = 2024-01-21T14:25:17Z, size = 5195, hashes = { sha256 = "87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c" } }] + +[[packages]] +name = "networkx" +version = "3.6.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", upload-time = 2025-12-08T17:02:39Z, size = 2517025, hashes = { sha256 = "26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", upload-time = 2025-12-08T17:02:38Z, size = 2068504, hashes = { sha256 = "d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762" } }] + +[[packages]] +name = "ninja" +version = "1.13.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ac/92/410b7917d16ab54c04b05cc32b9284803671d91cf79d33be6009c28d4ea8/ninja-1.13.2.tar.gz", upload-time = 2026-08-30T15:49:51Z, size = 243739, hashes = { sha256 = "525bfa3fc88aa30a4467df270fd5be6f9fcae8061d54d4df74ea1dc5abd5a975" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/6e/53/ebfed7b689c338dd8ebeec9c0730c8d56821292f14e2536e5f3ef1a05744/ninja-1.13.2-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-08-30T15:49:34Z, size = 183365, hashes = { sha256 = "65a24341b5ac09fcadcc37082660be40a94174e51a937fabf6e2cae26225fa2c" } }] + +[[packages]] +name = "numpy" +version = "2.4.4" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/d7/9f/b8cef5bffa569759033adda9481211426f12f53299629b410340795c2514/numpy-2.4.4.tar.gz", upload-time = 2026-03-29T13:22:01Z, size = 20731587, hashes = { sha256 = "2d390634c5182175533585cc89f3608a4682ccb173cc9bb940b2881c8d6f8fa0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0a/0d/0e3ecece05b7a7e87ab9fb587855548da437a061326fff64a223b6dcb78a/numpy-2.4.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-29T13:19:03Z, size = 16645480, hashes = { sha256 = "81f4a14bee47aec54f883e0cad2d73986640c1590eb9bfaaba7ad17394481e6e" } }] + +[[packages]] +name = "nvidia-cudnn-frontend" +version = "1.31.0" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/cb/24/8ec9de1fd9ea95e1c1cb9e6e2d3a5547aa9c5ece1136d650ffce1bb5d8c5/nvidia_cudnn_frontend-1.31.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-10-08T18:06:15Z, size = 10159344, hashes = { sha256 = "3171f102254136418f24b4470dfa5419f34b03d9d792a4b773cf65c7a37e6bf8" } }] + +[[packages]] +name = "nvidia-cutlass-dsl" +version = "4.8.1" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/bd/ce/a590b929285faf0aa285c5ccee2b88e0b5259fb39a6326206e0f140ea3fc/nvidia_cutlass_dsl-4.8.1-py3-none-any.whl", upload-time = 2026-10-16T10:54:15Z, size = 10510, hashes = { sha256 = "43ed46b21d151aa643c6765457c7310827b938c1cf45d5109a0152de4ef06227" } }] + +[[packages]] +name = "nvidia-cutlass-dsl-libs-base" +version = "4.8.1" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/28/97/d8212f685544dc7208d78186128dc8a454158b1817a76b34d25392b9f910/nvidia_cutlass_dsl_libs_base-4.8.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-10-16T08:39:52Z, size = 3050567, hashes = { sha256 = "ac2fd8c7fa3d6ded00917fa7cba8686061005da8c4703c6a29e03c1504543909" } }] + +[[packages]] +name = "nvidia-cutlass-dsl-libs-core" +version = "4.8.1" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/6c/03/1c59e3caf7c8b5cae3ae4d1753201c7e64d36cdf182fb882e070b0f14a55/nvidia_cutlass_dsl_libs_core-4.8.1-py3-none-any.whl", upload-time = 2026-10-16T08:35:00Z, size = 1635096, hashes = { sha256 = "bacc6760e3286db447d45720d32ae58ac2e6cecade1152345ef784b2d5e44431" } }] + +[[packages]] +name = "nvidia-cutlass-dsl-libs-cu12" +version = "4.8.1" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/11/f4/a4f35a52b8a495b5dd3ad7b466567b3dbec656442811085ca1cb7d4a1d97/nvidia_cutlass_dsl_libs_cu12-4.8.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-10-16T10:41:51Z, size = 91697915, hashes = { sha256 = "440b88739120c65d96c5f15bbe496a3bd7c26392874d5af6061d38497f84c70c" } }] + +[[packages]] +name = "nvidia-cutlass-dsl-libs-cu13" +version = "4.8.1" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/a1/f2/0497bd834c92c8f30d6927388a91903e8e995ab7d1b5cbead87f0fd7187f/nvidia_cutlass_dsl_libs_cu13-4.8.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-10-16T10:48:43Z, size = 91954433, hashes = { sha256 = "50191a381d8cc1393373ae0bc879b0aefa9a256c23c22d4fa1c2fe3dfe57bc90" } }] + +[[packages]] +name = "nvidia-ml-py" +version = "13.595.45" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ce/49/c29f6e30d8662d2e94fef17739ea7309cc76aba269922ae999e4cc07f268/nvidia_ml_py-13.595.45.tar.gz", upload-time = 2026-03-19T16:59:44Z, size = 50780, hashes = { sha256 = "c9f34897fe0441ff35bc8f35baf80f830a20b0f4e6ce71e0a325bc0e66acf079" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8a/24/fc256107d23597fa33d319505ce77160fa1a2349c096d01901ffc7cb7fc4/nvidia_ml_py-13.595.45-py3-none-any.whl", upload-time = 2026-03-19T16:59:43Z, size = 51776, hashes = { sha256 = "b65a7977f503d56154b14d683710125ef93594adb63fbf7e559336e3318f1376" } }] + +[[packages]] +name = "openai" +version = "2.6.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/c4/44/303deb97be7c1c9b53118b52825cbd1557aeeff510f3a52566b1fa66f6a2/openai-2.6.1.tar.gz", upload-time = 2025-10-24T13:29:52Z, size = 593043, hashes = { sha256 = "27ae704d190615fca0c0fc2b796a38f8b5879645a3a52c9c453b23f97141bb49" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/15/0e/331df43df633e6105ff9cf45e0ce57762bd126a45ac16b25a43f6738d8a2/openai-2.6.1-py3-none-any.whl", upload-time = 2025-10-24T13:29:50Z, size = 1005551, hashes = { sha256 = "904e4b5254a8416746a2f05649594fa41b19d799843cd134dac86167e094edef" } }] + +[[packages]] +name = "openai-harmony" +version = "0.0.4" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/92/94/01509d510bebf6606614e51113e5a415ced15b8f34aa98a8bf2539314650/openai_harmony-0.0.4.tar.gz", upload-time = 2025-08-09T01:43:24Z, size = 279848, hashes = { sha256 = "5c67ac6df349236fb7b64f57c3dbb0273efcdca24314daa108f2a482c427106c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1f/ec/dcdcace0ffcf3a532cca910e0c351b62d3a7decf0b091ea8cf856d2a67a6/openai_harmony-0.0.4-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-08-09T01:43:11Z, size = 3049306, hashes = { sha256 = "31e9bcac0902a309e2fc688e52f247eec7fffcd00d17e958b9a83a8fea6519c2" } }] + +[[packages]] +name = "opentelemetry-api" +version = "1.41.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/fa/fc/b7564cbef36601aef0d6c9bc01f7badb64be8e862c2e1c3c5c3b43b53e4f/opentelemetry_api-1.41.1.tar.gz", upload-time = 2026-04-24T13:15:38Z, size = 71416, hashes = { sha256 = "0ad1814d73b875f84494387dae86ce0b12c68556331ce6ce8fe789197c949621" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/29/59/3e7118ed140f76b0982ba4321bdaed1997a0473f9720de2d10788a577033/opentelemetry_api-1.41.1-py3-none-any.whl", upload-time = 2026-04-24T13:15:15Z, size = 69007, hashes = { sha256 = "a22df900e75c76dc08440710e51f52f1aa6b451b429298896023e60db5b3139f" } }] + +[[packages]] +name = "orjson" +version = "3.11.8" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/9d/1b/2024d06792d0779f9dbc51531b61c24f76c75b9f4ce05e6f3377a1814cea/orjson-3.11.8.tar.gz", upload-time = 2026-03-31T16:16:27Z, size = 5603832, hashes = { sha256 = "96163d9cdc5a202703e9ad1b9ae757d5f0ca62f4fa0cc93d1f27b0e180cc404e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/37/87/5ddeb7fc1fbd9004aeccab08426f34c81a5b4c25c7061281862b015fce2b/orjson-3.11.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-03-31T16:15:22Z, size = 133624, hashes = { sha256 = "53a0f57e59a530d18a142f4d4ba6dfc708dc5fdedce45e98ff06b44930a2a48f" } }] + +[[packages]] +name = "outlines" +version = "0.1.11" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ac/d0/d59ae830bf7026425942899e3d48e77b58a713cff946a695e5405808da1b/outlines-0.1.11.tar.gz", upload-time = 2024-12-13T07:24:08Z, size = 2488858, hashes = { sha256 = "0997bd9da1cc050e430bd08995dc7d4bd855918bafa4531e49d3f37110a23aba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/13/b4/99ea4a122bef60e3fd6402d19665aff1f928e0daf8fac3044d0b73f72003/outlines-0.1.11-py3-none-any.whl", upload-time = 2024-12-13T07:24:05Z, size = 87623, hashes = { sha256 = "f5a5f2242ed9802d3aab7a92789bf4008d734c576be9258cc0a297f690124727" } }] + +[[packages]] +name = "outlines-core" +version = "0.1.26" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/d3/f3/274d07f4702728b43581235a77e545ec602b25f9b0098b288a0f3052521d/outlines_core-0.1.26.tar.gz", upload-time = 2024-12-12T23:38:50Z, size = 75139, hashes = { sha256 = "481c4301341e77cc8f1832d616784adb4d461b4fec65878e7c0d2cba7163a189" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e2/1d/a36292b6198986bd9c3ff8c24355deb82ed5475403379ee40b5b5473e2e3/outlines_core-0.1.26-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2024-12-12T23:38:34Z, size = 343201, hashes = { sha256 = "e86a1bb46adc5cbf6dfd7a7fe4105e0e2a4c6e041732a053126b41c521a1f223" } }] + +[[packages]] +name = "packaging" +version = "24.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", upload-time = 2024-11-08T09:47:47Z, size = 163950, hashes = { sha256 = "c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", upload-time = 2024-11-08T09:47:44Z, size = 65451, hashes = { sha256 = "09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759" } }] + +[[packages]] +name = "pandas" +version = "2.3.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", upload-time = 2025-09-29T23:34:51Z, size = 4495223, hashes = { sha256 = "e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e5/63/cd7d615331b328e287d8233ba9fdf191a9c2d11b6af0c7a59cfcec23de68/pandas-2.3.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-09-29T23:20:14Z, size = 12362693, hashes = { sha256 = "b3d11d2fda7eb164ef27ffc14b4fcab16a80e1ce67e9f57e19ec0afaf715ba89" } }] + +[[packages]] +name = "parso" +version = "0.8.6" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/81/76/a1e769043c0c0c9fe391b702539d594731a4362334cdf4dc25d0c09761e7/parso-0.8.6.tar.gz", upload-time = 2026-02-09T15:45:24Z, size = 401621, hashes = { sha256 = "2b9a0332696df97d454fa67b81618fd69c35a7b90327cbe6ba5c92d2c68a7bfd" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b6/61/fae042894f4296ec49e3f193aff5d7c18440da9e48102c3315e1bc4519a7/parso-0.8.6-py2.py3-none-any.whl", upload-time = 2026-02-09T15:45:21Z, size = 106894, hashes = { sha256 = "2c549f800b70a5c4952197248825584cb00f033b29c692671d3bf08bf380baff" } }] + +[[packages]] +name = "partial-json-parser" +version = "0.2.1.1.post7" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/6a/6d/eed37d7ebc1e0bcd27b831c0cf1fe94881934316187c4b30d23f29ea0bd4/partial_json_parser-0.2.1.1.post7.tar.gz", upload-time = 2025-11-17T07:27:41Z, size = 10296, hashes = { sha256 = "86590e1ba6bcb6739a2dfc17d2323f028cb5884f4c6ce23db376999132c9a922" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/42/32/658973117bf0fd82a24abbfb94fe73a5e86216e49342985e10acce54775a/partial_json_parser-0.2.1.1.post7-py3-none-any.whl", upload-time = 2025-11-17T07:27:40Z, size = 10877, hashes = { sha256 = "145119e5eabcf80cbb13844a6b50a85c68bf99d376f8ed771e2a3c3b03e653ae" } }] + +[[packages]] +name = "pexpect" +version = "4.9.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", upload-time = 2023-11-25T09:07:26Z, size = 166450, hashes = { sha256 = "ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", upload-time = 2023-11-25T06:56:14Z, size = 63772, hashes = { sha256 = "7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523" } }] + +[[packages]] +name = "pillow" +version = "12.3.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/1c/3d/bb7fca845737cf9d7dbde16ed1843984665ff2e0a518f5db43e77ec540b9/pillow-12.3.0.tar.gz", upload-time = 2026-07-01T11:56:38Z, size = 47025035, hashes = { sha256 = "3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/84/21/a35af28dcc61f37ed850a2d64c65c701321dfbf25085e469d5559360cbbf/pillow-12.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-01T11:54:13Z, size = 6940830, hashes = { sha256 = "78cb2c6865a35ab8ff8b75fd122f6033b92a62c82801110e48ddd6c936a45d91" } }] + +[[packages]] +name = "prometheus-client" +version = "0.26.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/52/73/f1334c29c2af4cd9dba6c7817e61b611bd0215e2eb5565c6064a4de18802/prometheus_client-0.26.0.tar.gz", upload-time = 2026-07-24T19:36:41Z, size = 92910, hashes = { sha256 = "04a91bcf94e2cf74a44a1a874d651a2e853ed354b6e822f3b7487751465d5c2b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/eb/a3/b69efbf4143b5b9859b977770bbbabcc2796b702fa69dc40271e45cd5a56/prometheus_client-0.26.0-py3-none-any.whl", upload-time = 2026-07-24T19:36:40Z, size = 64494, hashes = { sha256 = "fa93d06737aa02bacd05794768508bb97d2fbee28cb3bca04eaae92f0ca953d6" } }] + +[[packages]] +name = "prompt-toolkit" +version = "3.0.52" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", upload-time = 2025-08-27T15:24:02Z, size = 434198, hashes = { sha256 = "28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", upload-time = 2025-08-27T15:23:59Z, size = 391431, hashes = { sha256 = "9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955" } }] + +[[packages]] +name = "propcache" +version = "0.4.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", upload-time = 2025-10-08T19:49:02Z, size = 46442, hashes = { sha256 = "f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/46/4b/3aae6835b8e5f44ea6a68348ad90f78134047b503765087be2f9912140ea/propcache-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-10-08T19:46:54Z, size = 221575, hashes = { sha256 = "15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf" } }, + { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", upload-time = 2025-10-08T19:49:00Z, size = 13305, hashes = { sha256 = "af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237" } }, +] + +[[packages]] +name = "protobuf" +version = "6.33.6" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/66/70/e908e9c5e52ef7c3a6c7902c9dfbb34c7e29c25d2f81ade3856445fd5c94/protobuf-6.33.6.tar.gz", upload-time = 2026-03-18T19:05:00Z, size = 444531, hashes = { sha256 = "a6768d25248312c297558af96a9f9c929e8c4cee0659cb07e780731095f38135" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/16/92/d1e32e3e0d894fe00b15ce28ad4944ab692713f2e7f0a99787405e43533a/protobuf-6.33.6-cp39-abi3-manylinux2014_x86_64.whl", upload-time = 2026-03-18T19:04:55Z, size = 323436, hashes = { sha256 = "e9db7e292e0ab79dd108d7f1a94fe31601ce1ee3f7b79e0692043423020b0593" } }, + { url = "https://files.pythonhosted.org/packages/c4/72/02445137af02769918a93807b2b7890047c32bfb9f90371cbc12688819eb/protobuf-6.33.6-py3-none-any.whl", upload-time = 2026-03-18T19:04:59Z, size = 170656, hashes = { sha256 = "77179e006c476e69bf8e8ce866640091ec42e1beb80b213c3900006ecfba6901" } }, +] + +[[packages]] +name = "psutil" +version = "7.2.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", upload-time = 2026-01-28T18:14:54Z, size = 493740, hashes = { sha256 = "0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-01-28T18:15:25Z, size = 155560, hashes = { sha256 = "076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9" } }] + +[[packages]] +name = "ptyprocess" +version = "0.7.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", upload-time = 2020-12-28T15:15:30Z, size = 70762, hashes = { sha256 = "5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", upload-time = 2020-12-28T15:15:28Z, size = 13993, hashes = { sha256 = "4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35" } }] + +[[packages]] +name = "pure-eval" +version = "0.2.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", upload-time = 2024-07-21T12:58:21Z, size = 19752, hashes = { sha256 = "5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", upload-time = 2024-07-21T12:58:20Z, size = 11842, hashes = { sha256 = "1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0" } }] + +[[packages]] +name = "py-spy" +version = "0.4.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/93/d8/5b71371f50cf153b1307e5a11ac8a4ce4d85651dae946bd7e9a064146545/py_spy-0.4.2.tar.gz", upload-time = 2026-04-24T22:08:54Z, size = 286374, hashes = { sha256 = "90e600b27bb6bb40479637baca5a5b4bc2ba3395c93d889e672315d93042c4ae" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f9/34/dd7d3c763a00b7b965e25a5eab0acd1a345dbaf0f45fffe595278873a1c0/py_spy-0.4.2-py2.py3-none-manylinux_2_5_x86_64.manylinux1_x86_64.whl", upload-time = 2026-04-24T22:08:52Z, size = 2936518, hashes = { sha256 = "aeb0323409199c785f730645e9f4bb7a7b9ca2c481f2c331a55642b5d13fa52f" } }] + +[[packages]] +name = "pyarrow" +version = "23.0.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/88/22/134986a4cc224d593c1afde5494d18ff629393d74cc2eddb176669f234a4/pyarrow-23.0.1.tar.gz", upload-time = 2026-02-16T10:14:12Z, size = 1167336, hashes = { sha256 = "b8c5873e33440b2bc2f4a79d2b47017a89c5a24116c055625e6f2ee50523f019" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2c/a5/da83046273d990f256cb79796a190bbf7ec999269705ddc609403f8c6b06/pyarrow-23.0.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-02-16T10:10:17Z, size = 47586063, hashes = { sha256 = "813d99f31275919c383aab17f0f455a04f5a429c261cc411b1e9a8f5e4aaaa05" } }] + +[[packages]] +name = "pybase64" +version = "1.4.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/aa/b8/4ed5c7ad5ec15b08d35cc79ace6145d5c1ae426e46435f4987379439dfea/pybase64-1.4.3.tar.gz", upload-time = 2025-12-06T13:27:04Z, size = 137272, hashes = { sha256 = "c2ed274c9e0ba9c8f9c4083cfe265e66dd679126cd9c2027965d807352f3f053" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/62/f7/965b79ff391ad208b50e412b5d3205ccce372a2d27b7218ae86d5295b105/pybase64-1.4.3-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2025-12-06T13:23:20Z, size = 71599, hashes = { sha256 = "bb632edfd132b3eaf90c39c89aa314beec4e946e210099b57d40311f704e11d4" } }] + +[[packages]] +name = "pycountry" +version = "26.2.16" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/de/1d/061b9e7a48b85cfd69f33c33d2ef784a531c359399ad764243399673c8f5/pycountry-26.2.16.tar.gz", upload-time = 2026-02-17T03:42:52Z, size = 7711342, hashes = { sha256 = "5b6027d453fcd6060112b951dd010f01f168b51b4bf8a1f1fc8c95c8d94a0801" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9c/42/7703bd45b62fecd44cd7d3495423097e2f7d28bc2e99e7c1af68892ab157/pycountry-26.2.16-py3-none-any.whl", upload-time = 2026-02-17T03:42:49Z, size = 8044600, hashes = { sha256 = "115c4baf7cceaa30f59a4694d79483c9167dbce7a9de4d3d571c5f3ea77c305a" } }] + +[[packages]] +name = "pycparser" +version = "3.0" +marker = "implementation_name != 'PyPy' and sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", upload-time = 2026-01-21T14:26:51Z, size = 103492, hashes = { sha256 = "600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", upload-time = 2026-01-21T14:26:50Z, size = 48172, hashes = { sha256 = "b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992" } }] + +[[packages]] +name = "pycryptodomex" +version = "3.24.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/f4/e7/50e72301e32acb73a314e663c2014e1ddefc019d5f434ff14ec89861d664/pycryptodomex-3.24.1.tar.gz", upload-time = 2026-10-11T19:26:49Z, size = 4934627, hashes = { sha256 = "09081666ffc599976c0b8b29caf2cf82212c0f05bed233c8f8ed53e4f6e1d356" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/cf/93/a954b7a8746980e31648943e29772aca0311d0d8a407a3adf5788083b693/pycryptodomex-3.24.1-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-10-11T19:26:17Z, size = 2280275, hashes = { sha256 = "9b94a8c647c1f80b4c82c7ac9642dda94a71abbb4efa29ad652c410ad7a39879" } }] + +[[packages]] +name = "pydantic" +version = "2.12.5" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", upload-time = 2025-11-26T15:11:46Z, size = 821591, hashes = { sha256 = "4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", upload-time = 2025-11-26T15:11:44Z, size = 463580, hashes = { sha256 = "e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d" } }] + +[[packages]] +name = "pydantic-core" +version = "2.41.5" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", upload-time = 2025-11-04T13:43:49Z, size = 460952, hashes = { sha256 = "08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-04T13:40:09Z, size = 2075366, hashes = { sha256 = "eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c" } }] + +[[packages]] +name = "pydantic-extra-types" +version = "2.11.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/66/71/dba38ee2651f84f7842206adbd2233d8bbdb59fb85e9fa14232486a8c471/pydantic_extra_types-2.11.1.tar.gz", upload-time = 2026-03-16T08:08:03Z, size = 172002, hashes = { sha256 = "46792d2307383859e923d8fcefa82108b1a141f8a9c0198982b3832ab5ef1049" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/17/c1/3226e6d7f5a4f736f38ac11a6fbb262d701889802595cdb0f53a885ac2e0/pydantic_extra_types-2.11.1-py3-none-any.whl", upload-time = 2026-03-16T08:08:02Z, size = 79526, hashes = { sha256 = "1722ea2bddae5628ace25f2aa685b69978ef533123e5638cfbddb999e0100ec1" } }] + +[[packages]] +name = "pygments" +version = "2.20.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", upload-time = 2026-03-29T13:29:33Z, size = 4955991, hashes = { sha256 = "6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", upload-time = 2026-03-29T13:29:30Z, size = 1231151, hashes = { sha256 = "81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176" } }] + +[[packages]] +name = "pyproject-hooks" +version = "1.2.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/e7/82/28175b2414effca1cdac8dc99f76d660e7a4fb0ceefa4b4ab8f5f6742925/pyproject_hooks-1.2.0.tar.gz", upload-time = 2024-09-29T09:24:13Z, size = 19228, hashes = { sha256 = "1e859bd5c40fae9448642dd871adf459e5e2084186e8d2c2a79a824c970da1f8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/bd/24/12818598c362d7f300f18e74db45963dbcb85150324092410c8b49405e42/pyproject_hooks-1.2.0-py3-none-any.whl", upload-time = 2024-09-29T09:24:11Z, size = 10216, hashes = { sha256 = "9e5c6bfa8dcc30091c74b0cf803c81fdd29d94f01992a7707bc97babb1141913" } }] + +[[packages]] +name = "python-dateutil" +version = "2.9.0.post0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", upload-time = 2024-03-01T18:36:20Z, size = 342432, hashes = { sha256 = "37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", upload-time = 2024-03-01T18:36:18Z, size = 229892, hashes = { sha256 = "a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427" } }] + +[[packages]] +name = "python-multipart" +version = "0.0.32" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/5b/42/55c32bb9b12693c092ad250a0e82edb5b31ddeda6eb772de5f308b3804ad/python_multipart-0.0.32.tar.gz", upload-time = 2026-06-04T16:18:58Z, size = 46881, hashes = { sha256 = "be54b7f3fa167bb83e4fcd936b887b708f4e57fe75911c02aebf53efaf8d938e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e1/04/e8135ebd1ad02c56ec633277529b2602ff99ff634be76cdba5744cf554fd/python_multipart-0.0.32-py3-none-any.whl", upload-time = 2026-06-04T16:18:57Z, size = 30042, hashes = { sha256 = "ff6d3f776f16878c894e52e107296ffc890e913c611b1a4ec6c44e2821fe2e23" } }] + +[[packages]] +name = "pytz" +version = "2026.1.post1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/56/db/b8721d71d945e6a8ac63c0fc900b2067181dbb50805958d4d4661cf7d277/pytz-2026.1.post1.tar.gz", upload-time = 2026-03-03T07:47:50Z, size = 321088, hashes = { sha256 = "3378dde6a0c3d26719182142c56e60c7f9af7e968076f31aae569d72a0358ee1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/10/99/781fe0c827be2742bcc775efefccb3b048a3a9c6ce9aec0cbf4a101677e5/pytz-2026.1.post1-py2.py3-none-any.whl", upload-time = 2026-03-03T07:47:49Z, size = 510489, hashes = { sha256 = "f2fd16142fda348286a75e1a524be810bb05d444e5a081f37f7affc635035f7a" } }] + +[[packages]] +name = "pyyaml" +version = "6.0.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", upload-time = 2025-09-25T21:33:16Z, size = 130960, hashes = { sha256 = "d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-09-25T21:32:16Z, size = 807870, hashes = { sha256 = "ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc" } }] + +[[packages]] +name = "pyzmq" +version = "27.2.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/e7/8d/5b3d5631c2f4b4b8862f64cd0c9eb777b5710eeb5125b4be8dd0a200a4c0/pyzmq-27.2.0.tar.gz", upload-time = 2026-08-20T19:08:21Z, size = 292316, hashes = { sha256 = "54d4259d1bfae24ecdb5ca79f7acc2eac6c286a02d6a0ae617797cb45f0726d3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/62/2c/d5828306f795e8d34676d266823b74e2101e0ad3760d12083de3e02abbb2/pyzmq-27.2.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-08-20T19:06:44Z, size = 872258, hashes = { sha256 = "dea74fd65f1fc5f7fe167916a473ebe6ed6174e5e5d9de11ea6583661be6cf43" } }] + +[[packages]] +name = "quack-kernels" +version = "0.6.5" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/5f/18/6c2a20d00dff254f154fb3b951f4e5a0377a60122c17385e5f08d5f5b5e1/quack_kernels-0.6.5.tar.gz", upload-time = 2026-09-11T05:08:20Z, size = 846876, hashes = { sha256 = "dd9405a4a6fa35fc3a5a18fe35b46a14b0bf7e3ad9fe2451903e355047ac471d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/73/d8/f5e56c38b286308d115a171e3c5c44f24e9d03980c3cfd22588df40261fa/quack_kernels-0.6.5-py3-none-any.whl", upload-time = 2026-09-11T05:08:19Z, size = 729615, hashes = { sha256 = "df1ddd31366c82eb9692fe087c671209189dcbde53c909c81a865d4ee66b158d" } }] + +[[packages]] +name = "referencing" +version = "0.37.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", upload-time = 2025-10-13T15:30:48Z, size = 78036, hashes = { sha256 = "44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", upload-time = 2025-10-13T15:30:47Z, size = 26766, hashes = { sha256 = "381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231" } }] + +[[packages]] +name = "regex" +version = "2026.4.4" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/cb/0e/3a246dbf05666918bd3664d9d787f84a9108f6f43cc953a077e4a7dfdb7e/regex-2026.4.4.tar.gz", upload-time = 2026-04-03T20:56:28Z, size = 416000, hashes = { sha256 = "e08270659717f6973523ce3afbafa53515c4dc5dcad637dc215b6fd50f689423" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/11/0e/a9f6f81013e0deaf559b25711623864970fe6a098314e374ccb1540a4152/regex-2026.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-03T20:53:51Z, size = 801126, hashes = { sha256 = "993f657a7c1c6ec51b5e0ba97c9817d06b84ea5fa8d82e43b9405de0defdc2b9" } }] + +[[packages]] +name = "requests" +version = "2.33.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/5f/a4/98b9c7c6428a668bf7e42ebb7c79d576a1c3c1e3ae2d47e674b468388871/requests-2.33.1.tar.gz", upload-time = 2026-03-30T16:09:15Z, size = 134120, hashes = { sha256 = "18817f8c57c6263968bc123d237e3b8b08ac046f5456bd1e307ee8f4250d3517" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", upload-time = 2026-03-30T16:09:13Z, size = 64947, hashes = { sha256 = "4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a" } }] + +[[packages]] +name = "rich" +version = "13.9.4" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", upload-time = 2024-11-01T16:43:57Z, size = 223149, hashes = { sha256 = "439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", upload-time = 2024-11-01T16:43:55Z, size = 242424, hashes = { sha256 = "6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90" } }] + +[[packages]] +name = "rpds-py" +version = "0.30.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", upload-time = 2025-11-30T20:24:38Z, size = 69469, hashes = { sha256 = "dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/60/1b/6f8f29f3f995c7ffdde46a626ddccd7c63aefc0efae881dc13b6e5d5bb16/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-30T20:22:27Z, size = 394080, hashes = { sha256 = "47f236970bccb2233267d89173d3ad2703cd36a0e2a6e92d0560d333871a3d23" } }] + +[[packages]] +name = "safetensors" +version = "0.7.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/29/9c/6e74567782559a63bd040a236edca26fd71bc7ba88de2ef35d75df3bca5e/safetensors-0.7.0.tar.gz", upload-time = 2025-11-19T15:18:43Z, size = 200878, hashes = { sha256 = "07663963b67e8bd9f0b8ad15bb9163606cd27cc5a1b96235a50d8369803b96b0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a0/60/429e9b1cb3fc651937727befe258ea24122d9663e4d5709a48c9cbfceecb/safetensors-0.7.0-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-19T15:18:33Z, size = 507152, hashes = { sha256 = "dac7252938f0696ddea46f5e855dd3138444e82236e3be475f54929f0c510d48" } }] + +[[packages]] +name = "scipy" +version = "1.17.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", upload-time = 2026-02-23T00:26:24Z, size = 30573822, hashes = { sha256 = "95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/01/8e/1e35281b8ab6d5d72ebe9911edcdffa3f36b04ed9d51dec6dd140396e220/scipy-1.17.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-02-23T00:18:49Z, size = 35235890, hashes = { sha256 = "02ae3b274fde71c5e92ac4d54bc06c42d80e399fec704383dcd99b301df37458" } }] + +[[packages]] +name = "sentencepiece" +version = "0.2.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/15/15/2e7a025fc62d764b151ae6d0f2a92f8081755ebe8d4a64099accc6f77ba6/sentencepiece-0.2.1.tar.gz", upload-time = 2025-08-12T07:00:51Z, size = 3228515, hashes = { sha256 = "8138cec27c2f2282f4a34d9a016e3374cd40e5c6e9cb335063db66a0a3b71fad" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/04/88/14f2f4a2b922d8b39be45bf63d79e6cd3a9b2f248b2fcb98a69b12af12f5/sentencepiece-0.2.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-08-12T06:59:46Z, size = 1387881, hashes = { sha256 = "0cdfecef430d985f1c2bcbfff3defd1d95dae876fbd0173376012d2d7d24044b" } }] + +[[packages]] +name = "setproctitle" +version = "1.3.8" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/49/b0/6b8a516c5a9e9630bd5293db78314ac012f690305fe93beadea388626efb/setproctitle-1.3.8.tar.gz", upload-time = 2026-10-01T21:09:27Z, size = 27214, hashes = { sha256 = "cafe209d064a6efb88cb45a03e97981ff8832802b2b5d009dde0197a3b7b41c8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/cb/21/4df9fbc0c72b9bca39b5d53eff6813dc1738a1562983e0c614054e9dbb8d/setproctitle-1.3.8-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2026-10-01T20:59:09Z, size = 32929, hashes = { sha256 = "4a765e0c80a2453480be27c4fc22ba1c0771867040c5f91e4221940d78a4abfb" } }] + +[[packages]] +name = "setuptools" +version = "83.0.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/34/26/f5d29e25ffdb535afef2d35cdb55b325298f96debd670da4c325e08d70f4/setuptools-83.0.0.tar.gz", upload-time = 2026-07-04T15:31:22Z, size = 1154254, hashes = { sha256 = "025bccbbf0fa05b6192bc64ae1e7b16e001fd6d6d4d5de03c97b1c1ade523bef" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5d/40/e1e72872c6354b306daef1703549e8e83b4d43cfea356311bf722a043752/setuptools-83.0.0-py3-none-any.whl", upload-time = 2026-07-04T15:31:20Z, size = 1008090, hashes = { sha256 = "29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3" } }] + +[[packages]] +name = "sglang" +version = "0.5.10.post1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/42/38/feb04f6478b90315606fcd62b798917e7fcee9f1d7d84b01cf477398045e/sglang-0.5.10.post1.tar.gz", upload-time = 2026-04-08T22:20:07Z, size = 4701855, hashes = { sha256 = "01f7adfe7cde85b238fb0e1bae4b31d494e19d1471cf35ff3c5489a02f9d2263" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/15/26/f6b6fc49166a716cf79787555118dfe6254786fa1d9c01be0fea17b4f578/sglang-0.5.10.post1-py3-none-any.whl", upload-time = 2026-04-08T22:20:05Z, size = 6064493, hashes = { sha256 = "a854a68b11caf6b4b55c241a44378a7cdede7ede325db85c955f131506703bc6" } }] + +[[packages]] +name = "sglang-kernel" +version = "0.4.1" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/97/26/d4a84be6587b57d20214cc2ee1e7f41b7e3336df357c45a833f25b1f1abf/sglang_kernel-0.4.1-cp310-abi3-manylinux2014_x86_64.whl", upload-time = 2026-04-03T09:28:02Z, size = 352149358, hashes = { sha256 = "64ab5df34264cdffc36e25fee429dcafe2e204cae73cc1f9736a4e5ab97aa206" } }] + +[[packages]] +name = "shellingham" +version = "1.5.4" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", upload-time = 2023-10-24T04:13:40Z, size = 10310, hashes = { sha256 = "8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", upload-time = 2023-10-24T04:13:38Z, size = 9755, hashes = { sha256 = "7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686" } }] + +[[packages]] +name = "six" +version = "1.17.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", upload-time = 2024-12-04T17:35:28Z, size = 34031, hashes = { sha256 = "ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", upload-time = 2024-12-04T17:35:26Z, size = 11050, hashes = { sha256 = "4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274" } }] + +[[packages]] +name = "smg-grpc-proto" +version = "0.4.10" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/70/c4/e7fd91bf161fcaeb9c19e5fba73e54f7501bd310078d644700e627c4d7f9/smg_grpc_proto-0.4.10.tar.gz", upload-time = 2026-06-11T16:10:05Z, size = 19304, hashes = { sha256 = "5415618d252e5a2b43d1dbbd2c1eae305760070dd24735308140aed06a7486be" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/67/0d/d2f57ac38d2ecc9593ade6ee99953c2b2ea27e10e9532f69e3c47d2528dc/smg_grpc_proto-0.4.10-py3-none-any.whl", upload-time = 2026-06-11T16:10:04Z, size = 81122, hashes = { sha256 = "cf62b930b541ea117696d0decc2f3bd9f1f8811d066a37340e53adce3a535ccc" } }] + +[[packages]] +name = "smg-grpc-servicer" +version = "0.5.6" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/38/fa/fde2418c3e651bb20feba30ee13718cb4ac786a23c34969c5c7a9b0959ec/smg_grpc_servicer-0.5.6.tar.gz", upload-time = 2026-06-17T15:27:30Z, size = 88730, hashes = { sha256 = "b8e5f06a57537689888f67ea7a7d5b1f080038a3c8aada129098529245d185c0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/15/36/2b08a588c2b869ad072882883be4f31349beac6468b93db03f1608505796/smg_grpc_servicer-0.5.6-py3-none-any.whl", upload-time = 2026-06-17T15:27:29Z, size = 91597, hashes = { sha256 = "d583be1c1b6f5fa790b735feca21c870120d37d8b4d79b4641a4bf9c34203d97" } }] + +[[packages]] +name = "sniffio" +version = "1.3.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", upload-time = 2024-02-25T23:20:04Z, size = 20372, hashes = { sha256 = "f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", upload-time = 2024-02-25T23:20:01Z, size = 10235, hashes = { sha256 = "2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2" } }] + +[[packages]] +name = "soundfile" +version = "0.13.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/e1/41/9b873a8c055582859b239be17902a85339bec6a30ad162f98c9b0288a2cc/soundfile-0.13.1.tar.gz", upload-time = 2025-01-25T09:17:04Z, size = 46156, hashes = { sha256 = "b2c68dab1e30297317080a5b43df57e302584c49e2942defdde0acccc53f0e5b" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/28/e2a36573ccbcf3d57c00626a21fe51989380636e821b341d36ccca0c1c3a/soundfile-0.13.1-py2.py3-none-any.whl", upload-time = 2025-01-25T09:16:44Z, size = 25751, hashes = { sha256 = "a23c717560da2cf4c7b5ae1142514e0fd82d6bbd9dfc93a50423447142f2c445" } }, + { url = "https://files.pythonhosted.org/packages/57/5e/70bdd9579b35003a489fc850b5047beeda26328053ebadc1fb60f320f7db/soundfile-0.13.1-py2.py3-none-manylinux_2_28_x86_64.whl", upload-time = 2025-01-25T09:16:54Z, size = 1313646, hashes = { sha256 = "03267c4e493315294834a0870f31dbb3b28a95561b80b134f0bd3cf2d5f0e618" } }, +] + +[[packages]] +name = "stack-data" +version = "0.6.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", upload-time = 2023-09-30T13:58:05Z, size = 44707, hashes = { sha256 = "836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", upload-time = 2023-09-30T13:58:03Z, size = 24521, hashes = { sha256 = "d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695" } }] + +[[packages]] +name = "starlette" +version = "1.3.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/eb/e3/7c1dc7381d9f8ab7d854328ebfa884e62cb3f3d8549ddfd37c7814f42afa/starlette-1.3.1.tar.gz", upload-time = 2026-06-12T09:23:11Z, size = 2703240, hashes = { sha256 = "05d0213193f2fbaae60e2ecb593b4add4262ad4e46536b54abe36f11a71724e0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ec/bb/2799cc2ede3ed41131f8975621e7213dfc7ef4acbbaadfa440f32500c370/starlette-1.3.1-py3-none-any.whl", upload-time = 2026-06-12T09:23:10Z, size = 73632, hashes = { sha256 = "c7372aae11c3c3f26a42df7bd626cec2f47d03483d261d369516a615a53714c6" } }] + +[[packages]] +name = "sympy" +version = "1.14.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", upload-time = 2025-04-27T18:05:01Z, size = 7793921, hashes = { sha256 = "d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", upload-time = 2025-04-27T18:04:59Z, size = 6299353, hashes = { sha256 = "e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5" } }] + +[[packages]] +name = "tabulate" +version = "0.10.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/46/58/8c37dea7bbf769b20d58e7ace7e5edfe65b849442b00ffcdd56be88697c6/tabulate-0.10.0.tar.gz", upload-time = 2026-03-04T18:55:34Z, size = 91754, hashes = { sha256 = "e2cfde8f79420f6deeffdeda9aaec3b6bc5abce947655d17ac662b126e48a60d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/99/55/db07de81b5c630da5cbf5c7df646580ca26dfaefa593667fc6f2fe016d2e/tabulate-0.10.0-py3-none-any.whl", upload-time = 2026-03-04T18:55:31Z, size = 39814, hashes = { sha256 = "f0b0622e567335c8fabaaa659f1b33bcb6ddfe2e496071b743aa113f8774f2d3" } }] + +[[packages]] +name = "tiktoken" +version = "0.12.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/7d/ab/4d017d0f76ec3171d469d80fc03dfbb4e48a4bcaddaa831b31d526f05edc/tiktoken-0.12.0.tar.gz", upload-time = 2025-10-06T20:22:45Z, size = 37806, hashes = { sha256 = "b18ba7ee2b093863978fcb14f74b3707cdc8d4d4d3836853ce7ec60772139931" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f4/90/3dae6cc5436137ebd38944d396b5849e167896fc2073da643a49f372dc4f/tiktoken-0.12.0-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2025-10-06T20:21:56Z, size = 1152665, hashes = { sha256 = "edde1ec917dfd21c1f2f8046b86348b0f54a2c0547f68149d8600859598769ad" } }] + +[[packages]] +name = "timm" +version = "1.0.16" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/94/f6/4d7a8c261341fa6ad281920618739f2a650f41043afcedb570f24e99a776/timm-1.0.16.tar.gz", upload-time = 2025-06-26T17:09:44Z, size = 2339999, hashes = { sha256 = "a3b8130dd2cb8dc3b9f5e3d09ab6d677a6315a8695fd5264eb6d52a4a46c1044" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3b/14/10d0ea58a7580b8bd7c8d69420b3dc3a1deb890d4ff297deca9717689598/timm-1.0.16-py3-none-any.whl", upload-time = 2025-06-26T17:09:42Z, size = 2485733, hashes = { sha256 = "a640e58f4ae41e0445517d1133b34be75bb2bd49cdb830d739925ce1fb7d2526" } }] + +[[packages]] +name = "tokenizers" +version = "0.22.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/73/6f/f80cfef4a312e1fb34baf7d85c72d4411afde10978d4657f8cdd811d3ccc/tokenizers-0.22.2.tar.gz", upload-time = 2026-01-05T10:45:15Z, size = 372115, hashes = { sha256 = "473b83b915e547aa366d1eee11806deaf419e17be16310ac0a14077f1e28f917" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2e/76/932be4b50ef6ccedf9d3c6639b056a967a86258c6d9200643f01269211ca/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-01-05T10:40:58Z, size = 3274982, hashes = { sha256 = "369cc9fc8cc10cb24143873a0d95438bb8ee257bb80c71989e3ee290e8d72c67" } }] + +[[packages]] +name = "torch" +version = "2.9.1+cpu" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://download-r2.pytorch.org/whl/cpu/torch-2.9.1%2Bcpu-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-01-23T15:13:04Z, hashes = { sha256 = "7417d8c565f219d3455654cb431c6d892a3eb40246055e14d645422de13b9ea1" } }] + +[[packages]] +name = "torch-c-dlpack-ext" +version = "0.1.5" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/37/de/921b6491efce5c389a5ef9bbed3d2d6660005840dae488124173180859ab/torch_c_dlpack_ext-0.1.5.tar.gz", upload-time = 2026-01-12T11:25:08Z, size = 12913, hashes = { sha256 = "d06f0357d575d22a168cc77acb9020fc4bae30968ceb6718a055dcbe92bacabe" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e2/79/a914539b4785f3e44f891aa012a886edb8bc10fe081c440981c57543ce21/torch_c_dlpack_ext-0.1.5-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-01-12T11:24:48Z, size = 897846, hashes = { sha256 = "e6f9da4bb9af70e27facc777458be62e10dbbbddda7672d16138db0553c5a524" } }] + +[[packages]] +name = "torch-memory-saver" +version = "0.0.9" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/28/6c/21dfda5d31afb71f52cedff52370acbb8290485b3f0fee6816a15a3d08f1/torch_memory_saver-0.0.9.tar.gz", upload-time = 2025-10-18T02:10:18Z, size = 14220, hashes = { sha256 = "3bbf76391fb16870b1b0df279fc281c8a05ef8f8809400b309b0a8240e8ee5ba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3a/35/b22df9e730d8444d62445a594421992781c7fad271325d41656d8a32d103/torch_memory_saver-0.0.9-cp39-abi3-manylinux2014_x86_64.whl", upload-time = 2025-10-18T02:10:16Z, size = 488722, hashes = { sha256 = "0cf26332993649f8ea1b95d7307dfba3a95ee6cee53de84a3e561fb21752b584" } }] + +[[packages]] +name = "torchao" +version = "0.9.0+cpu" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://download.pytorch.org/whl/cpu/torchao-0.9.0%2Bcpu-py3-none-any.whl", upload-time = 2025-02-28T14:07:42Z, hashes = { sha256 = "69a488afe0cc82048dfd1f143fd66e26afdcbe7015d3bf054060d377ff4d6d63" } }] + +[[packages]] +name = "torchaudio" +version = "2.9.1+cpu" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://download-r2.pytorch.org/whl/cpu/torchaudio-2.9.1%2Bcpu-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2025-11-11T19:16:58Z, hashes = { sha256 = "43cf20a2965cf081945c91d2dc8844377e5e3f1b172c0d0c18399ca3ecf1f899" } }] + +[[packages]] +name = "torchcodec" +version = "0.9.1" +marker = "platform_machine != 'aarch64' and platform_machine != 'arm64' and platform_machine != 'armv7l' and sys_platform == 'linux'" +wheels = [{ url = "https://download.pytorch.org/whl/cpu/torchcodec-0.9.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-01-26T17:11:16Z, hashes = { sha256 = "a50568ce73b70395d113833fb07394c223f5546ef5d4fafe0fdcd91627fca270" } }] + +[[packages]] +name = "torchvision" +version = "0.24.1+cpu" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://download-r2.pytorch.org/whl/cpu/torchvision-0.24.1%2Bcpu-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2025-11-15T18:12:45Z, hashes = { sha256 = "48ff40694812292f1f75cddb517f9eef224a2e8388798a0aa191e27bf159fc5d" } }] + +[[packages]] +name = "tqdm" +version = "4.67.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/09/a9/6ba95a270c6f1fbcd8dac228323f2777d886cb206987444e4bce66338dd4/tqdm-4.67.3.tar.gz", upload-time = 2026-02-03T17:35:53Z, size = 169598, hashes = { sha256 = "7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", upload-time = 2026-02-03T17:35:50Z, size = 78374, hashes = { sha256 = "ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf" } }] + +[[packages]] +name = "traitlets" +version = "5.14.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", upload-time = 2024-04-19T11:11:49Z, size = 161621, hashes = { sha256 = "9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", upload-time = 2024-04-19T11:11:46Z, size = 85359, hashes = { sha256 = "b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f" } }] + +[[packages]] +name = "transformers" +version = "5.3.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/fc/1a/70e830d53ecc96ce69cfa8de38f163712d2b43ac52fbd743f39f56025c31/transformers-5.3.0.tar.gz", upload-time = 2026-03-04T17:41:46Z, size = 8830831, hashes = { sha256 = "009555b364029da9e2946d41f1c5de9f15e6b1df46b189b7293f33a161b9c557" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b8/88/ae8320064e32679a5429a2c9ebbc05c2bf32cefb6e076f9b07f6d685a9b4/transformers-5.3.0-py3-none-any.whl", upload-time = 2026-03-04T17:41:42Z, size = 10661827, hashes = { sha256 = "50ac8c89c3c7033444fb3f9f53138096b997ebb70d4b5e50a2e810bf12d3d29a" } }] + +[[packages]] +name = "triton" +version = "3.5.1" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://download-r2.pytorch.org/whl/triton-3.5.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-01-22T23:20:53Z, hashes = { sha256 = "8ce9bcedbd12b393d1309fb899e06818624c7e7765c5231ea5749850015c74d8" } }] + +[[packages]] +name = "truststore" +version = "0.10.5" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ee/9f/c5201d42a484c061e528825fc8e2d565f5abd50a4ced6fb7d29c4ec99b2b/truststore-0.10.5.tar.gz", upload-time = 2026-10-12T22:27:31Z, size = 28091, hashes = { sha256 = "30d36967ccaded5cbb38d602c433f53600036c79d502f4533a49b60a03bbefcd" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/51/e9/3a7820be2bb0fe53b6bc9c3be26d3d1158004e4c3ab953aa6840b955b1e9/truststore-0.10.5-py3-none-any.whl", upload-time = 2026-10-12T22:27:30Z, size = 19017, hashes = { sha256 = "9aaaedaefaf06d8b206278cf8b5012bc897f485a874503501e12d776df78951c" } }] + +[[packages]] +name = "typer" +version = "0.21.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/f2/1e/a27cc02a0cd715118c71fa2aef2c687fdefc3c28d90fd0dd789c5118154c/typer-0.21.2.tar.gz", upload-time = 2026-02-10T19:33:46Z, size = 120426, hashes = { sha256 = "1abd95a3b675e17ff61b0838ac637fe9478d446d62ad17fa4bb81ea57cc54028" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b8/cc/d59f893fbdfb5f58770c05febfc4086a46875f1084453621c35605cec946/typer-0.21.2-py3-none-any.whl", upload-time = 2026-02-10T19:33:48Z, size = 56728, hashes = { sha256 = "c3d8de54d00347ef90b82131ca946274f017cffb46683ae3883c360fa958f55c" } }] + +[[packages]] +name = "typing-extensions" +version = "4.15.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", upload-time = 2025-08-25T13:49:26Z, size = 109391, hashes = { sha256 = "0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", upload-time = 2025-08-25T13:49:24Z, size = 44614, hashes = { sha256 = "f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548" } }] + +[[packages]] +name = "typing-inspection" +version = "0.4.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", upload-time = 2025-10-01T02:14:41Z, size = 75949, hashes = { sha256 = "ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", upload-time = 2025-10-01T02:14:40Z, size = 14611, hashes = { sha256 = "4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7" } }] + +[[packages]] +name = "tzdata" +version = "2026.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ba/19/1b9b0e29f30c6d35cb345486df41110984ea67ae69dddbc0e8a100999493/tzdata-2026.2.tar.gz", upload-time = 2026-04-24T15:22:08Z, size = 198254, hashes = { sha256 = "9173fde7d80d9018e02a662e168e5a2d04f87c41ea174b139fbef642eda62d10" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ce/e4/dccd7f47c4b64213ac01ef921a1337ee6e30e8c6466046018326977efd95/tzdata-2026.2-py2.py3-none-any.whl", upload-time = 2026-04-24T15:22:05Z, size = 349321, hashes = { sha256 = "bbe9af844f658da81a5f95019480da3a89415801f6cc966806612cc7169bffe7" } }] + +[[packages]] +name = "urllib3" +version = "2.7.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", upload-time = 2026-05-07T16:13:18Z, size = 433602, hashes = { sha256 = "231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", upload-time = 2026-05-07T16:13:17Z, size = 131087, hashes = { sha256 = "9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897" } }] + +[[packages]] +name = "uvicorn" +version = "0.46.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/1f/93/041fca8274050e40e6791f267d82e0e2e27dd165627bd640d3e0e378d877/uvicorn-0.46.0.tar.gz", upload-time = 2026-04-23T07:16:00Z, size = 88758, hashes = { sha256 = "fb9da0926999cc6cb22dc7cd71a94a632f078e6ae47ff683c5c420750fb7413d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/31/a3/5b1562db76a5a488274b2332a97199b32d0442aca0ed193697fd47786316/uvicorn-0.46.0-py3-none-any.whl", upload-time = 2026-04-23T07:15:58Z, size = 70926, hashes = { sha256 = "bbebbcbed972d162afca128605223022bedd345b7bc7855ce66deb31487a9048" } }] + +[[packages]] +name = "uvloop" +version = "0.22.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", upload-time = 2025-10-16T22:17:19Z, size = 2443250, hashes = { sha256 = "6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-10-16T22:16:32Z, size = 4426307, hashes = { sha256 = "7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4" } }] + +[[packages]] +name = "watchfiles" +version = "1.1.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8869df9b2a2d6c59d79220a4db37679e74f807c559ffe5265e08b227a210/watchfiles-1.1.1.tar.gz", upload-time = 2025-10-14T15:06:21Z, size = 94440, hashes = { sha256 = "a173cb5c16c4f40ab19cecf48a534c409f7ea983ab8fed0741304a1c0a31b3f2" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/cf/68/5707da262a119fb06fbe214d82dd1fe4a6f4af32d2d14de368d0349eb52a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-10-14T15:04:55Z, size = 456812, hashes = { sha256 = "1db5d7ae38ff20153d542460752ff397fcf5c96090c1230803713cf3147a6803" } }] + +[[packages]] +name = "wcwidth" +version = "0.6.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/35/a2/8e3becb46433538a38726c948d3399905a4c7cabd0df578ede5dc51f0ec2/wcwidth-0.6.0.tar.gz", upload-time = 2026-02-06T19:19:40Z, size = 159684, hashes = { sha256 = "cdc4e4262d6ef9a1a57e018384cbeb1208d8abbc64176027e2c2455c81313159" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/68/5a/199c59e0a824a3db2b89c5d2dade7ab5f9624dbf6448dc291b46d5ec94d3/wcwidth-0.6.0-py3-none-any.whl", upload-time = 2026-02-06T19:19:39Z, size = 94189, hashes = { sha256 = "1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad" } }] + +[[packages]] +name = "xgrammar" +version = "0.1.32" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/99/6a/d51b44fc0b43e2d4adae42b6a17fe9ee49e177d6d768be739ed7dec7b57e/xgrammar-0.1.32.tar.gz", upload-time = 2026-03-04T12:01:52Z, size = 2365047, hashes = { sha256 = "5d424d52779ca2d3ccaf72f2289d6519efe308e933d0d3fc3c292c780825bb12" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/69/62/65e664d861cdadf2d788c03dd8fe67f1faaa7bd4bd2317a2ab850aebee20/xgrammar-0.1.32-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-04T12:00:50Z, size = 37711100, hashes = { sha256 = "f96c7a4fcbd68e18b13cb3b6ed5d24b5326b256933f476bdaf2cc8e609c228db" } }] + +[[packages]] +name = "xxhash" +version = "3.7.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/24/2f/e183a1b407002f5af81822bee18b61cdb94b8670208ef34734d8d2b8ebe9/xxhash-3.7.0.tar.gz", upload-time = 2026-04-25T11:10:32Z, size = 82022, hashes = { sha256 = "6cc4eefbb542a5d6ffd6d70ea9c502957c925e800f998c5630ecc809d6702bae" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/40/37/558f5a90c0672fc9b4402dc25d87ac5b7406616e8969430c9ca4e52ee74d/xxhash-3.7.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-25T11:06:31Z, size = 193932, hashes = { sha256 = "13805f0461cba0a857924e70ff91ae6d52d2598f79a884e788db80532614a4a1" } }] + +[[packages]] +name = "yarl" +version = "1.23.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", upload-time = 2026-03-01T22:07:53Z, size = 194676, hashes = { sha256 = "53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-01T22:05:23Z, size = 100132, hashes = { sha256 = "a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51" } }, + { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", upload-time = 2026-03-01T22:07:51Z, size = 48288, hashes = { sha256 = "a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f" } }, +] + +[[packages]] +name = "zipp" +version = "3.23.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/30/21/093488dfc7cc8964ded15ab726fad40f25fd3d788fd741cc1c5a17d78ee8/zipp-3.23.1.tar.gz", upload-time = 2026-04-13T23:21:46Z, size = 25965, hashes = { sha256 = "32120e378d32cd9714ad503c1d024619063ec28aad2248dc6672ad13edfa5110" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/08/8a/0861bec20485572fbddf3dfba2910e38fe249796cb73ecdeb74e07eeb8d3/zipp-3.23.1-py3-none-any.whl", upload-time = 2026-04-13T23:21:45Z, size = 10378, hashes = { sha256 = "0b3596c50a5c700c9cb40ba8d86d9f2cc4807e9bedb06bcdf7fac85633e444dc" } }] diff --git a/packages/sie_server/bundle-locks/cpu-sglang-arm64/manifest.json b/packages/sie_server/bundle-locks/cpu-sglang-arm64/manifest.json new file mode 100644 index 000000000..0877a9969 --- /dev/null +++ b/packages/sie_server/bundle-locks/cpu-sglang-arm64/manifest.json @@ -0,0 +1,44 @@ +{ + "completed_artifact_hashes": [ + { + "bytes": 7532, + "sha256": "926acba49b2c0a0374c61b7c98f337c085199cf51cdfe4d6423c4129c20547a7", + "url": "https://download.pytorch.org/whl/cuda_python-12.9.0-py3-none-any.whl" + }, + { + "bytes": 134899, + "sha256": "85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", + "url": "https://download.pytorch.org/whl/jinja2-3.1.6-py3-none-any.whl" + }, + { + "bytes": 24332, + "sha256": "3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", + "url": "https://download.pytorch.org/whl/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl" + } + ], + "exceptions_sha256": "a4235ada14b5015a0a836124fe6ab4778dc9b954dd3e3f4fd8abcf1660c1e3f2", + "exclude_newer": "2026-10-18T00:00:00Z", + "indexes": [ + "--default-index", + "https://pypi.org/simple", + "--index", + "https://download.pytorch.org/whl/cpu", + "--index-strategy", + "unsafe-best-match" + ], + "inputs": { + "requirements_sha256": "943a74a3f4565e0b7b3bab2f87080526604d1e3923a39ed287d444630d33b94c", + "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" + }, + "lock_sha256": "6680e1454e1fe6bf0d4aa7b6647b6fb8c948d2eff9646a51cbdcaac56eff09fb", + "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "schema_version": 1, + "target": { + "architecture": "arm64", + "bundle": "sglang", + "platform": "cpu", + "python_platform": "aarch64-manylinux_2_35", + "python_version": "3.12" + }, + "uv_version": "0.9.28" +} diff --git a/packages/sie_server/bundle-locks/cpu-sglang-arm64/pylock.toml b/packages/sie_server/bundle-locks/cpu-sglang-arm64/pylock.toml new file mode 100644 index 000000000..7211ee491 --- /dev/null +++ b/packages/sie_server/bundle-locks/cpu-sglang-arm64/pylock.toml @@ -0,0 +1,1224 @@ +lock-version = "1.0" +created-by = "uv" +requires-python = ">=3.12" + +[[packages]] +name = "aiohappyeyeballs" +version = "2.6.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", upload-time = 2025-03-12T01:42:48Z, size = 22760, hashes = { sha256 = "c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", upload-time = 2025-03-12T01:42:47Z, size = 15265, hashes = { sha256 = "f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8" } }] + +[[packages]] +name = "aiohttp" +version = "3.14.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/58/d9/22ce5786ac0c1653ae8b6c23bded02c1686d11f0dbb45b31ce128e0df985/aiohttp-3.14.3.tar.gz", upload-time = 2026-07-23T01:57:27Z, size = 7971213, hashes = { sha256 = "9491196535a88924a60afd5b5f434b5b203b6cc616250878dbdb223a8f7844bc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/54/b9/42e74c46b7b7c794b995bbc1f573fb48950c38b19d8600c62a6804ee2d67/aiohttp-3.14.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-07-23T01:53:59Z, size = 1765282, hashes = { sha256 = "f631fe87a6f30df5fbe6d79640b25e4cffb38c31c7fb6f10871517b84b0f8c1a" } }] + +[[packages]] +name = "aiosignal" +version = "1.4.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", upload-time = 2025-07-03T22:54:43Z, size = 25007, hashes = { sha256 = "f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", upload-time = 2025-07-03T22:54:42Z, size = 7490, hashes = { sha256 = "053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e" } }] + +[[packages]] +name = "airportsdata" +version = "20260905" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/a5/c2/69ec4b992746c4c7b076a7afffb11fc64267d684ed0cd3db00035f0f682b/airportsdata-20260905.tar.gz", upload-time = 2026-09-05T06:02:21Z, size = 929470, hashes = { sha256 = "a7e17469458ca356a5ca9971f49864b934a559d43e1587e19219cb981d364c45" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/45/f8/65e9d476f84bb60ac7ff1fe525acdd60fe6b4b585ae6f074c947c6ad0fc1/airportsdata-20260905-py3-none-any.whl", upload-time = 2026-09-05T06:02:19Z, size = 931164, hashes = { sha256 = "d7eaa9a57d373b0adaaae0d52da2af0bb0edf73f7baa170f7c415d3342bf4868" } }] + +[[packages]] +name = "annotated-doc" +version = "0.0.4" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", upload-time = 2025-11-10T22:07:42Z, size = 7288, hashes = { sha256 = "fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", upload-time = 2025-11-10T22:07:40Z, size = 5303, hashes = { sha256 = "571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320" } }] + +[[packages]] +name = "annotated-types" +version = "0.7.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", upload-time = 2024-05-20T21:33:25Z, size = 16081, hashes = { sha256 = "aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", upload-time = 2024-05-20T21:33:24Z, size = 13643, hashes = { sha256 = "1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53" } }] + +[[packages]] +name = "anthropic" +version = "1.15.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/10/37/5a2a4316df8babd28f096477a707cd75f240b4264c97fb128c32375105d6/anthropic-1.15.0.tar.gz", upload-time = 2026-10-15T19:45:34Z, size = 1726101, hashes = { sha256 = "90caa9df83e2fc8bddb4ddeb83b7191bce255f635c03eae055deec521741df08" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d1/65/54437e7edea49a3be9ef56f6b5965999bfdc52b9dadc9b448124ca51a594/anthropic-1.15.0-py3-none-any.whl", upload-time = 2026-10-15T19:45:32Z, size = 2047755, hashes = { sha256 = "10189a7993c5c71a0a2d4bb80020ca6a2fd27679f51e627405da37251d15ff49" } }] + +[[packages]] +name = "anyio" +version = "4.14.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/61/cc/a381afa6efea9f496eff839d4a6a1aed3bfafc7b3ab4b0d1b243a12573dd/anyio-4.14.2.tar.gz", upload-time = 2026-07-12T20:29:07Z, size = 260176, hashes = { sha256 = "cfa139f3ed1a23ee8f88a145ddb5ac7605b8bbfd8592baacd7ce3d8bb4313c7f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/da/35/f2287558c17e29fafc8ef3daf819bb9834061cfa43bff8014f7df7f63bdc/anyio-4.14.2-py3-none-any.whl", upload-time = 2026-07-12T20:29:05Z, size = 125813, hashes = { sha256 = "9f505dda5ac9f0c8309b5e8bd445a8c2bf7246f3ce950121e45ea15bc41d1494" } }] + +[[packages]] +name = "apache-tvm-ffi" +version = "0.1.14.post1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ed/50/2b9d308f34843b99e763ac7d510ba6400dbb3e86b3f04fd206be0dc9cd46/apache_tvm_ffi-0.1.14.post1.tar.gz", upload-time = 2026-09-24T07:52:45Z, size = 3232883, hashes = { sha256 = "8ebd92dc97cdcb22ab494aa252c868ddd6a9b6c89be69188562e0f236652429f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/35/16/47b9f8c06df3ee1eda3f0cef025bd94e70dcf37fc58296852a175512956b/apache_tvm_ffi-0.1.14.post1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-09-24T07:52:12Z, size = 3051062, hashes = { sha256 = "3fd2255a2e363a40c51ec1eeedb1110a2c74e443f95ae351ee5a81b5ff6808cf" } }] + +[[packages]] +name = "asttokens" +version = "3.0.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/be/a5/8e3f9b6771b0b408517c82d97aed8f2036509bc247d46114925e32fe33f0/asttokens-3.0.1.tar.gz", upload-time = 2025-11-15T16:43:48Z, size = 62308, hashes = { sha256 = "71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d2/39/e7eaf1799466a4aef85b6a4fe7bd175ad2b1c6345066aa33f1f58d4b18d0/asttokens-3.0.1-py3-none-any.whl", upload-time = 2025-11-15T16:43:16Z, size = 27047, hashes = { sha256 = "15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a" } }] + +[[packages]] +name = "attrs" +version = "26.1.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", upload-time = 2026-03-19T14:22:25Z, size = 952055, hashes = { sha256 = "d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", upload-time = 2026-03-19T14:22:23Z, size = 67548, hashes = { sha256 = "c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309" } }] + +[[packages]] +name = "av" +version = "19.0.1" +marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'arm64' and sys_platform == 'linux') or (platform_machine == 'armv7l' and sys_platform == 'linux')" +sdist = { url = "https://files.pythonhosted.org/packages/90/bc/a2a40e503250fe5d4174471911828f31658864eb69a8a7cb960c715e17b7/av-19.0.1.tar.gz", upload-time = 2026-10-03T01:48:28Z, size = 4274648, hashes = { sha256 = "08674930eaf1af78a3ed8f93d3ba49383323b3a867e84349d9c399e36f7497da" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/10/4b/61f138fcf21e7bb50655ed21dd7fdc7a296baf72ea3c7ad8e89cb00b69c1/av-19.0.1-cp312-abi3-manylinux_2_28_aarch64.whl", upload-time = 2026-10-03T01:47:29Z, size = 32676941, hashes = { sha256 = "437d4c0d5a7d771f2c3af84cd28e6aac6e173851116c60b53e81dbf1eebe4eab" } }] + +[[packages]] +name = "blobfile" +version = "3.0.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/9d/a9/a34e8153b0203d9060ff7aa5dfcd175e161117949697a83c4cc003b523ff/blobfile-3.0.0.tar.gz", upload-time = 2024-08-27T00:02:53Z, size = 77863, hashes = { sha256 = "32ec777414de7bb2a76ca812a838f0d33327ca28ae844a253503cde625cdf2f1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ed/4d/1392562369b1139e741b30d624f09fe7091d17dd5579fae5732f044b12bb/blobfile-3.0.0-py3-none-any.whl", upload-time = 2024-08-27T00:02:51Z, size = 75413, hashes = { sha256 = "48ecc3307e622804bd8fe13bf6f40e6463c4439eba7a1f9ad49fd78aa63cc658" } }] + +[[packages]] +name = "build" +version = "1.4.4" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/02/ec/bf5ae0a7e5ab57abe8aabdd0759c971883895d1a20c49ae99f8146840c3c/build-1.4.4.tar.gz", upload-time = 2026-04-22T20:53:44Z, size = 89220, hashes = { sha256 = "f832ae053061f3fb524af812dc94b8b84bac6880cd587630e3b5d91a6a9c1703" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/fa/88/6764e7a109dd84294850741501145da90d13cdeac9d4e614929464a37420/build-1.4.4-py3-none-any.whl", upload-time = 2026-04-22T20:53:43Z, size = 25921, hashes = { sha256 = "8c3f48a6090b39edec1a273d2d57949aaf13723b01e02f9d518396887519f64d" } }] + +[[packages]] +name = "certifi" +version = "2026.4.22" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/25/ee/6caf7a40c36a1220410afe15a1cc64993a1f864871f698c0f93acb72842a/certifi-2026.4.22.tar.gz", upload-time = 2026-04-22T11:26:11Z, size = 137077, hashes = { sha256 = "8d455352a37b71bf76a79caa83a3d6c25afee4a385d632127b6afb3963f1c580" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/22/30/7cd8fdcdfbc5b869528b079bfb76dcdf6056b1a2097a662e5e8c04f42965/certifi-2026.4.22-py3-none-any.whl", upload-time = 2026-04-22T11:26:09Z, size = 135707, hashes = { sha256 = "3cb2210c8f88ba2318d29b0388d1023c8492ff72ecdde4ebdaddbb13a31b1c4a" } }] + +[[packages]] +name = "cffi" +version = "2.0.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", upload-time = 2025-09-08T23:24:04Z, size = 523588, hashes = { sha256 = "44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", upload-time = 2025-09-08T23:22:48Z, size = 220097, hashes = { sha256 = "b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062" } }] + +[[packages]] +name = "charset-normalizer" +version = "3.4.7" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", upload-time = 2026-04-02T09:28:39Z, size = 144271, hashes = { sha256 = "ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f8/e3/0fadc706008ac9d7b9b5be6dc767c05f9d3e5df51744ce4cc9605de7b9f4/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-04-02T09:26:25Z, size = 208061, hashes = { sha256 = "6178f72c5508bfc5fd446a5905e698c6212932f25bcdd4b47a757a50605a90e2" } }, + { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", upload-time = 2026-04-02T09:28:37Z, size = 61958, hashes = { sha256 = "3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d" } }, +] + +[[packages]] +name = "click" +version = "8.1.8" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", upload-time = 2024-12-21T18:38:44Z, size = 226593, hashes = { sha256 = "ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", upload-time = 2024-12-21T18:38:41Z, size = 98188, hashes = { sha256 = "63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2" } }] + +[[packages]] +name = "cloudpickle" +version = "3.1.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/27/fb/576f067976d320f5f0114a8d9fa1215425441bb35627b1993e5afd8111e5/cloudpickle-3.1.2.tar.gz", upload-time = 2025-11-03T09:25:26Z, size = 22330, hashes = { sha256 = "7fda9eb655c9c230dab534f1983763de5835249750e85fbcef43aaa30a9a2414" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl", upload-time = 2025-11-03T09:25:25Z, size = 22228, hashes = { sha256 = "9acb47f6afd73f60dc1df93bb801b472f05ff42fa6c84167d25cb206be1fbf4a" } }] + +[[packages]] +name = "compressed-tensors" +version = "0.15.0.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/41/1b/c3c4a98ec5f2727656336f07a0c35862195c310d8eb0b2fa5b4be6848680/compressed_tensors-0.15.0.1.tar.gz", upload-time = 2026-04-10T14:23:54Z, size = 229412, hashes = { sha256 = "a8e93054e8a5ec49c980b09ed36c4c1249b4a8ee167920a8e461c4da26e78d99" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a8/52/93833dc1610e017ac5b7dcd59b8304d8ef67d1114c2d124e728a2cbbea12/compressed_tensors-0.15.0.1-py3-none-any.whl", upload-time = 2026-04-10T14:23:53Z, size = 194260, hashes = { sha256 = "e1b1f322e82e475715e242bad46925a304ea8e5c98b5055a15b8eb22fb6bfea9" } }] + +[[packages]] +name = "cryptography" +version = "50.0.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/de/41/6cbdcf9142d00fe82836fbb51e503e58088575cf7a0fe1dbff6695bf0840/cryptography-50.0.0.tar.gz", upload-time = 2026-07-31T14:25:10Z, size = 880201, hashes = { sha256 = "eeac2acb5a20ed25e0ad6d1df9891a520b78b404266b6d11778f25d5d691a6c9" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/57/ef/8f2df13c7216bcad3e1c74e07f6e193d93e998e114f524a53877c9af27ad/cryptography-50.0.0-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", upload-time = 2026-07-31T14:23:35Z, size = 4719554, hashes = { sha256 = "fd9192b7b70c573d7f214eb1ae35e00d359f6f5e4b27c7e21e30de1fc6204645" } }, + { url = "https://files.pythonhosted.org/packages/7d/ff/b6ce0954962e7f7b969f850a883744197bb3910bdfd7b6da162eab7d9f68/cryptography-50.0.0-cp311-abi3-manylinux_2_28_aarch64.whl", upload-time = 2026-07-31T14:23:39Z, size = 4725244, hashes = { sha256 = "a1b30560f2acc95aa8b2e06e716a13dbfc97314747b80d9707e307f77b40d6b3" } }, + { url = "https://files.pythonhosted.org/packages/32/98/8a151d64367204cbc63ec65d37502f1d9c53cf4bfc6ec3c532614dbec60d/cryptography-50.0.0-cp311-abi3-manylinux_2_34_aarch64.whl", upload-time = 2026-07-31T14:23:46Z, size = 4724529, hashes = { sha256 = "07949c449a1abcf60d1ee6e88956d89404c7df3c8258f46589e912988e551987" } }, + { url = "https://files.pythonhosted.org/packages/ff/c6/7a6202a534e32103a285b7834a120869557fe198d51d7cfe59754c8bda9c/cryptography-50.0.0-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", upload-time = 2026-07-31T14:24:26Z, size = 4745252, hashes = { sha256 = "910e1d2668e7de9648f2bcee30e180db2a6b15c30f887d7c4c93ddf96e3992e3" } }, + { url = "https://files.pythonhosted.org/packages/d1/63/54dd723490ba2dc09b299682c10b38db38f159728bcaae8c591b8af2f22d/cryptography-50.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", upload-time = 2026-07-31T14:24:30Z, size = 4748483, hashes = { sha256 = "e722f16708d854fe924790e051061f6704a472c3bac347b6fd88033ea8dd0dc5" } }, + { url = "https://files.pythonhosted.org/packages/d8/36/83bb81f6e569bc38e1e4a7bc80f29b46bb9601920bc455fc8e888f5d5742/cryptography-50.0.0-cp39-abi3-manylinux_2_34_aarch64.whl", upload-time = 2026-07-31T14:24:39Z, size = 4748095, hashes = { sha256 = "2a8183b489dc1f7f80f135780fadc1108f14b31b8a40411c7a5b17425f65f28b" } }, +] + +[[packages]] +name = "cuda-bindings" +version = "12.9.10" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/7f/b2/8cef7e30e02e7ec3bf157ec192c0522546ed807c262752e884c693813494/cuda_bindings-12.9.10-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-10-15T14:12:01Z, size = 7063851, hashes = { sha256 = "aa1e07b12ae190a01ba3e0c85253be6ec1bfa13545a88eac5fd45ae4b0c04333" } }] + +[[packages]] +name = "cuda-pathfinder" +version = "1.8.3" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/b9/fb/f8e1890428f9f590b4beebd63b068aac1ce32a3331510c847b9f9a78f261/cuda_pathfinder-1.8.3-py3-none-any.whl", upload-time = 2026-10-02T03:20:23Z, size = 62561, hashes = { sha256 = "e29e59829c297a7a5233bd9cc71094fc5bddbd076951482670178f9eade39b1f" } }] + +[[packages]] +name = "cuda-python" +version = "12.9.0" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://download.pytorch.org/whl/cuda_python-12.9.0-py3-none-any.whl", upload-time = 2026-01-20T19:36:06Z, hashes = { sha256 = "926acba49b2c0a0374c61b7c98f337c085199cf51cdfe4d6423c4129c20547a7" } }] + +[[packages]] +name = "cuda-tile" +version = "1.6.0" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/1f/cc/b4da247f624320c9898c14003e7b809b74c4a447251e1c98e33505f41757/cuda_tile-1.6.0-cp312-cp312-manylinux2014_aarch64.whl", upload-time = 2026-09-10T00:04:22Z, size = 378564, hashes = { sha256 = "77fb2b15c61960514f62fc41eeae3722cf6468c051f7593fd43970691624214b" } }] + +[[packages]] +name = "datasets" +version = "3.6.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/1a/89/d3d6fef58a488f8569c82fd293ab7cbd4250244d67f425dcae64c63800ea/datasets-3.6.0.tar.gz", upload-time = 2025-05-07T15:15:02Z, size = 569336, hashes = { sha256 = "1b2bf43b19776e2787e181cfd329cb0ca1a358ea014780c3581e0f276375e041" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/20/34/a08b0ee99715eaba118cbe19a71f7b5e2425c2718ef96007c325944a1152/datasets-3.6.0-py3-none-any.whl", upload-time = 2025-05-07T15:14:59Z, size = 491546, hashes = { sha256 = "25000c4a2c0873a710df127d08a202a06eab7bf42441a6bc278b499c2f72cd1b" } }] + +[[packages]] +name = "decorator" +version = "5.2.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", upload-time = 2025-02-24T04:41:34Z, size = 56711, hashes = { sha256 = "65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", upload-time = 2025-02-24T04:41:32Z, size = 9190, hashes = { sha256 = "d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a" } }] + +[[packages]] +name = "decord2" +version = "3.4.0" +marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'arm64' and sys_platform == 'linux') or (platform_machine == 'armv7l' and sys_platform == 'linux')" +wheels = [{ url = "https://files.pythonhosted.org/packages/ec/ad/1e9f5081c9120653b483d6a91a707df65255b45b7c2a9d382aaafe0dcf55/decord2-3.4.0-cp312-cp312-manylinux_2_28_aarch64.whl", upload-time = 2026-05-30T13:23:41Z, size = 24476754, hashes = { sha256 = "f4ca81aa56aea80ecaaf1a285d8db9ea8aeda14cc929218255ad3419ea8a4a0e" } }] + +[[packages]] +name = "dill" +version = "0.3.8" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/17/4d/ac7ffa80c69ea1df30a8aa11b3578692a5118e7cd1aa157e3ef73b092d15/dill-0.3.8.tar.gz", upload-time = 2024-01-27T23:42:16Z, size = 184847, hashes = { sha256 = "3ebe3c479ad625c4553aca177444d89b486b1d84982eeacded644afc0cf797ca" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c9/7a/cef76fd8438a42f96db64ddaa85280485a9c395e7df3db8158cfec1eee34/dill-0.3.8-py3-none-any.whl", upload-time = 2024-01-27T23:42:14Z, size = 116252, hashes = { sha256 = "c36ca9ffb54365bdd2f8eb3eff7d2a21237f8452b57ace88b1ac615b7e815bd7" } }] + +[[packages]] +name = "diskcache" +version = "5.6.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/3f/21/1c1ffc1a039ddcc459db43cc108658f32c57d271d7289a2794e401d0fdb6/diskcache-5.6.3.tar.gz", upload-time = 2023-08-31T06:12:00Z, size = 67916, hashes = { sha256 = "2c3a3fa2743d8535d832ec61c2054a1641f41775aa7c556758a109941e33e4fc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3f/27/4570e78fc0bf5ea0ca45eb1de3818a23787af9b390c0b0a0033a1b8236f9/diskcache-5.6.3-py3-none-any.whl", upload-time = 2023-08-31T06:11:58Z, size = 45550, hashes = { sha256 = "5e31b2d5fbad117cc363ebaf6b689474db18a1f6438bc82358b024abd4c2ca19" } }] + +[[packages]] +name = "distro" +version = "1.9.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", upload-time = 2023-12-24T09:54:32Z, size = 60722, hashes = { sha256 = "2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", upload-time = 2023-12-24T09:54:30Z, size = 20277, hashes = { sha256 = "7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2" } }] + +[[packages]] +name = "docstring-parser" +version = "0.18.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/e0/4d/f332313098c1de1b2d2ff91cf2674415cc7cddab2ca1b01ae29774bd5fdf/docstring_parser-0.18.0.tar.gz", upload-time = 2026-04-14T04:09:19Z, size = 29341, hashes = { sha256 = "292510982205c12b1248696f44959db3cdd1740237a968ea1e2e7a900eeb2015" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a7/5f/ed01f9a3cdffbd5a008556fc7b2a08ddb1cc6ace7effa7340604b1d16699/docstring_parser-0.18.0-py3-none-any.whl", upload-time = 2026-04-14T04:09:18Z, size = 22484, hashes = { sha256 = "b3fcbed555c47d8479be0796ef7e19c2670d428d72e96da63f3a40122860374b" } }] + +[[packages]] +name = "einops" +version = "0.8.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/2c/77/850bef8d72ffb9219f0b1aac23fbc1bf7d038ee6ea666f331fa273031aa2/einops-0.8.2.tar.gz", upload-time = 2026-01-26T04:13:17Z, size = 56261, hashes = { sha256 = "609da665570e5e265e27283aab09e7f279ade90c4f01bcfca111f3d3e13f2827" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/09/f8d8f8f31e4483c10a906437b4ce31bdf3d6d417b73fe33f1a8b59e34228/einops-0.8.2-py3-none-any.whl", upload-time = 2026-01-26T04:13:18Z, size = 65638, hashes = { sha256 = "54058201ac7087911181bfec4af6091bb59380360f069276601256a76af08193" } }] + +[[packages]] +name = "executing" +version = "2.2.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", upload-time = 2025-09-01T09:48:10Z, size = 1129488, hashes = { sha256 = "3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", upload-time = 2025-09-01T09:48:08Z, size = 28317, hashes = { sha256 = "760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017" } }] + +[[packages]] +name = "fastapi" +version = "0.136.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/5d/45/c130091c2dfa061bbfe3150f2a5091ef1adf149f2a8d2ae769ecaf6e99a2/fastapi-0.136.1.tar.gz", upload-time = 2026-04-23T16:49:44Z, size = 397448, hashes = { sha256 = "7af665ad7acfa0a3baf8983d393b6b471b9da10ede59c60045f49fbc89a0fa7f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5a/ff/2e4eca3ade2c22fe1dea7043b8ee9dabe47753349eb1b56a202de8af6349/fastapi-0.136.1-py3-none-any.whl", upload-time = 2026-04-23T16:49:42Z, size = 117683, hashes = { sha256 = "a6e9d7eeada96c93a4d69cb03836b44fa34e2854accb7244a1ece36cd4781c3f" } }] + +[[packages]] +name = "filelock" +version = "3.29.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/b5/fe/997687a931ab51049acce6fa1f23e8f01216374ea81374ddee763c493db5/filelock-3.29.0.tar.gz", upload-time = 2026-04-19T15:39:10Z, size = 57571, hashes = { sha256 = "69974355e960702e789734cb4871f884ea6fe50bd8404051a3530bc07809cf90" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/81/47/dd9a212ef6e343a6857485ffe25bba537304f1913bdbed446a23f7f592e1/filelock-3.29.0-py3-none-any.whl", upload-time = 2026-04-19T15:39:08Z, size = 39812, hashes = { sha256 = "96f5f6344709aa1572bbf631c640e4ebeeb519e08da902c39a001882f30ac258" } }] + +[[packages]] +name = "flash-attn-4" +version = "4.0.0b19" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/93/63/6a00e1cd55765f5cf7d7a0100d1a5831824227ae3306275f3e6db420a76e/flash_attn_4-4.0.0b19.tar.gz", upload-time = 2026-06-24T09:15:14Z, size = 353141, hashes = { sha256 = "c904c9da0387c2ac0420cffdf61d6201d94cfeb354b6768fde794b04e9fc4e89" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e4/0e/5298d57e3efd5b7a07755fa9009fc1f6efc0f2d422915113eb7288a6552b/flash_attn_4-4.0.0b19-py3-none-any.whl", upload-time = 2026-06-24T09:15:13Z, size = 377662, hashes = { sha256 = "bc3856e018fa32e2b833726566641e51d02d45f2d444849937276a46c01653a2" } }] + +[[packages]] +name = "flashinfer-cubin" +version = "0.6.7.post3" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/91/64/f516081e983a35e3f52b7e525e2e62f1d6148c175eb24df32c8786776ba5/flashinfer_cubin-0.6.7.post3-py3-none-any.whl", upload-time = 2026-04-06T01:43:16Z, size = 294635743, hashes = { sha256 = "724cbce52f917dd06ebcb61fff2146c30b69cfdb341891d7c293249e414d6e35" } }] + +[[packages]] +name = "flashinfer-python" +version = "0.6.7.post3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/12/b5/466778818d195b96a062467ee389d0fcfa51fdfecad4a831922916d4c48a/flashinfer_python-0.6.7.post3.tar.gz", upload-time = 2026-04-06T01:43:00Z, size = 6508243, hashes = { sha256 = "defad86864e087f754ed0a632c2d15aa389a1dc8e3198fb6b7d7af4b36e3eaa5" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/01/6b/4117cd7cbeff07818ae7c6b8bf5a6d1ee3eed29356672b731b55af3d4453/flashinfer_python-0.6.7.post3-py3-none-any.whl", upload-time = 2026-04-06T01:42:58Z, size = 9187533, hashes = { sha256 = "9d3f1aa0313cf9e5cf99f7560b8e003c57876088c8abfe7a3d330cccd4873052" } }] + +[[packages]] +name = "frozenlist" +version = "1.8.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", upload-time = 2025-10-06T05:38:17Z, size = 45875, hashes = { sha256 = "3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2025-10-06T05:36:11Z, size = 243014, hashes = { sha256 = "96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4" } }, + { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", upload-time = 2025-10-06T05:38:16Z, size = 13409, hashes = { sha256 = "0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d" } }, +] + +[[packages]] +name = "fsspec" +version = "2025.3.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/34/f4/5721faf47b8c499e776bc34c6a8fc17efdf7fdef0b00f398128bc5dcb4ac/fsspec-2025.3.0.tar.gz", upload-time = 2025-03-07T21:47:56Z, size = 298491, hashes = { sha256 = "a935fd1ea872591f2b5148907d103488fc523295e6c64b835cfad8c3eca44972" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/56/53/eb690efa8513166adef3e0669afd31e95ffde69fb3c52ec2ac7223ed6018/fsspec-2025.3.0-py3-none-any.whl", upload-time = 2025-03-07T21:47:54Z, size = 193615, hashes = { sha256 = "efb87af3efa9103f94ca91a7f8cb7a4df91af9f74fc106c9c7ea0efd7277c1b3" } }] + +[[packages]] +name = "gguf" +version = "0.19.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/48/ae/17f1308ae45cd7b08ebb521747d5b23f4efc4d172038a4e228dd5106c3ff/gguf-0.19.0.tar.gz", upload-time = 2026-05-06T13:04:03Z, size = 111220, hashes = { sha256 = "dbadcd6cc7ccd44256f2229fe7c2dff5e8aa5cf0612ab987fd2b1a57e428923f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b3/bb/d71d6da82763528c2c2ed6b59a9d6142c6595545a4c448e2085d155e88c2/gguf-0.19.0-py3-none-any.whl", upload-time = 2026-05-06T13:04:02Z, size = 118475, hashes = { sha256 = "70bcd10edfe697fb2dad6e40af2234b9d8ece9a41a99761405121ebda1c3c1cd" } }] + +[[packages]] +name = "grpcio" +version = "1.78.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/06/8a/3d098f35c143a89520e568e6539cc098fcd294495910e359889ce8741c84/grpcio-1.78.0.tar.gz", upload-time = 2026-02-06T09:57:18Z, size = 12852416, hashes = { sha256 = "7382b95189546f375c174f53a5fa873cef91c4b8005faa05cc5b3beea9c4f1c5" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/24/a7/f06d151afc4e64b7e3cc3e872d331d011c279aaab02831e40a81c691fb65/grpcio-1.78.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", upload-time = 2026-02-06T09:55:31Z, size = 6475766, hashes = { sha256 = "859b13906ce098c0b493af92142ad051bf64c7870fa58a123911c88606714996" } }] + +[[packages]] +name = "grpcio-health-checking" +version = "1.78.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/8e/ac/8eb871f4e47b11abfe45497e6187a582ec680ccd7232706d228474a8c7a5/grpcio_health_checking-1.78.0.tar.gz", upload-time = 2026-02-06T10:01:47Z, size = 17008, hashes = { sha256 = "78526d5c60b9b99fd18954b89f86d70033c702e96ad6ccc9749baf16136979b3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8e/30/dbaf47e2210697e2923b49eb62a6a2c07d5ee55bb40cff1e6cc0c5bb22e1/grpcio_health_checking-1.78.0-py3-none-any.whl", upload-time = 2026-02-06T10:01:37Z, size = 19010, hashes = { sha256 = "309798c098c5de72a9bff7172d788fdf309d246d231db9955b32e7c1c773fbeb" } }] + +[[packages]] +name = "grpcio-reflection" +version = "1.78.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/31/06/337546aae558675f79cae2a8c1ce0c9b1952cbc5c28b01878f68d040f5bb/grpcio_reflection-1.78.0.tar.gz", upload-time = 2026-02-06T10:01:52Z, size = 19098, hashes = { sha256 = "e6e60c0b85dbcdf963b4d4d150c0f1d238ba891d805b575c52c0365d07fc0c40" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/df/6d/4d095d27ccd049865ecdafc467754e9e47ad0f677a30dda969c3590f6582/grpcio_reflection-1.78.0-py3-none-any.whl", upload-time = 2026-02-06T10:01:33Z, size = 22800, hashes = { sha256 = "06fcfde9e6888cdd12e9dd1cf6dc7c440c2e9acf420f696ccbe008672ed05b60" } }] + +[[packages]] +name = "h11" +version = "0.16.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", upload-time = 2025-04-24T03:35:25Z, size = 101250, hashes = { sha256 = "4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", upload-time = 2025-04-24T03:35:24Z, size = 37515, hashes = { sha256 = "63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86" } }] + +[[packages]] +name = "hf-xet" +version = "1.4.3" +marker = "(platform_machine == 'AMD64' and sys_platform == 'linux') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'amd64' and sys_platform == 'linux') or (platform_machine == 'arm64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" +sdist = { url = "https://files.pythonhosted.org/packages/53/92/ec9ad04d0b5728dca387a45af7bc98fbb0d73b2118759f5f6038b61a57e8/hf_xet-1.4.3.tar.gz", upload-time = 2026-03-31T22:40:07Z, size = 670477, hashes = { sha256 = "8ddedb73c8c08928c793df2f3401ec26f95be7f7e516a7bee2fbb546f6676113" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/53/60/46d493db155d2ee2801b71fb1b0fd67696359047fdd8caee2c914cc50c79/hf_xet-1.4.3-cp37-abi3-manylinux_2_28_aarch64.whl", upload-time = 2026-03-31T22:39:41Z, size = 3991546, hashes = { sha256 = "39f2d2e9654cd9b4319885733993807aab6de9dfbd34c42f0b78338d6617421f" } }] + +[[packages]] +name = "httpcore" +version = "1.0.9" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", upload-time = 2025-04-24T22:06:22Z, size = 85484, hashes = { sha256 = "6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", upload-time = 2025-04-24T22:06:20Z, size = 78784, hashes = { sha256 = "2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55" } }] + +[[packages]] +name = "httpcore2" +version = "2.3.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/e6/34/18f1c596e677962f040284246f393b10a1f8ce440b3a7e69c637d0f1c7ad/httpcore2-2.3.0.tar.gz", upload-time = 2026-06-01T13:15:02Z, size = 64300, hashes = { sha256 = "07327e251560960eea8e969d92d4c6a325feb13cca39e25340731336c3baf924" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c2/dd/3357218c69360d1cecc196c230c9a1d5c9afd5dba362056e23e60a5e64e5/httpcore2-2.3.0-py3-none-any.whl", upload-time = 2026-06-01T13:15:00Z, size = 80024, hashes = { sha256 = "477e9e334f74e5240dcac002e890580f36a57d40ff0fb14cc9655731d23b8415" } }] + +[[packages]] +name = "httpx" +version = "0.28.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", upload-time = 2024-12-06T15:37:23Z, size = 141406, hashes = { sha256 = "75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", upload-time = 2024-12-06T15:37:21Z, size = 73517, hashes = { sha256 = "d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad" } }] + +[[packages]] +name = "httpx2" +version = "2.3.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/9f/9a/cca0b9145f13d8ae34b885ae28d403a1469a433abc78e0f94f4ce94e650b/httpx2-2.3.0.tar.gz", upload-time = 2026-06-01T13:15:04Z, size = 81115, hashes = { sha256 = "227e7c41d95a76d4077a52640564132777215fc3394e07b66a3116c33d668fa9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/87/ce/ae2911859847f9ba1d6b23027e53481cbeb50b93234f355a968d300ca2cb/httpx2-2.3.0-py3-none-any.whl", upload-time = 2026-06-01T13:15:01Z, size = 74538, hashes = { sha256 = "6f393663bdf6dbe7fe90118e3eb5b2bd024a675cae0390ac08cec9198812d8b7" } }] + +[[packages]] +name = "huggingface-hub" +version = "1.16.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/48/0f/ed994dbade67a54407c28cab96ef845e0e6d25500be56aca6394f8bfc9dd/huggingface_hub-1.16.1.tar.gz", upload-time = 2026-05-21T18:40:00Z, size = 792534, hashes = { sha256 = "7f1dc4c5ec21aed69be630ad0c3378616be16f3de1a47b141c0e812965d9c832" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/49/79/621a7dbb80c70974f73a597275351ebe03ce5bc65cb5f8f4acb5859252bc/huggingface_hub-1.16.1-py3-none-any.whl", upload-time = 2026-05-21T18:39:58Z, size = 668176, hashes = { sha256 = "64340de934b9ce37857ef85a82de72f5629e8a270f9119eabb12bf495eb53c22" } }] + +[[packages]] +name = "idna" +version = "3.17" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/b9/28/99c51f664567218d824af024c0251650fb27e4ca066df188dab0769c5b91/idna-3.17.tar.gz", upload-time = 2026-05-28T14:32:38Z, size = 196048, hashes = { sha256 = "5eb0cb53bc467c12eadcf6de83163ad8527cec9416f44b9b61b19caedad2b87f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/de/a7/f76514cc40ad6234098ecdebda08732d75964776c51a42845b7da10649e2/idna-3.17-py3-none-any.whl", upload-time = 2026-05-28T14:32:37Z, size = 65316, hashes = { sha256 = "466e48829084efe2548012b855df21540b96f2e20e51bd124c851536556a592c" } }] + +[[packages]] +name = "importlib-metadata" +version = "8.5.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/cd/12/33e59336dca5be0c398a7482335911a33aa0e20776128f038019f1a95f1b/importlib_metadata-8.5.0.tar.gz", upload-time = 2024-09-11T14:56:08Z, size = 55304, hashes = { sha256 = "71522656f0abace1d072b9e5481a48f07c138e00f079c38c8f883823f9c26bd7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a0/d9/a1e041c5e7caa9a05c925f4bdbdfb7f006d1f74996af53467bc394c97be7/importlib_metadata-8.5.0-py3-none-any.whl", upload-time = 2024-09-11T14:56:07Z, size = 26514, hashes = { sha256 = "45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b" } }] + +[[packages]] +name = "interegular" +version = "0.3.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/dc/9d/8b6dde58a028a3962ce17e84d5fe73758df61378e00ef8ac3d85da34b0ff/interegular-0.3.3.tar.gz", upload-time = 2024-01-06T23:01:22Z, size = 24705, hashes = { sha256 = "d9b697b21b34884711399ba0f0376914b81899ce670032486d0d048344a76600" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c4/01/72d6472f80651673716d1deda2a5bbb633e563ecf94f4479da5519d69d25/interegular-0.3.3-py37-none-any.whl", upload-time = 2024-01-06T23:01:20Z, size = 23635, hashes = { sha256 = "b0c07007d48c89d6d19f7204972d369b2a77222722e126b6aa63aa721dc3b19c" } }] + +[[packages]] +name = "ipython" +version = "9.13.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/cd/c4/87cda5842cf5c31837c06ddb588e11c3c35d8ece89b7a0108c06b8c9b00a/ipython-9.13.0.tar.gz", upload-time = 2026-04-24T12:24:55Z, size = 4430549, hashes = { sha256 = "7e834b6afc99f020e3f05966ced34792f40267d64cb1ea9043886dab0dde5967" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b9/86/3060e8029b7cc505cce9a0137431dda81d0a3fde93a8f0f50ee0bf37a795/ipython-9.13.0-py3-none-any.whl", upload-time = 2026-04-24T12:24:53Z, size = 627274, hashes = { sha256 = "57f9d4639e20818d328d287c7b549af3d05f12486ea8f2e7f73e52a36ec4d201" } }] + +[[packages]] +name = "ipython-pygments-lexers" +version = "1.1.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", upload-time = 2025-01-17T11:24:34Z, size = 8393, hashes = { sha256 = "09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", upload-time = 2025-01-17T11:24:33Z, size = 8074, hashes = { sha256 = "a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c" } }] + +[[packages]] +name = "jedi" +version = "0.19.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", upload-time = 2024-11-11T01:41:42Z, size = 1231287, hashes = { sha256 = "4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", upload-time = 2024-11-11T01:41:40Z, size = 1572278, hashes = { sha256 = "a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9" } }] + +[[packages]] +name = "jinja2" +version = "3.1.6" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://download.pytorch.org/whl/jinja2-3.1.6-py3-none-any.whl", upload-time = 2025-10-14T18:38:59Z, hashes = { sha256 = "85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67" } }] + +[[packages]] +name = "jiter" +version = "0.13.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/0d/5e/4ec91646aee381d01cdb9974e30882c9cd3b8c5d1079d6b5ff4af522439a/jiter-0.13.0.tar.gz", upload-time = 2026-02-02T12:37:56Z, size = 164847, hashes = { sha256 = "f2839f9c2c7e2dffc1bc5929a510e14ce0a946be9365fd1219e7ef342dae14f4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/cf/52/e5719a60ac5d4d7c5995461a94ad5ef962a37c8bf5b088390e6fad59b2ff/jiter-0.13.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2026-02-02T12:36:00Z, size = 348821, hashes = { sha256 = "c1e2b199f446d3e82246b4fd9236d7cb502dc2222b18698ba0d986d2fecc6152" } }] + +[[packages]] +name = "jsonschema" +version = "4.23.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/38/2e/03362ee4034a4c917f697890ccd4aec0800ccf9ded7f511971c75451deec/jsonschema-4.23.0.tar.gz", upload-time = 2024-07-08T18:40:05Z, size = 325778, hashes = { sha256 = "d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/69/4a/4f9dbeb84e8850557c02365a0eee0649abe5eb1d84af92a25731c6c0f922/jsonschema-4.23.0-py3-none-any.whl", upload-time = 2024-07-08T18:40:00Z, size = 88462, hashes = { sha256 = "fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566" } }] + +[[packages]] +name = "jsonschema-specifications" +version = "2025.9.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", upload-time = 2025-09-08T01:34:59Z, size = 32855, hashes = { sha256 = "b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", upload-time = 2025-09-08T01:34:57Z, size = 18437, hashes = { sha256 = "98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe" } }] + +[[packages]] +name = "lark" +version = "1.3.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/da/34/28fff3ab31ccff1fd4f6c7c7b0ceb2b6968d8ea4950663eadcb5720591a0/lark-1.3.1.tar.gz", upload-time = 2025-10-27T18:25:56Z, size = 382732, hashes = { sha256 = "b426a7a6d6d53189d318f2b6236ab5d6429eaf09259f1ca33eb716eed10d2905" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl", upload-time = 2025-10-27T18:25:54Z, size = 113151, hashes = { sha256 = "c629b661023a014c37da873b4ff58a817398d12635d3bbb2c5a03be7fe5d1e12" } }] + +[[packages]] +name = "llguidance" +version = "0.7.30" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/bf/38/d1ef3ae08d8d857e5e0690c5b1e07bf7eb4a1cae5881d87215826dc6cadb/llguidance-0.7.30.tar.gz", upload-time = 2025-06-23T00:23:49Z, size = 1055528, hashes = { sha256 = "e93bf75f2b6e48afb86a5cee23038746975e1654672bf5ba0ae75f7d4d4a2248" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9c/5b/6a166564b14f9f805f0ea01ec233a84f55789cb7eeffe1d6224ccd0e6cdd/llguidance-0.7.30-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2025-06-23T00:23:39Z, size = 14867038, hashes = { sha256 = "af8741c867e4bc7e42f7cdc68350c076b4edd0ca10ecefbde75f15a9f6bc25d0" } }] + +[[packages]] +name = "loguru" +version = "0.7.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/3a/05/a1dae3dffd1116099471c643b8924f5aa6524411dc6c63fdae648c4f1aca/loguru-0.7.3.tar.gz", upload-time = 2024-12-06T11:20:56Z, size = 63559, hashes = { sha256 = "19480589e77d47b8d85b2c827ad95d49bf31b0dcde16593892eb51dd18706eb6" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl", upload-time = 2024-12-06T11:20:54Z, size = 61595, hashes = { sha256 = "31a33c10c8e1e10422bfd431aeb5d351c7cf7fa671e3c4df004162264b28220c" } }] + +[[packages]] +name = "lxml" +version = "6.1.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/28/30/9abc9e34c657c33834eaf6cd02124c61bdf5944d802aa48e69be8da3585d/lxml-6.1.0.tar.gz", upload-time = 2026-04-18T04:32:51Z, size = 4197006, hashes = { sha256 = "bfd57d8008c4965709a919c3e9a98f76c2c7cb319086b3d26858250620023b13" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/90/97/a517944b20f8fd0932ad2109482bee4e29fe721416387a363306667941f6/lxml-6.1.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", upload-time = 2026-04-18T04:32:56Z, size = 4930895, hashes = { sha256 = "fc46da94826188ed45cb53bd8e3fc076ae22675aea2087843d4735627f867c6d" } }, + { url = "https://files.pythonhosted.org/packages/88/ee/2a5c2aa2c32016a226ca25d3e1056a8102ea6e1fe308bf50213586635400/lxml-6.1.0-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-04-18T04:33:01Z, size = 5005790, hashes = { sha256 = "5715e0e28736a070f3f34a7ccc09e2fdcba0e3060abbcf61a1a5718ff6d6b105" } }, +] + +[[packages]] +name = "markdown-it-py" +version = "4.0.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", upload-time = 2025-08-11T12:57:52Z, size = 73070, hashes = { sha256 = "cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", upload-time = 2025-08-11T12:57:51Z, size = 87321, hashes = { sha256 = "87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147" } }] + +[[packages]] +name = "markupsafe" +version = "3.0.3" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://download.pytorch.org/whl/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-03-27T13:54:33Z, hashes = { sha256 = "3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d" } }] + +[[packages]] +name = "matplotlib-inline" +version = "0.2.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/c7/74/97e72a36efd4ae2bccb3463284300f8953f199b5ffbc04cbbb0ec78f74b1/matplotlib_inline-0.2.1.tar.gz", upload-time = 2025-10-23T09:00:22Z, size = 8110, hashes = { sha256 = "e1ee949c340d771fc39e241ea75683deb94762c8fa5f2927ec57c83c4dffa9fe" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/af/33/ee4519fa02ed11a94aef9559552f3b17bb863f2ecfe1a35dc7f548cde231/matplotlib_inline-0.2.1-py3-none-any.whl", upload-time = 2025-10-23T09:00:20Z, size = 9516, hashes = { sha256 = "d56ce5156ba6085e00a9d54fead6ed29a9c47e215cd1bba2e976ef39f5710a76" } }] + +[[packages]] +name = "mdurl" +version = "0.1.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", upload-time = 2022-08-14T12:40:10Z, size = 8729, hashes = { sha256 = "bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", upload-time = 2022-08-14T12:40:09Z, size = 9979, hashes = { sha256 = "84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8" } }] + +[[packages]] +name = "mistral-common" +version = "1.9.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/db/ce/685b8127a326478e05501cb4c9ca23d1cd9f37e16c465a1e832c75aea709/mistral_common-1.9.1.tar.gz", upload-time = 2026-02-12T10:53:41Z, size = 6338922, hashes = { sha256 = "550583d70a395c3586cfb748ffab53bd1d7c3409507f0efc0118bff30ffb26e9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ac/72/a38bb1fd9fd4d4ef990341c9dd1a7c8061f1951e10efa6d50c0a3f04eced/mistral_common-1.9.1-py3-none-any.whl", upload-time = 2026-02-12T10:53:39Z, size = 6518623, hashes = { sha256 = "9e2b2520b6f67bac2e2bb06fcf985b7a1277b01938da2b7cda8cf0fdbfa92e91" } }] + +[[packages]] +name = "modelscope" +version = "1.40.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/d7/af/f92c9824db46757dd1b0b5cbf3778daf54e7e44f0e1e6934d0b1bedfb286/modelscope-1.40.2.tar.gz", upload-time = 2026-10-09T09:09:10Z, size = 4566951, hashes = { sha256 = "7a642cef8c144c28c4ddcc37db5fd803f5481f0d78a7f26c2b9e0e2a225b528c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b9/8a/e85b79ee1c541f7bbf208fd7a6185c9b11e50c192b1071b0750db26b09e9/modelscope-1.40.2-py3-none-any.whl", upload-time = 2026-10-09T09:09:07Z, size = 6062299, hashes = { sha256 = "ea03e0ec4a73398a488d3d240cda4f0c5b62390377a134756d4074a3036cb909" } }] + +[[packages]] +name = "modelscope-hub" +version = "0.4.6" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/08/d9/ac46c39b957ff44b55c550c641ad5c625ffe3eb5c0b6f20a849b591e9d14/modelscope_hub-0.4.6.tar.gz", upload-time = 2026-10-09T08:08:21Z, size = 298574, hashes = { sha256 = "c54de09be2ccb27b9214f7c3ebe5751121f335f5016643f789589d0547e78c52" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/4d/74/8872ae511d8a336ca918a8d0234cfbccfff0e2304de672882b2768ff628f/modelscope_hub-0.4.6-py3-none-any.whl", upload-time = 2026-10-09T08:08:19Z, size = 237177, hashes = { sha256 = "361bcec229bfbed645a9291ec5b167d76cd94b795207dc2eceba628108f4023a" } }] + +[[packages]] +name = "mpmath" +version = "1.3.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", upload-time = 2023-03-07T16:47:11Z, size = 508106, hashes = { sha256 = "7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", upload-time = 2023-03-07T16:47:09Z, size = 536198, hashes = { sha256 = "a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c" } }] + +[[packages]] +name = "msgspec" +version = "0.21.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/e3/60/f79b9b013a16fa3a58350c9295ddc6789f2e335f36ea61ed10a21b215364/msgspec-0.21.1.tar.gz", upload-time = 2026-04-12T21:44:50Z, size = 319193, hashes = { sha256 = "2313508e394b0d208f8f56892ca9b2799e2561329de9763b19619595a6c0f72c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8a/37/655101799590bcc5fddb2bd3fe0e6194e816c2d1da7c361725f5eb89a910/msgspec-0.21.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-04-12T21:44:09Z, size = 218871, hashes = { sha256 = "846758412e9518252b2ac9bffd6f0e54d9ff614f5f9488df7749f81ff5c80920" } }] + +[[packages]] +name = "multidict" +version = "6.7.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", upload-time = 2026-01-26T02:46:45Z, size = 102010, hashes = { sha256 = "ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/80/c959c5933adedb9ac15152e4067c702a808ea183a8b64cf8f31af8ad3155/multidict-6.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-01-26T02:43:57Z, size = 258883, hashes = { sha256 = "eb0ce7b2a32d09892b3dd6cc44877a0d02a33241fafca5f25c8b6b62374f8b75" } }, + { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", upload-time = 2026-01-26T02:46:44Z, size = 12319, hashes = { sha256 = "55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56" } }, +] + +[[packages]] +name = "multiprocess" +version = "0.70.16" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/b5/ae/04f39c5d0d0def03247c2893d6f2b83c136bf3320a2154d7b8858f2ba72d/multiprocess-0.70.16.tar.gz", upload-time = 2024-01-28T18:52:34Z, size = 1772603, hashes = { sha256 = "161af703d4652a0e1410be6abccecde4a7ddffd19341be0a7011b94aeb171ac1" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bc/f7/7ec7fddc92e50714ea3745631f79bd9c96424cb2702632521028e57d3a36/multiprocess-0.70.16-py310-none-any.whl", upload-time = 2024-01-28T18:52:26Z, size = 134824, hashes = { sha256 = "c4a9944c67bd49f823687463660a2d6daae94c289adff97e0f9d696ba6371d02" } }, + { url = "https://files.pythonhosted.org/packages/50/15/b56e50e8debaf439f44befec5b2af11db85f6e0f344c3113ae0be0593a91/multiprocess-0.70.16-py311-none-any.whl", upload-time = 2024-01-28T18:52:28Z, size = 143519, hashes = { sha256 = "af4cabb0dac72abfb1e794fa7855c325fd2b55a10a44628a3c1ad3311c04127a" } }, + { url = "https://files.pythonhosted.org/packages/0a/7d/a988f258104dcd2ccf1ed40fdc97e26c4ac351eeaf81d76e266c52d84e2f/multiprocess-0.70.16-py312-none-any.whl", upload-time = 2024-01-28T18:52:29Z, size = 146741, hashes = { sha256 = "fc0544c531920dde3b00c29863377f87e1632601092ea2daca74e4beb40faa2e" } }, + { url = "https://files.pythonhosted.org/packages/ea/89/38df130f2c799090c978b366cfdf5b96d08de5b29a4a293df7f7429fa50b/multiprocess-0.70.16-py38-none-any.whl", upload-time = 2024-01-28T18:52:30Z, size = 132628, hashes = { sha256 = "a71d82033454891091a226dfc319d0cfa8019a4e888ef9ca910372a446de4435" } }, + { url = "https://files.pythonhosted.org/packages/da/d9/f7f9379981e39b8c2511c9e0326d212accacb82f12fbfdc1aa2ce2a7b2b6/multiprocess-0.70.16-py39-none-any.whl", upload-time = 2024-01-28T18:52:31Z, size = 133351, hashes = { sha256 = "a0bafd3ae1b732eac64be2e72038231c1ba97724b60b09400d68f229fcc2fbf3" } }, +] + +[[packages]] +name = "nest-asyncio" +version = "1.6.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", upload-time = 2024-01-21T14:25:19Z, size = 7418, hashes = { sha256 = "6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", upload-time = 2024-01-21T14:25:17Z, size = 5195, hashes = { sha256 = "87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c" } }] + +[[packages]] +name = "networkx" +version = "3.6.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", upload-time = 2025-12-08T17:02:39Z, size = 2517025, hashes = { sha256 = "26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", upload-time = 2025-12-08T17:02:38Z, size = 2068504, hashes = { sha256 = "d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762" } }] + +[[packages]] +name = "ninja" +version = "1.13.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ac/92/410b7917d16ab54c04b05cc32b9284803671d91cf79d33be6009c28d4ea8/ninja-1.13.2.tar.gz", upload-time = 2026-08-30T15:49:51Z, size = 243739, hashes = { sha256 = "525bfa3fc88aa30a4467df270fd5be6f9fcae8061d54d4df74ea1dc5abd5a975" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/35/54/7368ce188625e39acc03ee362bb86cc9bfa6ad15e25c50889ae36e2889b3/ninja-1.13.2-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", upload-time = 2026-08-30T15:49:29Z, size = 177180, hashes = { sha256 = "d775a5e43e9088f507a6250d57fcf5678eb31268c545feb5064ffeee33735622" } }] + +[[packages]] +name = "numpy" +version = "2.4.4" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/d7/9f/b8cef5bffa569759033adda9481211426f12f53299629b410340795c2514/numpy-2.4.4.tar.gz", upload-time = 2026-03-29T13:22:01Z, size = 20731587, hashes = { sha256 = "2d390634c5182175533585cc89f3608a4682ccb173cc9bb940b2881c8d6f8fa0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7f/37/eed308a8f56cba4d1fdf467a4fc67ef4ff4bf1c888f5fc980481890104b1/numpy-2.4.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-03-29T13:19:00Z, size = 15670666, hashes = { sha256 = "f9e75681b59ddaa5e659898085ae0eaea229d054f2ac0c7e563a62205a700121" } }] + +[[packages]] +name = "nvidia-cudnn-frontend" +version = "1.31.0" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/bf/4b/ba084b26c9709b05446642413aa4bbb1056fe00af7f99e356a3cf24774d6/nvidia_cudnn_frontend-1.31.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-10-08T18:05:50Z, size = 9970357, hashes = { sha256 = "47d1a5432f59a2a7d0f903727c0d244e1413a20686b98d8e3890919c5d82a508" } }] + +[[packages]] +name = "nvidia-cutlass-dsl" +version = "4.8.1" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/bd/ce/a590b929285faf0aa285c5ccee2b88e0b5259fb39a6326206e0f140ea3fc/nvidia_cutlass_dsl-4.8.1-py3-none-any.whl", upload-time = 2026-10-16T10:54:15Z, size = 10510, hashes = { sha256 = "43ed46b21d151aa643c6765457c7310827b938c1cf45d5109a0152de4ef06227" } }] + +[[packages]] +name = "nvidia-cutlass-dsl-libs-base" +version = "4.8.1" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/b1/da/541743caf57efb1256ef9355bb69e80c0f116417d219140a840c5629cf8d/nvidia_cutlass_dsl_libs_base-4.8.1-cp312-cp312-manylinux_2_28_aarch64.whl", upload-time = 2026-10-16T08:39:31Z, size = 3553303, hashes = { sha256 = "c6312f8b2f1aadd959a0276daf3c4bacc05c783c6ea1119859ed4ebd3c07e3b1" } }] + +[[packages]] +name = "nvidia-cutlass-dsl-libs-core" +version = "4.8.1" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/6c/03/1c59e3caf7c8b5cae3ae4d1753201c7e64d36cdf182fb882e070b0f14a55/nvidia_cutlass_dsl_libs_core-4.8.1-py3-none-any.whl", upload-time = 2026-10-16T08:35:00Z, size = 1635096, hashes = { sha256 = "bacc6760e3286db447d45720d32ae58ac2e6cecade1152345ef784b2d5e44431" } }] + +[[packages]] +name = "nvidia-cutlass-dsl-libs-cu12" +version = "4.8.1" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/ef/cf/ffc908c085025f3f54c3aa9e793e14c432214e5c245e8c6ccecc6c3cc620/nvidia_cutlass_dsl_libs_cu12-4.8.1-cp312-cp312-manylinux_2_28_aarch64.whl", upload-time = 2026-10-16T10:41:31Z, size = 90665248, hashes = { sha256 = "c89d9ff9574e94561e17be23c0c06d67fc1edb6a4bc3eb067f38a1dc1f682b6e" } }] + +[[packages]] +name = "nvidia-cutlass-dsl-libs-cu13" +version = "4.8.1" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/b6/3e/63f5b39aab33f21c4ddb0fc5a0f6336eccb4e0b18375f901568c88a3205a/nvidia_cutlass_dsl_libs_cu13-4.8.1-cp312-cp312-manylinux_2_28_aarch64.whl", upload-time = 2026-10-16T10:48:23Z, size = 90996248, hashes = { sha256 = "862378c0c51a3af2e053b363656501b06f9a54f777eee5be8c0046d780b66956" } }] + +[[packages]] +name = "nvidia-ml-py" +version = "13.595.45" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ce/49/c29f6e30d8662d2e94fef17739ea7309cc76aba269922ae999e4cc07f268/nvidia_ml_py-13.595.45.tar.gz", upload-time = 2026-03-19T16:59:44Z, size = 50780, hashes = { sha256 = "c9f34897fe0441ff35bc8f35baf80f830a20b0f4e6ce71e0a325bc0e66acf079" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8a/24/fc256107d23597fa33d319505ce77160fa1a2349c096d01901ffc7cb7fc4/nvidia_ml_py-13.595.45-py3-none-any.whl", upload-time = 2026-03-19T16:59:43Z, size = 51776, hashes = { sha256 = "b65a7977f503d56154b14d683710125ef93594adb63fbf7e559336e3318f1376" } }] + +[[packages]] +name = "openai" +version = "2.6.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/c4/44/303deb97be7c1c9b53118b52825cbd1557aeeff510f3a52566b1fa66f6a2/openai-2.6.1.tar.gz", upload-time = 2025-10-24T13:29:52Z, size = 593043, hashes = { sha256 = "27ae704d190615fca0c0fc2b796a38f8b5879645a3a52c9c453b23f97141bb49" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/15/0e/331df43df633e6105ff9cf45e0ce57762bd126a45ac16b25a43f6738d8a2/openai-2.6.1-py3-none-any.whl", upload-time = 2025-10-24T13:29:50Z, size = 1005551, hashes = { sha256 = "904e4b5254a8416746a2f05649594fa41b19d799843cd134dac86167e094edef" } }] + +[[packages]] +name = "openai-harmony" +version = "0.0.4" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/92/94/01509d510bebf6606614e51113e5a415ced15b8f34aa98a8bf2539314650/openai_harmony-0.0.4.tar.gz", upload-time = 2025-08-09T01:43:24Z, size = 279848, hashes = { sha256 = "5c67ac6df349236fb7b64f57c3dbb0273efcdca24314daa108f2a482c427106c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/05/88/ade63bd8f36603610040e7cc086bc134d57a99a742e05f7fcddfdf822ee1/openai_harmony-0.0.4-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2025-08-09T01:43:02Z, size = 2963206, hashes = { sha256 = "3cf2344366f10981bbc0f6d9949a0b2bb87151d209ed295943ed6ad8eda37932" } }] + +[[packages]] +name = "opentelemetry-api" +version = "1.41.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/fa/fc/b7564cbef36601aef0d6c9bc01f7badb64be8e862c2e1c3c5c3b43b53e4f/opentelemetry_api-1.41.1.tar.gz", upload-time = 2026-04-24T13:15:38Z, size = 71416, hashes = { sha256 = "0ad1814d73b875f84494387dae86ce0b12c68556331ce6ce8fe789197c949621" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/29/59/3e7118ed140f76b0982ba4321bdaed1997a0473f9720de2d10788a577033/opentelemetry_api-1.41.1-py3-none-any.whl", upload-time = 2026-04-24T13:15:15Z, size = 69007, hashes = { sha256 = "a22df900e75c76dc08440710e51f52f1aa6b451b429298896023e60db5b3139f" } }] + +[[packages]] +name = "orjson" +version = "3.11.8" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/9d/1b/2024d06792d0779f9dbc51531b61c24f76c75b9f4ce05e6f3377a1814cea/orjson-3.11.8.tar.gz", upload-time = 2026-03-31T16:16:27Z, size = 5603832, hashes = { sha256 = "96163d9cdc5a202703e9ad1b9ae757d5f0ca62f4fa0cc93d1f27b0e180cc404e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/27/d2/1f8682ae50d5c6897a563cb96bc106da8c9cb5b7b6e81a52e4cc086679b9/orjson-3.11.8-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2026-03-31T16:15:15Z, size = 131946, hashes = { sha256 = "76070a76e9c5ae661e2d9848f216980d8d533e0f8143e6ed462807b242e3c5e8" } }] + +[[packages]] +name = "outlines" +version = "0.1.11" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ac/d0/d59ae830bf7026425942899e3d48e77b58a713cff946a695e5405808da1b/outlines-0.1.11.tar.gz", upload-time = 2024-12-13T07:24:08Z, size = 2488858, hashes = { sha256 = "0997bd9da1cc050e430bd08995dc7d4bd855918bafa4531e49d3f37110a23aba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/13/b4/99ea4a122bef60e3fd6402d19665aff1f928e0daf8fac3044d0b73f72003/outlines-0.1.11-py3-none-any.whl", upload-time = 2024-12-13T07:24:05Z, size = 87623, hashes = { sha256 = "f5a5f2242ed9802d3aab7a92789bf4008d734c576be9258cc0a297f690124727" } }] + +[[packages]] +name = "outlines-core" +version = "0.1.26" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/d3/f3/274d07f4702728b43581235a77e545ec602b25f9b0098b288a0f3052521d/outlines_core-0.1.26.tar.gz", upload-time = 2024-12-12T23:38:50Z, size = 75139, hashes = { sha256 = "481c4301341e77cc8f1832d616784adb4d461b4fec65878e7c0d2cba7163a189" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ad/db/fa91a2d54288b900de82d86eda3adb2417b3b5b2db6256854a5e8bc85c32/outlines_core-0.1.26-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2024-12-12T23:38:32Z, size = 321050, hashes = { sha256 = "00f409f72c11f6ffadb57066950dd384d5388015028c1a1a615c9a64988dae3e" } }] + +[[packages]] +name = "packaging" +version = "24.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", upload-time = 2024-11-08T09:47:47Z, size = 163950, hashes = { sha256 = "c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", upload-time = 2024-11-08T09:47:44Z, size = 65451, hashes = { sha256 = "09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759" } }] + +[[packages]] +name = "pandas" +version = "2.3.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", upload-time = 2025-09-29T23:34:51Z, size = 4495223, hashes = { sha256 = "e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/57/56/cf2dbe1a3f5271370669475ead12ce77c61726ffd19a35546e31aa8edf4e/pandas-2.3.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2025-09-29T23:19:59Z, size = 11737212, hashes = { sha256 = "ecaf1e12bdc03c86ad4a7ea848d66c685cb6851d807a26aa245ca3d2017a1908" } }] + +[[packages]] +name = "parso" +version = "0.8.6" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/81/76/a1e769043c0c0c9fe391b702539d594731a4362334cdf4dc25d0c09761e7/parso-0.8.6.tar.gz", upload-time = 2026-02-09T15:45:24Z, size = 401621, hashes = { sha256 = "2b9a0332696df97d454fa67b81618fd69c35a7b90327cbe6ba5c92d2c68a7bfd" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b6/61/fae042894f4296ec49e3f193aff5d7c18440da9e48102c3315e1bc4519a7/parso-0.8.6-py2.py3-none-any.whl", upload-time = 2026-02-09T15:45:21Z, size = 106894, hashes = { sha256 = "2c549f800b70a5c4952197248825584cb00f033b29c692671d3bf08bf380baff" } }] + +[[packages]] +name = "partial-json-parser" +version = "0.2.1.1.post7" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/6a/6d/eed37d7ebc1e0bcd27b831c0cf1fe94881934316187c4b30d23f29ea0bd4/partial_json_parser-0.2.1.1.post7.tar.gz", upload-time = 2025-11-17T07:27:41Z, size = 10296, hashes = { sha256 = "86590e1ba6bcb6739a2dfc17d2323f028cb5884f4c6ce23db376999132c9a922" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/42/32/658973117bf0fd82a24abbfb94fe73a5e86216e49342985e10acce54775a/partial_json_parser-0.2.1.1.post7-py3-none-any.whl", upload-time = 2025-11-17T07:27:40Z, size = 10877, hashes = { sha256 = "145119e5eabcf80cbb13844a6b50a85c68bf99d376f8ed771e2a3c3b03e653ae" } }] + +[[packages]] +name = "pexpect" +version = "4.9.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", upload-time = 2023-11-25T09:07:26Z, size = 166450, hashes = { sha256 = "ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", upload-time = 2023-11-25T06:56:14Z, size = 63772, hashes = { sha256 = "7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523" } }] + +[[packages]] +name = "pillow" +version = "12.3.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/1c/3d/bb7fca845737cf9d7dbde16ed1843984665ff2e0a518f5db43e77ec540b9/pillow-12.3.0.tar.gz", upload-time = 2026-07-01T11:56:38Z, size = 47025035, hashes = { sha256 = "3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/25/27/ac8f99618ffd3dde21db0f4d4b1d2ab00c0880595bfd17df103f7f39fd0c/pillow-12.3.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-07-01T11:54:11Z, size = 6266838, hashes = { sha256 = "d9c7f76c0673154f044e9d78c8655fb4213f6ca31a836df48b40fe5d187717b9" } }] + +[[packages]] +name = "prometheus-client" +version = "0.26.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/52/73/f1334c29c2af4cd9dba6c7817e61b611bd0215e2eb5565c6064a4de18802/prometheus_client-0.26.0.tar.gz", upload-time = 2026-07-24T19:36:41Z, size = 92910, hashes = { sha256 = "04a91bcf94e2cf74a44a1a874d651a2e853ed354b6e822f3b7487751465d5c2b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/eb/a3/b69efbf4143b5b9859b977770bbbabcc2796b702fa69dc40271e45cd5a56/prometheus_client-0.26.0-py3-none-any.whl", upload-time = 2026-07-24T19:36:40Z, size = 64494, hashes = { sha256 = "fa93d06737aa02bacd05794768508bb97d2fbee28cb3bca04eaae92f0ca953d6" } }] + +[[packages]] +name = "prompt-toolkit" +version = "3.0.52" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", upload-time = 2025-08-27T15:24:02Z, size = 434198, hashes = { sha256 = "28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", upload-time = 2025-08-27T15:23:59Z, size = 391431, hashes = { sha256 = "9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955" } }] + +[[packages]] +name = "propcache" +version = "0.4.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", upload-time = 2025-10-08T19:49:02Z, size = 46442, hashes = { sha256 = "f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/d3/6c7ee328b39a81ee877c962469f1e795f9db87f925251efeb0545e0020d0/propcache-0.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2025-10-08T19:46:50Z, size = 225505, hashes = { sha256 = "ec17c65562a827bba85e3872ead335f95405ea1674860d96483a02f5c698fa72" } }, + { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", upload-time = 2025-10-08T19:49:00Z, size = 13305, hashes = { sha256 = "af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237" } }, +] + +[[packages]] +name = "protobuf" +version = "6.33.6" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/66/70/e908e9c5e52ef7c3a6c7902c9dfbb34c7e29c25d2f81ade3856445fd5c94/protobuf-6.33.6.tar.gz", upload-time = 2026-03-18T19:05:00Z, size = 444531, hashes = { sha256 = "a6768d25248312c297558af96a9f9c929e8c4cee0659cb07e780731095f38135" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ee/90/b3c01fdec7d2f627b3a6884243ba328c1217ed2d978def5c12dc50d328a3/protobuf-6.33.6-cp39-abi3-manylinux2014_aarch64.whl", upload-time = 2026-03-18T19:04:53Z, size = 324610, hashes = { sha256 = "e2afbae9b8e1825e3529f88d514754e094278bb95eadc0e199751cdd9a2e82a2" } }, + { url = "https://files.pythonhosted.org/packages/c4/72/02445137af02769918a93807b2b7890047c32bfb9f90371cbc12688819eb/protobuf-6.33.6-py3-none-any.whl", upload-time = 2026-03-18T19:04:59Z, size = 170656, hashes = { sha256 = "77179e006c476e69bf8e8ce866640091ec42e1beb80b213c3900006ecfba6901" } }, +] + +[[packages]] +name = "psutil" +version = "7.2.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", upload-time = 2026-01-28T18:14:54Z, size = 493740, hashes = { sha256 = "0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/63/65/37648c0c158dc222aba51c089eb3bdfa238e621674dc42d48706e639204f/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-01-28T18:15:27Z, size = 156997, hashes = { sha256 = "b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e" } }] + +[[packages]] +name = "ptyprocess" +version = "0.7.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", upload-time = 2020-12-28T15:15:30Z, size = 70762, hashes = { sha256 = "5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", upload-time = 2020-12-28T15:15:28Z, size = 13993, hashes = { sha256 = "4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35" } }] + +[[packages]] +name = "pure-eval" +version = "0.2.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", upload-time = 2024-07-21T12:58:21Z, size = 19752, hashes = { sha256 = "5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", upload-time = 2024-07-21T12:58:20Z, size = 11842, hashes = { sha256 = "1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0" } }] + +[[packages]] +name = "py-spy" +version = "0.4.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/93/d8/5b71371f50cf153b1307e5a11ac8a4ce4d85651dae946bd7e9a064146545/py_spy-0.4.2.tar.gz", upload-time = 2026-04-24T22:08:54Z, size = 286374, hashes = { sha256 = "90e600b27bb6bb40479637baca5a5b4bc2ba3395c93d889e672315d93042c4ae" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/89/23/3eb4c23c684ebd667674ce1d076ae855e0621d1d9bd5e052aa3f7982f757/py_spy-0.4.2-py2.py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2026-04-24T22:08:48Z, size = 2828136, hashes = { sha256 = "142887e984a4e541071c99a4401ff8c3770f255d329dbd0f64e8c1dd51882cce" } }] + +[[packages]] +name = "pyarrow" +version = "23.0.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/88/22/134986a4cc224d593c1afde5494d18ff629393d74cc2eddb176669f234a4/pyarrow-23.0.1.tar.gz", upload-time = 2026-02-16T10:14:12Z, size = 1167336, hashes = { sha256 = "b8c5873e33440b2bc2f4a79d2b47017a89c5a24116c055625e6f2ee50523f019" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/88/7c/3d841c366620e906d54430817531b877ba646310296df42ef697308c2705/pyarrow-23.0.1-cp312-cp312-manylinux_2_28_aarch64.whl", upload-time = 2026-02-16T10:10:10Z, size = 44470940, hashes = { sha256 = "86ff03fb9f1a320266e0de855dee4b17da6794c595d207f89bba40d16b5c78b9" } }] + +[[packages]] +name = "pybase64" +version = "1.4.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/aa/b8/4ed5c7ad5ec15b08d35cc79ace6145d5c1ae426e46435f4987379439dfea/pybase64-1.4.3.tar.gz", upload-time = 2025-12-06T13:27:04Z, size = 137272, hashes = { sha256 = "c2ed274c9e0ba9c8f9c4083cfe265e66dd679126cd9c2027965d807352f3f053" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/03/4b/a3b5175130b3810bbb8ccfa1edaadbd3afddb9992d877c8a1e2f274b476e/pybase64-1.4.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", upload-time = 2025-12-06T13:23:21Z, size = 59922, hashes = { sha256 = "356ef1d74648ce997f5a777cf8f1aefecc1c0b4fe6201e0ef3ec8a08170e1b54" } }] + +[[packages]] +name = "pycountry" +version = "26.2.16" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/de/1d/061b9e7a48b85cfd69f33c33d2ef784a531c359399ad764243399673c8f5/pycountry-26.2.16.tar.gz", upload-time = 2026-02-17T03:42:52Z, size = 7711342, hashes = { sha256 = "5b6027d453fcd6060112b951dd010f01f168b51b4bf8a1f1fc8c95c8d94a0801" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9c/42/7703bd45b62fecd44cd7d3495423097e2f7d28bc2e99e7c1af68892ab157/pycountry-26.2.16-py3-none-any.whl", upload-time = 2026-02-17T03:42:49Z, size = 8044600, hashes = { sha256 = "115c4baf7cceaa30f59a4694d79483c9167dbce7a9de4d3d571c5f3ea77c305a" } }] + +[[packages]] +name = "pycparser" +version = "3.0" +marker = "implementation_name != 'PyPy' and sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", upload-time = 2026-01-21T14:26:51Z, size = 103492, hashes = { sha256 = "600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", upload-time = 2026-01-21T14:26:50Z, size = 48172, hashes = { sha256 = "b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992" } }] + +[[packages]] +name = "pycryptodomex" +version = "3.24.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/f4/e7/50e72301e32acb73a314e663c2014e1ddefc019d5f434ff14ec89861d664/pycryptodomex-3.24.1.tar.gz", upload-time = 2026-10-11T19:26:49Z, size = 4934627, hashes = { sha256 = "09081666ffc599976c0b8b29caf2cf82212c0f05bed233c8f8ed53e4f6e1d356" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3b/5f/44916f6aa08a08b34b3ce41e2282d36149aa416a8edca9dbecd7c07e0a10/pycryptodomex-3.24.1-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", upload-time = 2026-10-11T19:26:15Z, size = 2194142, hashes = { sha256 = "9a732b9f5603b153dcdc071d6b342f192981907519827f2c1e4aeac41e2b34c2" } }] + +[[packages]] +name = "pydantic" +version = "2.12.5" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", upload-time = 2025-11-26T15:11:46Z, size = 821591, hashes = { sha256 = "4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", upload-time = 2025-11-26T15:11:44Z, size = 463580, hashes = { sha256 = "e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d" } }] + +[[packages]] +name = "pydantic-core" +version = "2.41.5" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", upload-time = 2025-11-04T13:43:49Z, size = 460952, hashes = { sha256 = "08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2025-11-04T13:40:02Z, size = 1919200, hashes = { sha256 = "e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69" } }] + +[[packages]] +name = "pydantic-extra-types" +version = "2.11.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/66/71/dba38ee2651f84f7842206adbd2233d8bbdb59fb85e9fa14232486a8c471/pydantic_extra_types-2.11.1.tar.gz", upload-time = 2026-03-16T08:08:03Z, size = 172002, hashes = { sha256 = "46792d2307383859e923d8fcefa82108b1a141f8a9c0198982b3832ab5ef1049" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/17/c1/3226e6d7f5a4f736f38ac11a6fbb262d701889802595cdb0f53a885ac2e0/pydantic_extra_types-2.11.1-py3-none-any.whl", upload-time = 2026-03-16T08:08:02Z, size = 79526, hashes = { sha256 = "1722ea2bddae5628ace25f2aa685b69978ef533123e5638cfbddb999e0100ec1" } }] + +[[packages]] +name = "pygments" +version = "2.20.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", upload-time = 2026-03-29T13:29:33Z, size = 4955991, hashes = { sha256 = "6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", upload-time = 2026-03-29T13:29:30Z, size = 1231151, hashes = { sha256 = "81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176" } }] + +[[packages]] +name = "pyproject-hooks" +version = "1.2.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/e7/82/28175b2414effca1cdac8dc99f76d660e7a4fb0ceefa4b4ab8f5f6742925/pyproject_hooks-1.2.0.tar.gz", upload-time = 2024-09-29T09:24:13Z, size = 19228, hashes = { sha256 = "1e859bd5c40fae9448642dd871adf459e5e2084186e8d2c2a79a824c970da1f8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/bd/24/12818598c362d7f300f18e74db45963dbcb85150324092410c8b49405e42/pyproject_hooks-1.2.0-py3-none-any.whl", upload-time = 2024-09-29T09:24:11Z, size = 10216, hashes = { sha256 = "9e5c6bfa8dcc30091c74b0cf803c81fdd29d94f01992a7707bc97babb1141913" } }] + +[[packages]] +name = "python-dateutil" +version = "2.9.0.post0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", upload-time = 2024-03-01T18:36:20Z, size = 342432, hashes = { sha256 = "37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", upload-time = 2024-03-01T18:36:18Z, size = 229892, hashes = { sha256 = "a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427" } }] + +[[packages]] +name = "python-multipart" +version = "0.0.32" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/5b/42/55c32bb9b12693c092ad250a0e82edb5b31ddeda6eb772de5f308b3804ad/python_multipart-0.0.32.tar.gz", upload-time = 2026-06-04T16:18:58Z, size = 46881, hashes = { sha256 = "be54b7f3fa167bb83e4fcd936b887b708f4e57fe75911c02aebf53efaf8d938e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e1/04/e8135ebd1ad02c56ec633277529b2602ff99ff634be76cdba5744cf554fd/python_multipart-0.0.32-py3-none-any.whl", upload-time = 2026-06-04T16:18:57Z, size = 30042, hashes = { sha256 = "ff6d3f776f16878c894e52e107296ffc890e913c611b1a4ec6c44e2821fe2e23" } }] + +[[packages]] +name = "pytz" +version = "2026.1.post1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/56/db/b8721d71d945e6a8ac63c0fc900b2067181dbb50805958d4d4661cf7d277/pytz-2026.1.post1.tar.gz", upload-time = 2026-03-03T07:47:50Z, size = 321088, hashes = { sha256 = "3378dde6a0c3d26719182142c56e60c7f9af7e968076f31aae569d72a0358ee1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/10/99/781fe0c827be2742bcc775efefccb3b048a3a9c6ce9aec0cbf4a101677e5/pytz-2026.1.post1-py2.py3-none-any.whl", upload-time = 2026-03-03T07:47:49Z, size = 510489, hashes = { sha256 = "f2fd16142fda348286a75e1a524be810bb05d444e5a081f37f7affc635035f7a" } }] + +[[packages]] +name = "pyyaml" +version = "6.0.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", upload-time = 2025-09-25T21:33:16Z, size = 130960, hashes = { sha256 = "d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2025-09-25T21:32:13Z, size = 775116, hashes = { sha256 = "9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28" } }] + +[[packages]] +name = "pyzmq" +version = "27.2.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/e7/8d/5b3d5631c2f4b4b8862f64cd0c9eb777b5710eeb5125b4be8dd0a200a4c0/pyzmq-27.2.0.tar.gz", upload-time = 2026-08-20T19:08:21Z, size = 292316, hashes = { sha256 = "54d4259d1bfae24ecdb5ca79f7acc2eac6c286a02d6a0ae617797cb45f0726d3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b4/78/a3a3a86c2b00fadb92ece1ca4f8f028d62b2ce9ac3526097239ab2d6fba9/pyzmq-27.2.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-08-20T19:06:43Z, size = 697722, hashes = { sha256 = "1f8079d0521fe94bbb401fe9407578b28f3701627c8be2c9f7e0c5b77dcb0109" } }] + +[[packages]] +name = "quack-kernels" +version = "0.6.5" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/5f/18/6c2a20d00dff254f154fb3b951f4e5a0377a60122c17385e5f08d5f5b5e1/quack_kernels-0.6.5.tar.gz", upload-time = 2026-09-11T05:08:20Z, size = 846876, hashes = { sha256 = "dd9405a4a6fa35fc3a5a18fe35b46a14b0bf7e3ad9fe2451903e355047ac471d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/73/d8/f5e56c38b286308d115a171e3c5c44f24e9d03980c3cfd22588df40261fa/quack_kernels-0.6.5-py3-none-any.whl", upload-time = 2026-09-11T05:08:19Z, size = 729615, hashes = { sha256 = "df1ddd31366c82eb9692fe087c671209189dcbde53c909c81a865d4ee66b158d" } }] + +[[packages]] +name = "referencing" +version = "0.37.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", upload-time = 2025-10-13T15:30:48Z, size = 78036, hashes = { sha256 = "44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", upload-time = 2025-10-13T15:30:47Z, size = 26766, hashes = { sha256 = "381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231" } }] + +[[packages]] +name = "regex" +version = "2026.4.4" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/cb/0e/3a246dbf05666918bd3664d9d787f84a9108f6f43cc953a077e4a7dfdb7e/regex-2026.4.4.tar.gz", upload-time = 2026-04-03T20:56:28Z, size = 416000, hashes = { sha256 = "e08270659717f6973523ce3afbafa53515c4dc5dcad637dc215b6fd50f689423" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/31/87/3accf55634caad8c0acab23f5135ef7d4a21c39f28c55c816ae012931408/regex-2026.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-04-03T20:53:45Z, size = 796651, hashes = { sha256 = "760ef21c17d8e6a4fe8cf406a97cf2806a4df93416ccc82fc98d25b1c20425be" } }] + +[[packages]] +name = "requests" +version = "2.33.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/5f/a4/98b9c7c6428a668bf7e42ebb7c79d576a1c3c1e3ae2d47e674b468388871/requests-2.33.1.tar.gz", upload-time = 2026-03-30T16:09:15Z, size = 134120, hashes = { sha256 = "18817f8c57c6263968bc123d237e3b8b08ac046f5456bd1e307ee8f4250d3517" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", upload-time = 2026-03-30T16:09:13Z, size = 64947, hashes = { sha256 = "4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a" } }] + +[[packages]] +name = "rich" +version = "13.9.4" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", upload-time = 2024-11-01T16:43:57Z, size = 223149, hashes = { sha256 = "439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", upload-time = 2024-11-01T16:43:55Z, size = 242424, hashes = { sha256 = "6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90" } }] + +[[packages]] +name = "rpds-py" +version = "0.30.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", upload-time = 2025-11-30T20:24:38Z, size = 69469, hashes = { sha256 = "dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/65/1c/ae157e83a6357eceff62ba7e52113e3ec4834a84cfe07fa4b0757a7d105f/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2025-11-30T20:22:21Z, size = 390763, hashes = { sha256 = "ca28829ae5f5d569bb62a79512c842a03a12576375d5ece7d2cadf8abe96ec28" } }] + +[[packages]] +name = "safetensors" +version = "0.7.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/29/9c/6e74567782559a63bd040a236edca26fd71bc7ba88de2ef35d75df3bca5e/safetensors-0.7.0.tar.gz", upload-time = 2025-11-19T15:18:43Z, size = 200878, hashes = { sha256 = "07663963b67e8bd9f0b8ad15bb9163606cd27cc5a1b96235a50d8369803b96b0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f1/06/578ffed52c2296f93d7fd2d844cabfa92be51a587c38c8afbb8ae449ca89/safetensors-0.7.0-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2025-11-19T15:18:09Z, size = 491748, hashes = { sha256 = "e07d91d0c92a31200f25351f4acb2bc6aff7f48094e13ebb1d0fb995b54b6542" } }] + +[[packages]] +name = "scipy" +version = "1.17.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", upload-time = 2026-02-23T00:26:24Z, size = 30573822, hashes = { sha256 = "95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/da/34/16f10e3042d2f1d6b66e0428308ab52224b6a23049cb2f5c1756f713815f/scipy-1.17.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-02-23T00:18:35Z, size = 32927842, hashes = { sha256 = "e19ebea31758fac5893a2ac360fedd00116cbb7628e650842a6691ba7ca28a21" } }] + +[[packages]] +name = "sentencepiece" +version = "0.2.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/15/15/2e7a025fc62d764b151ae6d0f2a92f8081755ebe8d4a64099accc6f77ba6/sentencepiece-0.2.1.tar.gz", upload-time = 2025-08-12T07:00:51Z, size = 3228515, hashes = { sha256 = "8138cec27c2f2282f4a34d9a016e3374cd40e5c6e9cb335063db66a0a3b71fad" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/89/fa/d3d5ebcba3cb9e6d3775a096251860c41a6bc53a1b9461151df83fe93255/sentencepiece-0.2.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2025-08-12T06:59:44Z, size = 1316273, hashes = { sha256 = "99f955df238021bf11f0fc37cdb54fd5e5b5f7fd30ecc3d93fb48b6815437167" } }] + +[[packages]] +name = "setproctitle" +version = "1.3.8" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/49/b0/6b8a516c5a9e9630bd5293db78314ac012f690305fe93beadea388626efb/setproctitle-1.3.8.tar.gz", upload-time = 2026-10-01T21:09:27Z, size = 27214, hashes = { sha256 = "cafe209d064a6efb88cb45a03e97981ff8832802b2b5d009dde0197a3b7b41c8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5f/07/1476dafdbf5d124a05ae4856272908c0796fa65844376a32bb066f04afda/setproctitle-1.3.8-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-10-01T20:59:15Z, size = 33765, hashes = { sha256 = "f61345393548bc72844d837d62fcf63444b0f5dac418544beb6d4f628a1c5df3" } }] + +[[packages]] +name = "setuptools" +version = "83.0.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/34/26/f5d29e25ffdb535afef2d35cdb55b325298f96debd670da4c325e08d70f4/setuptools-83.0.0.tar.gz", upload-time = 2026-07-04T15:31:22Z, size = 1154254, hashes = { sha256 = "025bccbbf0fa05b6192bc64ae1e7b16e001fd6d6d4d5de03c97b1c1ade523bef" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5d/40/e1e72872c6354b306daef1703549e8e83b4d43cfea356311bf722a043752/setuptools-83.0.0-py3-none-any.whl", upload-time = 2026-07-04T15:31:20Z, size = 1008090, hashes = { sha256 = "29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3" } }] + +[[packages]] +name = "sglang" +version = "0.5.10.post1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/42/38/feb04f6478b90315606fcd62b798917e7fcee9f1d7d84b01cf477398045e/sglang-0.5.10.post1.tar.gz", upload-time = 2026-04-08T22:20:07Z, size = 4701855, hashes = { sha256 = "01f7adfe7cde85b238fb0e1bae4b31d494e19d1471cf35ff3c5489a02f9d2263" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/15/26/f6b6fc49166a716cf79787555118dfe6254786fa1d9c01be0fea17b4f578/sglang-0.5.10.post1-py3-none-any.whl", upload-time = 2026-04-08T22:20:05Z, size = 6064493, hashes = { sha256 = "a854a68b11caf6b4b55c241a44378a7cdede7ede325db85c955f131506703bc6" } }] + +[[packages]] +name = "sglang-kernel" +version = "0.4.1" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/62/8d/6923baa7447a758b38a0ed0b2ee5b89bd13b1e35ee14f72114bbbf8fb3e6/sglang_kernel-0.4.1-cp310-abi3-manylinux2014_aarch64.whl", upload-time = 2026-04-03T09:54:03Z, size = 212840645, hashes = { sha256 = "c4df0c48f167fa95b77dbdd8f04293b305159e438d8797ca96009e02a7554406" } }] + +[[packages]] +name = "shellingham" +version = "1.5.4" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", upload-time = 2023-10-24T04:13:40Z, size = 10310, hashes = { sha256 = "8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", upload-time = 2023-10-24T04:13:38Z, size = 9755, hashes = { sha256 = "7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686" } }] + +[[packages]] +name = "six" +version = "1.17.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", upload-time = 2024-12-04T17:35:28Z, size = 34031, hashes = { sha256 = "ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", upload-time = 2024-12-04T17:35:26Z, size = 11050, hashes = { sha256 = "4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274" } }] + +[[packages]] +name = "smg-grpc-proto" +version = "0.4.10" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/70/c4/e7fd91bf161fcaeb9c19e5fba73e54f7501bd310078d644700e627c4d7f9/smg_grpc_proto-0.4.10.tar.gz", upload-time = 2026-06-11T16:10:05Z, size = 19304, hashes = { sha256 = "5415618d252e5a2b43d1dbbd2c1eae305760070dd24735308140aed06a7486be" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/67/0d/d2f57ac38d2ecc9593ade6ee99953c2b2ea27e10e9532f69e3c47d2528dc/smg_grpc_proto-0.4.10-py3-none-any.whl", upload-time = 2026-06-11T16:10:04Z, size = 81122, hashes = { sha256 = "cf62b930b541ea117696d0decc2f3bd9f1f8811d066a37340e53adce3a535ccc" } }] + +[[packages]] +name = "smg-grpc-servicer" +version = "0.5.6" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/38/fa/fde2418c3e651bb20feba30ee13718cb4ac786a23c34969c5c7a9b0959ec/smg_grpc_servicer-0.5.6.tar.gz", upload-time = 2026-06-17T15:27:30Z, size = 88730, hashes = { sha256 = "b8e5f06a57537689888f67ea7a7d5b1f080038a3c8aada129098529245d185c0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/15/36/2b08a588c2b869ad072882883be4f31349beac6468b93db03f1608505796/smg_grpc_servicer-0.5.6-py3-none-any.whl", upload-time = 2026-06-17T15:27:29Z, size = 91597, hashes = { sha256 = "d583be1c1b6f5fa790b735feca21c870120d37d8b4d79b4641a4bf9c34203d97" } }] + +[[packages]] +name = "sniffio" +version = "1.3.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", upload-time = 2024-02-25T23:20:04Z, size = 20372, hashes = { sha256 = "f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", upload-time = 2024-02-25T23:20:01Z, size = 10235, hashes = { sha256 = "2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2" } }] + +[[packages]] +name = "soundfile" +version = "0.13.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/e1/41/9b873a8c055582859b239be17902a85339bec6a30ad162f98c9b0288a2cc/soundfile-0.13.1.tar.gz", upload-time = 2025-01-25T09:17:04Z, size = 46156, hashes = { sha256 = "b2c68dab1e30297317080a5b43df57e302584c49e2942defdde0acccc53f0e5b" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/28/e2a36573ccbcf3d57c00626a21fe51989380636e821b341d36ccca0c1c3a/soundfile-0.13.1-py2.py3-none-any.whl", upload-time = 2025-01-25T09:16:44Z, size = 25751, hashes = { sha256 = "a23c717560da2cf4c7b5ae1142514e0fd82d6bbd9dfc93a50423447142f2c445" } }, + { url = "https://files.pythonhosted.org/packages/58/ae/c0e4a53d77cf6e9a04179535766b3321b0b9ced5f70522e4caf9329f0046/soundfile-0.13.1-py2.py3-none-manylinux_2_28_aarch64.whl", upload-time = 2025-01-25T09:16:53Z, size = 1235729, hashes = { sha256 = "9c9e855f5a4d06ce4213f31918653ab7de0c5a8d8107cd2427e44b42df547deb" } }, +] + +[[packages]] +name = "stack-data" +version = "0.6.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", upload-time = 2023-09-30T13:58:05Z, size = 44707, hashes = { sha256 = "836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", upload-time = 2023-09-30T13:58:03Z, size = 24521, hashes = { sha256 = "d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695" } }] + +[[packages]] +name = "starlette" +version = "1.3.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/eb/e3/7c1dc7381d9f8ab7d854328ebfa884e62cb3f3d8549ddfd37c7814f42afa/starlette-1.3.1.tar.gz", upload-time = 2026-06-12T09:23:11Z, size = 2703240, hashes = { sha256 = "05d0213193f2fbaae60e2ecb593b4add4262ad4e46536b54abe36f11a71724e0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ec/bb/2799cc2ede3ed41131f8975621e7213dfc7ef4acbbaadfa440f32500c370/starlette-1.3.1-py3-none-any.whl", upload-time = 2026-06-12T09:23:10Z, size = 73632, hashes = { sha256 = "c7372aae11c3c3f26a42df7bd626cec2f47d03483d261d369516a615a53714c6" } }] + +[[packages]] +name = "sympy" +version = "1.14.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", upload-time = 2025-04-27T18:05:01Z, size = 7793921, hashes = { sha256 = "d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", upload-time = 2025-04-27T18:04:59Z, size = 6299353, hashes = { sha256 = "e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5" } }] + +[[packages]] +name = "tabulate" +version = "0.10.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/46/58/8c37dea7bbf769b20d58e7ace7e5edfe65b849442b00ffcdd56be88697c6/tabulate-0.10.0.tar.gz", upload-time = 2026-03-04T18:55:34Z, size = 91754, hashes = { sha256 = "e2cfde8f79420f6deeffdeda9aaec3b6bc5abce947655d17ac662b126e48a60d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/99/55/db07de81b5c630da5cbf5c7df646580ca26dfaefa593667fc6f2fe016d2e/tabulate-0.10.0-py3-none-any.whl", upload-time = 2026-03-04T18:55:31Z, size = 39814, hashes = { sha256 = "f0b0622e567335c8fabaaa659f1b33bcb6ddfe2e496071b743aa113f8774f2d3" } }] + +[[packages]] +name = "tiktoken" +version = "0.12.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/7d/ab/4d017d0f76ec3171d469d80fc03dfbb4e48a4bcaddaa831b31d526f05edc/tiktoken-0.12.0.tar.gz", upload-time = 2025-10-06T20:22:45Z, size = 37806, hashes = { sha256 = "b18ba7ee2b093863978fcb14f74b3707cdc8d4d4d3836853ce7ec60772139931" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/66/c5/ed88504d2f4a5fd6856990b230b56d85a777feab84e6129af0822f5d0f70/tiktoken-0.12.0-cp312-cp312-manylinux_2_28_aarch64.whl", upload-time = 2025-10-06T20:21:54Z, size = 1129008, hashes = { sha256 = "65b26c7a780e2139e73acc193e5c63ac754021f160df919add909c1492c0fb37" } }] + +[[packages]] +name = "timm" +version = "1.0.16" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/94/f6/4d7a8c261341fa6ad281920618739f2a650f41043afcedb570f24e99a776/timm-1.0.16.tar.gz", upload-time = 2025-06-26T17:09:44Z, size = 2339999, hashes = { sha256 = "a3b8130dd2cb8dc3b9f5e3d09ab6d677a6315a8695fd5264eb6d52a4a46c1044" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3b/14/10d0ea58a7580b8bd7c8d69420b3dc3a1deb890d4ff297deca9717689598/timm-1.0.16-py3-none-any.whl", upload-time = 2025-06-26T17:09:42Z, size = 2485733, hashes = { sha256 = "a640e58f4ae41e0445517d1133b34be75bb2bd49cdb830d739925ce1fb7d2526" } }] + +[[packages]] +name = "tokenizers" +version = "0.22.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/73/6f/f80cfef4a312e1fb34baf7d85c72d4411afde10978d4657f8cdd811d3ccc/tokenizers-0.22.2.tar.gz", upload-time = 2026-01-05T10:45:15Z, size = 372115, hashes = { sha256 = "473b83b915e547aa366d1eee11806deaf419e17be16310ac0a14077f1e28f917" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d6/84/7990e799f1309a8b87af6b948f31edaa12a3ed22d11b352eaf4f4b2e5753/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2026-01-05T10:40:32Z, size = 3290736, hashes = { sha256 = "2249487018adec45d6e3554c71d46eb39fa8ea67156c640f7513eb26f318cec7" } }] + +[[packages]] +name = "torch" +version = "2.9.1+cpu" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://download-r2.pytorch.org/whl/cpu/torch-2.9.1%2Bcpu-cp312-cp312-manylinux_2_28_aarch64.whl", upload-time = 2026-01-23T15:13:02Z, hashes = { sha256 = "3bf9b442a51a2948e41216a76d7ab00f0694cfcaaa51b6f9bcab57b7f89843e6" } }] + +[[packages]] +name = "torch-c-dlpack-ext" +version = "0.1.5" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/37/de/921b6491efce5c389a5ef9bbed3d2d6660005840dae488124173180859ab/torch_c_dlpack_ext-0.1.5.tar.gz", upload-time = 2026-01-12T11:25:08Z, size = 12913, hashes = { sha256 = "d06f0357d575d22a168cc77acb9020fc4bae30968ceb6718a055dcbe92bacabe" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/87/06/8d760997307a5c3be4384424667bf31aae0a42060838c532c7d846516175/torch_c_dlpack_ext-0.1.5-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-01-12T11:24:45Z, size = 443069, hashes = { sha256 = "3562ee411258676f9c38b8ad39306d1c8d027b6a86f6a87c920d2d009a9d1510" } }] + +[[packages]] +name = "torch-memory-saver" +version = "0.0.9" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/28/6c/21dfda5d31afb71f52cedff52370acbb8290485b3f0fee6816a15a3d08f1/torch_memory_saver-0.0.9.tar.gz", upload-time = 2025-10-18T02:10:18Z, size = 14220, hashes = { sha256 = "3bbf76391fb16870b1b0df279fc281c8a05ef8f8809400b309b0a8240e8ee5ba" } } + +[[packages]] +name = "torchao" +version = "0.9.0+cpu" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://download.pytorch.org/whl/cpu/torchao-0.9.0%2Bcpu-py3-none-any.whl", upload-time = 2025-02-28T14:07:42Z, hashes = { sha256 = "69a488afe0cc82048dfd1f143fd66e26afdcbe7015d3bf054060d377ff4d6d63" } }] + +[[packages]] +name = "torchaudio" +version = "2.9.1" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://download-r2.pytorch.org/whl/cpu/torchaudio-2.9.1-cp312-cp312-manylinux_2_28_aarch64.whl", upload-time = 2025-11-11T19:16:58Z, hashes = { sha256 = "f6fa882b750385fdb0a2aa5215a6a04b97cf9668b37617038a814c7630b2dc8d" } }] + +[[packages]] +name = "torchvision" +version = "0.24.1" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://download-r2.pytorch.org/whl/cpu/torchvision-0.24.1-cp312-cp312-manylinux_2_28_aarch64.whl", upload-time = 2025-11-15T18:12:46Z, hashes = { sha256 = "28157649758fb97491de0db478d5d6e73c23b508e54de20adbc35e6b3aa72443" } }] + +[[packages]] +name = "tqdm" +version = "4.67.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/09/a9/6ba95a270c6f1fbcd8dac228323f2777d886cb206987444e4bce66338dd4/tqdm-4.67.3.tar.gz", upload-time = 2026-02-03T17:35:53Z, size = 169598, hashes = { sha256 = "7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", upload-time = 2026-02-03T17:35:50Z, size = 78374, hashes = { sha256 = "ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf" } }] + +[[packages]] +name = "traitlets" +version = "5.14.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", upload-time = 2024-04-19T11:11:49Z, size = 161621, hashes = { sha256 = "9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", upload-time = 2024-04-19T11:11:46Z, size = 85359, hashes = { sha256 = "b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f" } }] + +[[packages]] +name = "transformers" +version = "5.3.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/fc/1a/70e830d53ecc96ce69cfa8de38f163712d2b43ac52fbd743f39f56025c31/transformers-5.3.0.tar.gz", upload-time = 2026-03-04T17:41:46Z, size = 8830831, hashes = { sha256 = "009555b364029da9e2946d41f1c5de9f15e6b1df46b189b7293f33a161b9c557" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b8/88/ae8320064e32679a5429a2c9ebbc05c2bf32cefb6e076f9b07f6d685a9b4/transformers-5.3.0-py3-none-any.whl", upload-time = 2026-03-04T17:41:42Z, size = 10661827, hashes = { sha256 = "50ac8c89c3c7033444fb3f9f53138096b997ebb70d4b5e50a2e810bf12d3d29a" } }] + +[[packages]] +name = "truststore" +version = "0.10.5" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ee/9f/c5201d42a484c061e528825fc8e2d565f5abd50a4ced6fb7d29c4ec99b2b/truststore-0.10.5.tar.gz", upload-time = 2026-10-12T22:27:31Z, size = 28091, hashes = { sha256 = "30d36967ccaded5cbb38d602c433f53600036c79d502f4533a49b60a03bbefcd" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/51/e9/3a7820be2bb0fe53b6bc9c3be26d3d1158004e4c3ab953aa6840b955b1e9/truststore-0.10.5-py3-none-any.whl", upload-time = 2026-10-12T22:27:30Z, size = 19017, hashes = { sha256 = "9aaaedaefaf06d8b206278cf8b5012bc897f485a874503501e12d776df78951c" } }] + +[[packages]] +name = "typer" +version = "0.21.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/f2/1e/a27cc02a0cd715118c71fa2aef2c687fdefc3c28d90fd0dd789c5118154c/typer-0.21.2.tar.gz", upload-time = 2026-02-10T19:33:46Z, size = 120426, hashes = { sha256 = "1abd95a3b675e17ff61b0838ac637fe9478d446d62ad17fa4bb81ea57cc54028" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b8/cc/d59f893fbdfb5f58770c05febfc4086a46875f1084453621c35605cec946/typer-0.21.2-py3-none-any.whl", upload-time = 2026-02-10T19:33:48Z, size = 56728, hashes = { sha256 = "c3d8de54d00347ef90b82131ca946274f017cffb46683ae3883c360fa958f55c" } }] + +[[packages]] +name = "typing-extensions" +version = "4.15.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", upload-time = 2025-08-25T13:49:26Z, size = 109391, hashes = { sha256 = "0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", upload-time = 2025-08-25T13:49:24Z, size = 44614, hashes = { sha256 = "f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548" } }] + +[[packages]] +name = "typing-inspection" +version = "0.4.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", upload-time = 2025-10-01T02:14:41Z, size = 75949, hashes = { sha256 = "ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", upload-time = 2025-10-01T02:14:40Z, size = 14611, hashes = { sha256 = "4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7" } }] + +[[packages]] +name = "tzdata" +version = "2026.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ba/19/1b9b0e29f30c6d35cb345486df41110984ea67ae69dddbc0e8a100999493/tzdata-2026.2.tar.gz", upload-time = 2026-04-24T15:22:08Z, size = 198254, hashes = { sha256 = "9173fde7d80d9018e02a662e168e5a2d04f87c41ea174b139fbef642eda62d10" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ce/e4/dccd7f47c4b64213ac01ef921a1337ee6e30e8c6466046018326977efd95/tzdata-2026.2-py2.py3-none-any.whl", upload-time = 2026-04-24T15:22:05Z, size = 349321, hashes = { sha256 = "bbe9af844f658da81a5f95019480da3a89415801f6cc966806612cc7169bffe7" } }] + +[[packages]] +name = "urllib3" +version = "2.7.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", upload-time = 2026-05-07T16:13:18Z, size = 433602, hashes = { sha256 = "231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", upload-time = 2026-05-07T16:13:17Z, size = 131087, hashes = { sha256 = "9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897" } }] + +[[packages]] +name = "uvicorn" +version = "0.46.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/1f/93/041fca8274050e40e6791f267d82e0e2e27dd165627bd640d3e0e378d877/uvicorn-0.46.0.tar.gz", upload-time = 2026-04-23T07:16:00Z, size = 88758, hashes = { sha256 = "fb9da0926999cc6cb22dc7cd71a94a632f078e6ae47ff683c5c420750fb7413d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/31/a3/5b1562db76a5a488274b2332a97199b32d0442aca0ed193697fd47786316/uvicorn-0.46.0-py3-none-any.whl", upload-time = 2026-04-23T07:15:58Z, size = 70926, hashes = { sha256 = "bbebbcbed972d162afca128605223022bedd345b7bc7855ce66deb31487a9048" } }] + +[[packages]] +name = "uvloop" +version = "0.22.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", upload-time = 2025-10-16T22:17:19Z, size = 2443250, hashes = { sha256 = "6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/24/68/a6ac446820273e71aa762fa21cdcc09861edd3536ff47c5cd3b7afb10eeb/uvloop-0.22.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2025-10-16T22:16:31Z, size = 4317413, hashes = { sha256 = "700e674a166ca5778255e0e1dc4e9d79ab2acc57b9171b79e65feba7184b3370" } }] + +[[packages]] +name = "watchfiles" +version = "1.1.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8869df9b2a2d6c59d79220a4db37679e74f807c559ffe5265e08b227a210/watchfiles-1.1.1.tar.gz", upload-time = 2025-10-14T15:06:21Z, size = 94440, hashes = { sha256 = "a173cb5c16c4f40ab19cecf48a534c409f7ea983ab8fed0741304a1c0a31b3f2" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/4b/5b/d3b460364aeb8da471c1989238ea0e56bec24b6042a68046adf3d9ddb01c/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2025-10-14T15:04:49Z, size = 449374, hashes = { sha256 = "8526e8f916bb5b9a0a777c8317c23ce65de259422bba5b31325a6fa6029d33af" } }] + +[[packages]] +name = "wcwidth" +version = "0.6.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/35/a2/8e3becb46433538a38726c948d3399905a4c7cabd0df578ede5dc51f0ec2/wcwidth-0.6.0.tar.gz", upload-time = 2026-02-06T19:19:40Z, size = 159684, hashes = { sha256 = "cdc4e4262d6ef9a1a57e018384cbeb1208d8abbc64176027e2c2455c81313159" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/68/5a/199c59e0a824a3db2b89c5d2dade7ab5f9624dbf6448dc291b46d5ec94d3/wcwidth-0.6.0-py3-none-any.whl", upload-time = 2026-02-06T19:19:39Z, size = 94189, hashes = { sha256 = "1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad" } }] + +[[packages]] +name = "xgrammar" +version = "0.1.32" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/99/6a/d51b44fc0b43e2d4adae42b6a17fe9ee49e177d6d768be739ed7dec7b57e/xgrammar-0.1.32.tar.gz", upload-time = 2026-03-04T12:01:52Z, size = 2365047, hashes = { sha256 = "5d424d52779ca2d3ccaf72f2289d6519efe308e933d0d3fc3c292c780825bb12" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/79/29/3b0306800ccabce8f565123a5b97432dee43822c30142085d9b13b43f166/xgrammar-0.1.32-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-03-04T12:00:46Z, size = 37680849, hashes = { sha256 = "f9a637d4e0c541149e0d409c24f4ec79cd74d87508ee6a17a7e64a9b9c0cf56f" } }] + +[[packages]] +name = "xxhash" +version = "3.7.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/24/2f/e183a1b407002f5af81822bee18b61cdb94b8670208ef34734d8d2b8ebe9/xxhash-3.7.0.tar.gz", upload-time = 2026-04-25T11:10:32Z, size = 82022, hashes = { sha256 = "6cc4eefbb542a5d6ffd6d70ea9c502957c925e800f998c5630ecc809d6702bae" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/87/ee/2f9f2ed993e77206d1e66991290a1ebe22e843351ca3ebec8e49e01ba186/xxhash-3.7.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-04-25T11:06:25Z, size = 212977, hashes = { sha256 = "f3e7b689c3bce16699efcf736066f5c6cc4472c3840fe4b22bd8279daf4abdac" } }] + +[[packages]] +name = "yarl" +version = "1.23.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", upload-time = 2026-03-01T22:07:53Z, size = 194676, hashes = { sha256 = "53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/30/58260ed98e6ff7f90ba84442c1ddd758c9170d70327394a6227b310cd60f/yarl-1.23.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-03-01T22:05:17Z, size = 97587, hashes = { sha256 = "9cbf44c5cb4a7633d078788e1b56387e3d3cf2b8139a3be38040b22d6c3221c8" } }, + { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", upload-time = 2026-03-01T22:07:51Z, size = 48288, hashes = { sha256 = "a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f" } }, +] + +[[packages]] +name = "zipp" +version = "3.23.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/30/21/093488dfc7cc8964ded15ab726fad40f25fd3d788fd741cc1c5a17d78ee8/zipp-3.23.1.tar.gz", upload-time = 2026-04-13T23:21:46Z, size = 25965, hashes = { sha256 = "32120e378d32cd9714ad503c1d024619063ec28aad2248dc6672ad13edfa5110" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/08/8a/0861bec20485572fbddf3dfba2910e38fe249796cb73ecdeb74e07eeb8d3/zipp-3.23.1-py3-none-any.whl", upload-time = 2026-04-13T23:21:45Z, size = 10378, hashes = { sha256 = "0b3596c50a5c700c9cb40ba8d86d9f2cc4807e9bedb06bcdf7fac85633e444dc" } }] diff --git a/packages/sie_server/bundle-locks/cpu-transformers5-amd64/manifest.json b/packages/sie_server/bundle-locks/cpu-transformers5-amd64/manifest.json new file mode 100644 index 000000000..9ef5ac69e --- /dev/null +++ b/packages/sie_server/bundle-locks/cpu-transformers5-amd64/manifest.json @@ -0,0 +1,39 @@ +{ + "completed_artifact_hashes": [ + { + "bytes": 134899, + "sha256": "85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", + "url": "https://download.pytorch.org/whl/jinja2-3.1.6-py3-none-any.whl" + }, + { + "bytes": 22947, + "sha256": "d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", + "url": "https://download.pytorch.org/whl/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl" + } + ], + "exceptions_sha256": "5c29066935461a1e1078d98330401efc346b54b44619d978acfda39cb9497dde", + "exclude_newer": "2026-10-18T00:00:00Z", + "indexes": [ + "--default-index", + "https://pypi.org/simple", + "--index", + "https://download.pytorch.org/whl/cpu", + "--index-strategy", + "unsafe-best-match" + ], + "inputs": { + "requirements_sha256": "529fd129d457b6820b48a3acbb4dee1f9eb83806e0a6730f122ff3826861a3f2", + "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" + }, + "lock_sha256": "3e756b5dffc07c0527a9a3465dbab2c17a0873beefe37e39f7cbd8e68b43f6cc", + "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "schema_version": 1, + "target": { + "architecture": "amd64", + "bundle": "transformers5", + "platform": "cpu", + "python_platform": "x86_64-manylinux_2_35", + "python_version": "3.12" + }, + "uv_version": "0.9.28" +} diff --git a/packages/sie_server/bundle-locks/cpu-transformers5-amd64/pylock.toml b/packages/sie_server/bundle-locks/cpu-transformers5-amd64/pylock.toml new file mode 100644 index 000000000..7323f3376 --- /dev/null +++ b/packages/sie_server/bundle-locks/cpu-transformers5-amd64/pylock.toml @@ -0,0 +1,385 @@ +lock-version = "1.0" +created-by = "uv" +requires-python = ">=3.12" + +[[packages]] +name = "annotated-doc" +version = "0.0.4" +sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", upload-time = 2025-11-10T22:07:42Z, size = 7288, hashes = { sha256 = "fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", upload-time = 2025-11-10T22:07:40Z, size = 5303, hashes = { sha256 = "571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320" } }] + +[[packages]] +name = "annotated-types" +version = "0.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", upload-time = 2024-05-20T21:33:25Z, size = 16081, hashes = { sha256 = "aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", upload-time = 2024-05-20T21:33:24Z, size = 13643, hashes = { sha256 = "1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53" } }] + +[[packages]] +name = "anyio" +version = "4.14.2" +sdist = { url = "https://files.pythonhosted.org/packages/61/cc/a381afa6efea9f496eff839d4a6a1aed3bfafc7b3ab4b0d1b243a12573dd/anyio-4.14.2.tar.gz", upload-time = 2026-07-12T20:29:07Z, size = 260176, hashes = { sha256 = "cfa139f3ed1a23ee8f88a145ddb5ac7605b8bbfd8592baacd7ce3d8bb4313c7f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/da/35/f2287558c17e29fafc8ef3daf819bb9834061cfa43bff8014f7df7f63bdc/anyio-4.14.2-py3-none-any.whl", upload-time = 2026-07-12T20:29:05Z, size = 125813, hashes = { sha256 = "9f505dda5ac9f0c8309b5e8bd445a8c2bf7246f3ce950121e45ea15bc41d1494" } }] + +[[packages]] +name = "certifi" +version = "2026.4.22" +sdist = { url = "https://files.pythonhosted.org/packages/25/ee/6caf7a40c36a1220410afe15a1cc64993a1f864871f698c0f93acb72842a/certifi-2026.4.22.tar.gz", upload-time = 2026-04-22T11:26:11Z, size = 137077, hashes = { sha256 = "8d455352a37b71bf76a79caa83a3d6c25afee4a385d632127b6afb3963f1c580" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/22/30/7cd8fdcdfbc5b869528b079bfb76dcdf6056b1a2097a662e5e8c04f42965/certifi-2026.4.22-py3-none-any.whl", upload-time = 2026-04-22T11:26:09Z, size = 135707, hashes = { sha256 = "3cb2210c8f88ba2318d29b0388d1023c8492ff72ecdde4ebdaddbb13a31b1c4a" } }] + +[[packages]] +name = "cffi" +version = "2.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", upload-time = 2025-09-08T23:24:04Z, size = 523588, hashes = { sha256 = "44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-09-08T23:22:52Z, size = 219572, hashes = { sha256 = "3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba" } }] + +[[packages]] +name = "charset-normalizer" +version = "3.4.7" +sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", upload-time = 2026-04-02T09:28:39Z, size = 144271, hashes = { sha256 = "ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4b/f8/d0118a2f5f23b02cd166fa385c60f9b0d4f9194f574e2b31cef350ad7223/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-02T09:26:29Z, size = 216589, hashes = { sha256 = "5649fd1c7bade02f320a462fdefd0b4bd3ce036065836d4f42e0de958038e116" } }, + { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", upload-time = 2026-04-02T09:28:37Z, size = 61958, hashes = { sha256 = "3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d" } }, +] + +[[packages]] +name = "click" +version = "8.1.8" +sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", upload-time = 2024-12-21T18:38:44Z, size = 226593, hashes = { sha256 = "ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", upload-time = 2024-12-21T18:38:41Z, size = 98188, hashes = { sha256 = "63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2" } }] + +[[packages]] +name = "decorator" +version = "5.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", upload-time = 2025-02-24T04:41:34Z, size = 56711, hashes = { sha256 = "65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", upload-time = 2025-02-24T04:41:32Z, size = 9190, hashes = { sha256 = "d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a" } }] + +[[packages]] +name = "filelock" +version = "3.29.0" +sdist = { url = "https://files.pythonhosted.org/packages/b5/fe/997687a931ab51049acce6fa1f23e8f01216374ea81374ddee763c493db5/filelock-3.29.0.tar.gz", upload-time = 2026-04-19T15:39:10Z, size = 57571, hashes = { sha256 = "69974355e960702e789734cb4871f884ea6fe50bd8404051a3530bc07809cf90" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/81/47/dd9a212ef6e343a6857485ffe25bba537304f1913bdbed446a23f7f592e1/filelock-3.29.0-py3-none-any.whl", upload-time = 2026-04-19T15:39:08Z, size = 39812, hashes = { sha256 = "96f5f6344709aa1572bbf631c640e4ebeeb519e08da902c39a001882f30ac258" } }] + +[[packages]] +name = "fsspec" +version = "2025.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/34/f4/5721faf47b8c499e776bc34c6a8fc17efdf7fdef0b00f398128bc5dcb4ac/fsspec-2025.3.0.tar.gz", upload-time = 2025-03-07T21:47:56Z, size = 298491, hashes = { sha256 = "a935fd1ea872591f2b5148907d103488fc523295e6c64b835cfad8c3eca44972" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/56/53/eb690efa8513166adef3e0669afd31e95ffde69fb3c52ec2ac7223ed6018/fsspec-2025.3.0-py3-none-any.whl", upload-time = 2025-03-07T21:47:54Z, size = 193615, hashes = { sha256 = "efb87af3efa9103f94ca91a7f8cb7a4df91af9f74fc106c9c7ea0efd7277c1b3" } }] + +[[packages]] +name = "gliner2" +version = "2.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/b2/a8/2dcfdb8862dbeb488b6b86047075a213cc101ca592eae1a43b824cca74dd/gliner2-2.0.0.tar.gz", upload-time = 2026-08-24T15:13:43Z, size = 565826, hashes = { sha256 = "82b149f893ba0f6adf75ef1db599b6dbecd9811cca34dbd0bac7cd9e90b90ce4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/00/44/87d2803c5c5c6c0bd22bce4d52c66c965dacae29e0121d7e04c9883711df/gliner2-2.0.0-py3-none-any.whl", upload-time = 2026-08-24T15:13:41Z, size = 326214, hashes = { sha256 = "6f7c4cba0ef3173636d8bd9404aa94d4e0ccf36d4b4b9a0d27d740dd2d3236c3" } }] + +[[packages]] +name = "h11" +version = "0.16.0" +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", upload-time = 2025-04-24T03:35:25Z, size = 101250, hashes = { sha256 = "4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", upload-time = 2025-04-24T03:35:24Z, size = 37515, hashes = { sha256 = "63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86" } }] + +[[packages]] +name = "hf-xet" +version = "1.4.3" +marker = "platform_machine == 'AMD64' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" +sdist = { url = "https://files.pythonhosted.org/packages/53/92/ec9ad04d0b5728dca387a45af7bc98fbb0d73b2118759f5f6038b61a57e8/hf_xet-1.4.3.tar.gz", upload-time = 2026-03-31T22:40:07Z, size = 670477, hashes = { sha256 = "8ddedb73c8c08928c793df2f3401ec26f95be7f7e516a7bee2fbb546f6676113" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/df/9a/a24b26dc8a65f0ecc0fe5be981a19e61e7ca963b85e062c083f3a9100529/hf_xet-1.4.3-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-03-31T22:39:42Z, size = 4212320, hashes = { sha256 = "fc360b70c815bf340ed56c7b8c63aacf11762a4b099b2fe2c9bd6d6068668c08" } }] + +[[packages]] +name = "httpcore" +version = "1.0.9" +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", upload-time = 2025-04-24T22:06:22Z, size = 85484, hashes = { sha256 = "6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", upload-time = 2025-04-24T22:06:20Z, size = 78784, hashes = { sha256 = "2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55" } }] + +[[packages]] +name = "httpx" +version = "0.28.1" +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", upload-time = 2024-12-06T15:37:23Z, size = 141406, hashes = { sha256 = "75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", upload-time = 2024-12-06T15:37:21Z, size = 73517, hashes = { sha256 = "d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad" } }] + +[[packages]] +name = "huggingface-hub" +version = "1.16.1" +sdist = { url = "https://files.pythonhosted.org/packages/48/0f/ed994dbade67a54407c28cab96ef845e0e6d25500be56aca6394f8bfc9dd/huggingface_hub-1.16.1.tar.gz", upload-time = 2026-05-21T18:40:00Z, size = 792534, hashes = { sha256 = "7f1dc4c5ec21aed69be630ad0c3378616be16f3de1a47b141c0e812965d9c832" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/49/79/621a7dbb80c70974f73a597275351ebe03ce5bc65cb5f8f4acb5859252bc/huggingface_hub-1.16.1-py3-none-any.whl", upload-time = 2026-05-21T18:39:58Z, size = 668176, hashes = { sha256 = "64340de934b9ce37857ef85a82de72f5629e8a270f9119eabb12bf495eb53c22" } }] + +[[packages]] +name = "idna" +version = "3.17" +sdist = { url = "https://files.pythonhosted.org/packages/b9/28/99c51f664567218d824af024c0251650fb27e4ca066df188dab0769c5b91/idna-3.17.tar.gz", upload-time = 2026-05-28T14:32:38Z, size = 196048, hashes = { sha256 = "5eb0cb53bc467c12eadcf6de83163ad8527cec9416f44b9b61b19caedad2b87f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/de/a7/f76514cc40ad6234098ecdebda08732d75964776c51a42845b7da10649e2/idna-3.17-py3-none-any.whl", upload-time = 2026-05-28T14:32:37Z, size = 65316, hashes = { sha256 = "466e48829084efe2548012b855df21540b96f2e20e51bd124c851536556a592c" } }] + +[[packages]] +name = "jinja2" +version = "3.1.6" +wheels = [{ url = "https://download.pytorch.org/whl/jinja2-3.1.6-py3-none-any.whl", upload-time = 2025-10-14T18:38:59Z, hashes = { sha256 = "85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67" } }] + +[[packages]] +name = "joblib" +version = "1.5.3" +sdist = { url = "https://files.pythonhosted.org/packages/41/f2/d34e8b3a08a9cc79a50b2208a93dce981fe615b64d5a4d4abee421d898df/joblib-1.5.3.tar.gz", upload-time = 2025-12-15T08:41:46Z, size = 331603, hashes = { sha256 = "8561a3269e6801106863fd0d6d84bb737be9e7631e33aaed3fb9ce5953688da3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7b/91/984aca2ec129e2757d1e4e3c81c3fcda9d0f85b74670a094cc443d9ee949/joblib-1.5.3-py3-none-any.whl", upload-time = 2025-12-15T08:41:44Z, size = 309071, hashes = { sha256 = "5fc3c5039fc5ca8c0276333a188bbd59d6b7ab37fe6632daa76bc7f9ec18e713" } }] + +[[packages]] +name = "lazy-loader" +version = "0.6" +sdist = { url = "https://files.pythonhosted.org/packages/19/8c/0f2ff2a8b7513e68871a74740c17a504b0488c679b379e6445ebb7bd78dc/lazy_loader-0.6.tar.gz", upload-time = 2026-09-21T21:31:32Z, size = 18438, hashes = { sha256 = "2f4b7824d6401958639008a0cae20c776b61dff619accd6890693e2de8260167" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/23/93/4e45e37f26c820216704b36b8e67cc55c490a7abd287a78a26a2c0e21386/lazy_loader-0.6-py3-none-any.whl", upload-time = 2026-09-21T21:31:31Z, size = 8791, hashes = { sha256 = "77253be3391b06124a0e16105bd663b6c54470af1a9ca8e1cf026f38d58ed056" } }] + +[[packages]] +name = "librosa" +version = "1.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/8e/c1/ce66b20953b7370421dd13d22b4e04e401346c824ceacb9f4e722eec84dc/librosa-1.0.0.tar.gz", upload-time = 2026-08-11T15:37:37Z, size = 377965, hashes = { sha256 = "73ed480d4022e436e85dfa6f6b06ff38a259b9210039ac99939cd64854b61a57" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/96/14/0b2e4cc8017796dc8f69de740708601832c1e8d5377166eedb4db0a92264/librosa-1.0.0-py3-none-any.whl", upload-time = 2026-08-11T15:37:35Z, size = 294628, hashes = { sha256 = "5910a6c0e1b2e494b92758c1615a7acbd0515a2315e138927ba2982f2af88857" } }] + +[[packages]] +name = "llvmlite" +version = "0.50.0" +sdist = { url = "https://files.pythonhosted.org/packages/11/c5/907cec40688a34eb489cded74d555e1ee4af8cf49d83e03dba2c2d4cfe27/llvmlite-0.50.0.tar.gz", upload-time = 2026-09-29T18:44:46Z, size = 194522, hashes = { sha256 = "f2a2cd6ec9ffcc1b7147dea0d7a49efebf17a2b434e0c2844fe175999d571eb4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/4c/72/22b6449e15bec4cc86c62b659e6c625ab777d01e87aaec717ecef440f87a/llvmlite-0.50.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-09-29T18:43:04Z, size = 59696588, hashes = { sha256 = "d501e5103076b9a14be885d2574dc2f6793171aa54a853d1244e011d476f1399" } }] + +[[packages]] +name = "markdown-it-py" +version = "4.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", upload-time = 2025-08-11T12:57:52Z, size = 73070, hashes = { sha256 = "cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", upload-time = 2025-08-11T12:57:51Z, size = 87321, hashes = { sha256 = "87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147" } }] + +[[packages]] +name = "markupsafe" +version = "3.0.3" +wheels = [{ url = "https://download.pytorch.org/whl/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-27T13:54:35Z, hashes = { sha256 = "d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d" } }] + +[[packages]] +name = "mdurl" +version = "0.1.2" +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", upload-time = 2022-08-14T12:40:10Z, size = 8729, hashes = { sha256 = "bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", upload-time = 2022-08-14T12:40:09Z, size = 9979, hashes = { sha256 = "84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8" } }] + +[[packages]] +name = "mpmath" +version = "1.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", upload-time = 2023-03-07T16:47:11Z, size = 508106, hashes = { sha256 = "7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", upload-time = 2023-03-07T16:47:09Z, size = 536198, hashes = { sha256 = "a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c" } }] + +[[packages]] +name = "msgpack" +version = "1.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/31/f9/c0a1c127f9049db9155afc316952ea571720dd01833ff5e4d7e8e6352dbb/msgpack-1.2.1.tar.gz", upload-time = 2026-06-18T16:13:52Z, size = 183960, hashes = { sha256 = "04c721c2c7448767e9e3f2520a475663d8ee0f09c31890f6d2bd70fd636a9647" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/6a/fd/6adabd4f6d5e686f97dd02ce7fce3fe4cf672cbac36b8f67ff4040e8ad8b/msgpack-1.2.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-06-18T16:13:01Z, size = 419989, hashes = { sha256 = "020e881a764b20d8d7ca1a54fc01b8175519d108e3c3f194fddc200bda95951a" } }] + +[[packages]] +name = "networkx" +version = "3.6.1" +sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", upload-time = 2025-12-08T17:02:39Z, size = 2517025, hashes = { sha256 = "26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", upload-time = 2025-12-08T17:02:38Z, size = 2068504, hashes = { sha256 = "d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762" } }] + +[[packages]] +name = "numba" +version = "0.68.0" +sdist = { url = "https://files.pythonhosted.org/packages/4e/cd/e8280f9ffa30fea9fabc5341223701231fcc5d53a31f51419d42d4bec3a6/numba-0.68.0.tar.gz", upload-time = 2026-09-30T15:05:44Z, size = 2855363, hashes = { sha256 = "8a781de54b980b98f43bff7f1093701b5f07c80d031c7cfa8a87493d8bf73f2d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/6f/40/2211b4ff48cccfb21d4c38fb56788d7a975189883efb8d549be9d51aba7d/numba-0.68.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-09-30T15:04:57Z, size = 3888027, hashes = { sha256 = "51fe913a70fe9a7a0b193757ff977a9e96c82ae936ae388aec8990814fffdf9d" } }] + +[[packages]] +name = "numpy" +version = "2.4.4" +sdist = { url = "https://files.pythonhosted.org/packages/d7/9f/b8cef5bffa569759033adda9481211426f12f53299629b410340795c2514/numpy-2.4.4.tar.gz", upload-time = 2026-03-29T13:22:01Z, size = 20731587, hashes = { sha256 = "2d390634c5182175533585cc89f3608a4682ccb173cc9bb940b2881c8d6f8fa0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0a/0d/0e3ecece05b7a7e87ab9fb587855548da437a061326fff64a223b6dcb78a/numpy-2.4.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-29T13:19:03Z, size = 16645480, hashes = { sha256 = "81f4a14bee47aec54f883e0cad2d73986640c1590eb9bfaaba7ad17394481e6e" } }] + +[[packages]] +name = "opf" +version = "0.1.0" +vcs = { type = "git", url = "https://github.com/openai/privacy-filter", requested-revision = "f7f00ca7fb869683eb732c010299d901457f19c3", commit-id = "f7f00ca7fb869683eb732c010299d901457f19c3" } + +[[packages]] +name = "packaging" +version = "24.2" +sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", upload-time = 2024-11-08T09:47:47Z, size = 163950, hashes = { sha256 = "c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", upload-time = 2024-11-08T09:47:44Z, size = 65451, hashes = { sha256 = "09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759" } }] + +[[packages]] +name = "pillow" +version = "12.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/1c/3d/bb7fca845737cf9d7dbde16ed1843984665ff2e0a518f5db43e77ec540b9/pillow-12.3.0.tar.gz", upload-time = 2026-07-01T11:56:38Z, size = 47025035, hashes = { sha256 = "3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/84/21/a35af28dcc61f37ed850a2d64c65c701321dfbf25085e469d5559360cbbf/pillow-12.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-01T11:54:13Z, size = 6940830, hashes = { sha256 = "78cb2c6865a35ab8ff8b75fd122f6033b92a62c82801110e48ddd6c936a45d91" } }] + +[[packages]] +name = "platformdirs" +version = "4.9.6" +sdist = { url = "https://files.pythonhosted.org/packages/9f/4a/0883b8e3802965322523f0b200ecf33d31f10991d0401162f4b23c698b42/platformdirs-4.9.6.tar.gz", upload-time = 2026-04-09T00:04:10Z, size = 29400, hashes = { sha256 = "3bfa75b0ad0db84096ae777218481852c0ebc6c727b3168c1b9e0118e458cf0a" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/75/a6/a0a304dc33b49145b21f4808d763822111e67d1c3a32b524a1baf947b6e1/platformdirs-4.9.6-py3-none-any.whl", upload-time = 2026-04-09T00:04:09Z, size = 21348, hashes = { sha256 = "e61adb1d5e5cb3441b4b7710bea7e4c12250ca49439228cc1021c00dcfac0917" } }] + +[[packages]] +name = "pooch" +version = "1.9.0" +sdist = { url = "https://files.pythonhosted.org/packages/83/43/85ef45e8b36c6a48546af7b266592dc32d7f67837a6514d111bced6d7d75/pooch-1.9.0.tar.gz", upload-time = 2026-01-30T19:15:09Z, size = 61788, hashes = { sha256 = "de46729579b9857ffd3e741987a2f6d5e0e03219892c167c6578c0091fb511ed" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/2d/d4bf65e47cea8ff2c794a600c4fd1273a7902f268757c531e0ee9f18aa58/pooch-1.9.0-py3-none-any.whl", upload-time = 2026-01-30T19:15:08Z, size = 67175, hashes = { sha256 = "f265597baa9f760d25ceb29d0beb8186c243d6607b0f60b83ecf14078dbc703b" } }] + +[[packages]] +name = "pycparser" +version = "3.0" +marker = "implementation_name != 'PyPy'" +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", upload-time = 2026-01-21T14:26:51Z, size = 103492, hashes = { sha256 = "600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", upload-time = 2026-01-21T14:26:50Z, size = 48172, hashes = { sha256 = "b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992" } }] + +[[packages]] +name = "pydantic" +version = "2.12.5" +sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", upload-time = 2025-11-26T15:11:46Z, size = 821591, hashes = { sha256 = "4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", upload-time = 2025-11-26T15:11:44Z, size = 463580, hashes = { sha256 = "e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d" } }] + +[[packages]] +name = "pydantic-core" +version = "2.41.5" +sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", upload-time = 2025-11-04T13:43:49Z, size = 460952, hashes = { sha256 = "08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-04T13:40:09Z, size = 2075366, hashes = { sha256 = "eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c" } }] + +[[packages]] +name = "pygments" +version = "2.20.0" +sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", upload-time = 2026-03-29T13:29:33Z, size = 4955991, hashes = { sha256 = "6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", upload-time = 2026-03-29T13:29:30Z, size = 1231151, hashes = { sha256 = "81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176" } }] + +[[packages]] +name = "pyyaml" +version = "6.0.3" +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", upload-time = 2025-09-25T21:33:16Z, size = 130960, hashes = { sha256 = "d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-09-25T21:32:16Z, size = 807870, hashes = { sha256 = "ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc" } }] + +[[packages]] +name = "regex" +version = "2026.4.4" +sdist = { url = "https://files.pythonhosted.org/packages/cb/0e/3a246dbf05666918bd3664d9d787f84a9108f6f43cc953a077e4a7dfdb7e/regex-2026.4.4.tar.gz", upload-time = 2026-04-03T20:56:28Z, size = 416000, hashes = { sha256 = "e08270659717f6973523ce3afbafa53515c4dc5dcad637dc215b6fd50f689423" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/11/0e/a9f6f81013e0deaf559b25711623864970fe6a098314e374ccb1540a4152/regex-2026.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-03T20:53:51Z, size = 801126, hashes = { sha256 = "993f657a7c1c6ec51b5e0ba97c9817d06b84ea5fa8d82e43b9405de0defdc2b9" } }] + +[[packages]] +name = "requests" +version = "2.33.1" +sdist = { url = "https://files.pythonhosted.org/packages/5f/a4/98b9c7c6428a668bf7e42ebb7c79d576a1c3c1e3ae2d47e674b468388871/requests-2.33.1.tar.gz", upload-time = 2026-03-30T16:09:15Z, size = 134120, hashes = { sha256 = "18817f8c57c6263968bc123d237e3b8b08ac046f5456bd1e307ee8f4250d3517" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", upload-time = 2026-03-30T16:09:13Z, size = 64947, hashes = { sha256 = "4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a" } }] + +[[packages]] +name = "rich" +version = "13.9.4" +sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", upload-time = 2024-11-01T16:43:57Z, size = 223149, hashes = { sha256 = "439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", upload-time = 2024-11-01T16:43:55Z, size = 242424, hashes = { sha256 = "6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90" } }] + +[[packages]] +name = "safetensors" +version = "0.8.0" +sdist = { url = "https://files.pythonhosted.org/packages/45/06/f955dbbb1859e3bd23c8ac6141af5106e7ad5fedec4a3a6e3d60f94b7001/safetensors-0.8.0.tar.gz", upload-time = 2026-06-09T07:52:25Z, size = 325846, hashes = { sha256 = "fabaf3e0f18a6618d9b36560682562157f77c2b71fcffc7b432be2baed9d753d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/28/50/f203ff3a3ddfe19308efc83c5a3a29ed02bf786732ec35e68bf9162f3365/safetensors-0.8.0-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-06-09T07:52:16Z, size = 516040, hashes = { sha256 = "fd6f3f93c9a0a7cc2788ee63fb763353d4bd2e89b0751bc78fcf7dda00bea774" } }] + +[[packages]] +name = "scikit-learn" +version = "1.8.0" +sdist = { url = "https://files.pythonhosted.org/packages/0e/d4/40988bf3b8e34feec1d0e6a051446b1f66225f8529b9309becaeef62b6c4/scikit_learn-1.8.0.tar.gz", upload-time = 2025-12-10T07:08:53Z, size = 7335585, hashes = { sha256 = "9bccbb3b40e3de10351f8f5068e105d0f4083b1a65fa07b6634fbc401a6287fd" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/97/74/b7a304feb2b49df9fafa9382d4d09061a96ee9a9449a7cbea7988dda0828/scikit_learn-1.8.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-12-10T07:07:57Z, size = 8931904, hashes = { sha256 = "a0bcfe4d0d14aec44921545fd2af2338c7471de9cb701f1da4c9d85906ab847a" } }] + +[[packages]] +name = "scipy" +version = "1.17.1" +sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", upload-time = 2026-02-23T00:26:24Z, size = 30573822, hashes = { sha256 = "95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/01/8e/1e35281b8ab6d5d72ebe9911edcdffa3f36b04ed9d51dec6dd140396e220/scipy-1.17.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-02-23T00:18:49Z, size = 35235890, hashes = { sha256 = "02ae3b274fde71c5e92ac4d54bc06c42d80e399fec704383dcd99b301df37458" } }] + +[[packages]] +name = "sentence-transformers" +version = "5.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/9d/59/867381b1414a975da6c9953f48a07c05cb0629305e2d37c9bcc9764367b2/sentence_transformers-5.7.0.tar.gz", upload-time = 2026-08-06T12:12:33Z, size = 466382, hashes = { sha256 = "fd8c8fc35e6323631dff9f3760969ebf7980dc3cfda0ab1354bc6a774cc0e5d8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e8/c8/f63d99e354532f5b83e735dd1e001bda92495fbfde934f65d924abf2b071/sentence_transformers-5.7.0-py3-none-any.whl", upload-time = 2026-08-06T12:12:31Z, size = 611333, hashes = { sha256 = "b78141da3d8137e70d965866e2ca43190b9266f3d4d8752e250ded75e7136730" } }] + +[[packages]] +name = "setuptools" +version = "83.0.0" +marker = "python_full_version >= '3.12'" +sdist = { url = "https://files.pythonhosted.org/packages/34/26/f5d29e25ffdb535afef2d35cdb55b325298f96debd670da4c325e08d70f4/setuptools-83.0.0.tar.gz", upload-time = 2026-07-04T15:31:22Z, size = 1154254, hashes = { sha256 = "025bccbbf0fa05b6192bc64ae1e7b16e001fd6d6d4d5de03c97b1c1ade523bef" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5d/40/e1e72872c6354b306daef1703549e8e83b4d43cfea356311bf722a043752/setuptools-83.0.0-py3-none-any.whl", upload-time = 2026-07-04T15:31:20Z, size = 1008090, hashes = { sha256 = "29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3" } }] + +[[packages]] +name = "shellingham" +version = "1.5.4" +sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", upload-time = 2023-10-24T04:13:40Z, size = 10310, hashes = { sha256 = "8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", upload-time = 2023-10-24T04:13:38Z, size = 9755, hashes = { sha256 = "7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686" } }] + +[[packages]] +name = "soundfile" +version = "0.14.0" +sdist = { url = "https://files.pythonhosted.org/packages/d2/db/949331952a6fb1c5b12e9de80fd08747966c2039d1a61db4764fbd3981c2/soundfile-0.14.0.tar.gz", upload-time = 2026-06-06T08:58:47Z, size = 47842, hashes = { sha256 = "ba1c1a2d618bca5c406647c83b89f07cc8810fa506a50622a6993ba130c1de11" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/d1/5e338af9ca6ed0786cd5bb03f6d60de1c325728c1189014f3b59aae7403c/soundfile-0.14.0-py2.py3-none-any.whl", upload-time = 2026-06-06T08:58:33Z, size = 26799, hashes = { sha256 = "8ba81ae3a89fd5ab3bef8a8eb481fbbe794e806309675a89b4df48b8d31908a8" } }, + { url = "https://files.pythonhosted.org/packages/7b/a2/70fd4432b924684c372df8b0a45708c36c057ef3596c9eb53e0a806b980b/soundfile-0.14.0-py2.py3-none-manylinux_2_28_x86_64.whl", upload-time = 2026-06-06T08:58:41Z, size = 1315963, hashes = { sha256 = "1e38bac1853412871318e82a1ba69a8be677619b56025bbfcccdb41b6cafe82d" } }, +] + +[[packages]] +name = "soxr" +version = "1.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/ed/11/27cebce4a108f77afea7c80545115536b45e3f11ebfb914f638fdd9ba847/soxr-1.1.0.tar.gz", upload-time = 2026-05-03T00:15:18Z, size = 173067, hashes = { sha256 = "9f228ae21c78fa9359ca98d8a5e8e91f30639e438e574133dace62c5b5309e44" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5c/f1/0e55195893228609c9a08c3b13b7a83a46c3a992cd00d3304f0f320cfb07/soxr-1.1.0-cp312-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-05-03T00:14:59Z, size = 240413, hashes = { sha256 = "3b033078e86f3c4a658e5697fac8995764fad9e799563616b630136b613167f1" } }] + +[[packages]] +name = "sympy" +version = "1.14.0" +sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", upload-time = 2025-04-27T18:05:01Z, size = 7793921, hashes = { sha256 = "d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", upload-time = 2025-04-27T18:04:59Z, size = 6299353, hashes = { sha256 = "e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5" } }] + +[[packages]] +name = "threadpoolctl" +version = "3.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/b7/4d/08c89e34946fce2aec4fbb45c9016efd5f4d7f24af8e5d93296e935631d8/threadpoolctl-3.6.0.tar.gz", upload-time = 2025-03-13T13:49:23Z, size = 21274, hashes = { sha256 = "8ab8b4aa3491d812b623328249fab5302a68d2d71745c8a4c719a2fcaba9f44e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", upload-time = 2025-03-13T13:49:21Z, size = 18638, hashes = { sha256 = "43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb" } }] + +[[packages]] +name = "tiktoken" +version = "0.12.0" +sdist = { url = "https://files.pythonhosted.org/packages/7d/ab/4d017d0f76ec3171d469d80fc03dfbb4e48a4bcaddaa831b31d526f05edc/tiktoken-0.12.0.tar.gz", upload-time = 2025-10-06T20:22:45Z, size = 37806, hashes = { sha256 = "b18ba7ee2b093863978fcb14f74b3707cdc8d4d4d3836853ce7ec60772139931" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f4/90/3dae6cc5436137ebd38944d396b5849e167896fc2073da643a49f372dc4f/tiktoken-0.12.0-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2025-10-06T20:21:56Z, size = 1152665, hashes = { sha256 = "edde1ec917dfd21c1f2f8046b86348b0f54a2c0547f68149d8600859598769ad" } }] + +[[packages]] +name = "tokenizers" +version = "0.23.3" +sdist = { url = "https://files.pythonhosted.org/packages/e0/7c/2cabb2174e772636683008f2c5621949b645da7d303c596589e84516a184/tokenizers-0.23.3.tar.gz", upload-time = 2026-10-09T10:16:55Z, size = 385286, hashes = { sha256 = "cded33237c77caeef62944d32aa9a7ef42bdce2b3497e18d137e072a8c4be438" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3a/40/6706b82693715581457c6d5423eaa7faae576bb0526c5738a57085eb4449/tokenizers-0.23.3-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-10-09T10:01:05Z, size = 3396193, hashes = { sha256 = "376851d22bcf9d650a5c3090bb83e6cf9e895fbf0595369fa4cd43c1f69b5f87" } }] + +[[packages]] +name = "torch" +version = "2.9.1+cpu" +wheels = [{ url = "https://download-r2.pytorch.org/whl/cpu/torch-2.9.1%2Bcpu-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-01-23T15:13:04Z, hashes = { sha256 = "7417d8c565f219d3455654cb431c6d892a3eb40246055e14d645422de13b9ea1" } }] + +[[packages]] +name = "torchvision" +version = "0.24.1+cpu" +wheels = [{ url = "https://download-r2.pytorch.org/whl/cpu/torchvision-0.24.1%2Bcpu-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2025-11-15T18:12:45Z, hashes = { sha256 = "48ff40694812292f1f75cddb517f9eef224a2e8388798a0aa191e27bf159fc5d" } }] + +[[packages]] +name = "tqdm" +version = "4.67.3" +sdist = { url = "https://files.pythonhosted.org/packages/09/a9/6ba95a270c6f1fbcd8dac228323f2777d886cb206987444e4bce66338dd4/tqdm-4.67.3.tar.gz", upload-time = 2026-02-03T17:35:53Z, size = 169598, hashes = { sha256 = "7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", upload-time = 2026-02-03T17:35:50Z, size = 78374, hashes = { sha256 = "ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf" } }] + +[[packages]] +name = "transformers" +version = "5.17.0" +sdist = { url = "https://files.pythonhosted.org/packages/0e/9e/750649904a065007a838981785b2bd8d9ff26154c6c341ac67d0b7f82c68/transformers-5.17.0.tar.gz", upload-time = 2026-09-09T15:39:56Z, size = 9817878, hashes = { sha256 = "a153be279169b55b92d8000bf4af294aed684503d091cca7804da2dd8a9de000" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e8/d0/c502b60d684adbd98a8dc7d5bb866842772b816ac4354e4608be240041ae/transformers-5.17.0-py3-none-any.whl", upload-time = 2026-09-09T15:39:53Z, size = 12295140, hashes = { sha256 = "78ec1ce21579b38dfb83950a0658cd119f87212a2fcfdff478096ce9d6c03801" } }] + +[[packages]] +name = "typer" +version = "0.21.2" +sdist = { url = "https://files.pythonhosted.org/packages/f2/1e/a27cc02a0cd715118c71fa2aef2c687fdefc3c28d90fd0dd789c5118154c/typer-0.21.2.tar.gz", upload-time = 2026-02-10T19:33:46Z, size = 120426, hashes = { sha256 = "1abd95a3b675e17ff61b0838ac637fe9478d446d62ad17fa4bb81ea57cc54028" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b8/cc/d59f893fbdfb5f58770c05febfc4086a46875f1084453621c35605cec946/typer-0.21.2-py3-none-any.whl", upload-time = 2026-02-10T19:33:48Z, size = 56728, hashes = { sha256 = "c3d8de54d00347ef90b82131ca946274f017cffb46683ae3883c360fa958f55c" } }] + +[[packages]] +name = "typing-extensions" +version = "4.15.0" +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", upload-time = 2025-08-25T13:49:26Z, size = 109391, hashes = { sha256 = "0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", upload-time = 2025-08-25T13:49:24Z, size = 44614, hashes = { sha256 = "f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548" } }] + +[[packages]] +name = "typing-inspection" +version = "0.4.2" +sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", upload-time = 2025-10-01T02:14:41Z, size = 75949, hashes = { sha256 = "ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", upload-time = 2025-10-01T02:14:40Z, size = 14611, hashes = { sha256 = "4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7" } }] + +[[packages]] +name = "urllib3" +version = "2.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", upload-time = 2026-05-07T16:13:18Z, size = 433602, hashes = { sha256 = "231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", upload-time = 2026-05-07T16:13:17Z, size = 131087, hashes = { sha256 = "9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897" } }] diff --git a/packages/sie_server/bundle-locks/cpu-transformers5-arm64/manifest.json b/packages/sie_server/bundle-locks/cpu-transformers5-arm64/manifest.json new file mode 100644 index 000000000..8ec51d6cf --- /dev/null +++ b/packages/sie_server/bundle-locks/cpu-transformers5-arm64/manifest.json @@ -0,0 +1,39 @@ +{ + "completed_artifact_hashes": [ + { + "bytes": 134899, + "sha256": "85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", + "url": "https://download.pytorch.org/whl/jinja2-3.1.6-py3-none-any.whl" + }, + { + "bytes": 24332, + "sha256": "3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", + "url": "https://download.pytorch.org/whl/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl" + } + ], + "exceptions_sha256": "2d808969e86d3da417f7b52a9ea461f2d281baa48e1cda74b257f65a6f67ab34", + "exclude_newer": "2026-10-18T00:00:00Z", + "indexes": [ + "--default-index", + "https://pypi.org/simple", + "--index", + "https://download.pytorch.org/whl/cpu", + "--index-strategy", + "unsafe-best-match" + ], + "inputs": { + "requirements_sha256": "529fd129d457b6820b48a3acbb4dee1f9eb83806e0a6730f122ff3826861a3f2", + "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" + }, + "lock_sha256": "f0243e01019a55d573ceffa9798460b0a503d128e5f1942e8901d83658995219", + "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "schema_version": 1, + "target": { + "architecture": "arm64", + "bundle": "transformers5", + "platform": "cpu", + "python_platform": "aarch64-manylinux_2_35", + "python_version": "3.12" + }, + "uv_version": "0.9.28" +} diff --git a/packages/sie_server/bundle-locks/cpu-transformers5-arm64/pylock.toml b/packages/sie_server/bundle-locks/cpu-transformers5-arm64/pylock.toml new file mode 100644 index 000000000..fcb2eba03 --- /dev/null +++ b/packages/sie_server/bundle-locks/cpu-transformers5-arm64/pylock.toml @@ -0,0 +1,385 @@ +lock-version = "1.0" +created-by = "uv" +requires-python = ">=3.12" + +[[packages]] +name = "annotated-doc" +version = "0.0.4" +sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", upload-time = 2025-11-10T22:07:42Z, size = 7288, hashes = { sha256 = "fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", upload-time = 2025-11-10T22:07:40Z, size = 5303, hashes = { sha256 = "571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320" } }] + +[[packages]] +name = "annotated-types" +version = "0.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", upload-time = 2024-05-20T21:33:25Z, size = 16081, hashes = { sha256 = "aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", upload-time = 2024-05-20T21:33:24Z, size = 13643, hashes = { sha256 = "1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53" } }] + +[[packages]] +name = "anyio" +version = "4.14.2" +sdist = { url = "https://files.pythonhosted.org/packages/61/cc/a381afa6efea9f496eff839d4a6a1aed3bfafc7b3ab4b0d1b243a12573dd/anyio-4.14.2.tar.gz", upload-time = 2026-07-12T20:29:07Z, size = 260176, hashes = { sha256 = "cfa139f3ed1a23ee8f88a145ddb5ac7605b8bbfd8592baacd7ce3d8bb4313c7f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/da/35/f2287558c17e29fafc8ef3daf819bb9834061cfa43bff8014f7df7f63bdc/anyio-4.14.2-py3-none-any.whl", upload-time = 2026-07-12T20:29:05Z, size = 125813, hashes = { sha256 = "9f505dda5ac9f0c8309b5e8bd445a8c2bf7246f3ce950121e45ea15bc41d1494" } }] + +[[packages]] +name = "certifi" +version = "2026.4.22" +sdist = { url = "https://files.pythonhosted.org/packages/25/ee/6caf7a40c36a1220410afe15a1cc64993a1f864871f698c0f93acb72842a/certifi-2026.4.22.tar.gz", upload-time = 2026-04-22T11:26:11Z, size = 137077, hashes = { sha256 = "8d455352a37b71bf76a79caa83a3d6c25afee4a385d632127b6afb3963f1c580" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/22/30/7cd8fdcdfbc5b869528b079bfb76dcdf6056b1a2097a662e5e8c04f42965/certifi-2026.4.22-py3-none-any.whl", upload-time = 2026-04-22T11:26:09Z, size = 135707, hashes = { sha256 = "3cb2210c8f88ba2318d29b0388d1023c8492ff72ecdde4ebdaddbb13a31b1c4a" } }] + +[[packages]] +name = "cffi" +version = "2.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", upload-time = 2025-09-08T23:24:04Z, size = 523588, hashes = { sha256 = "44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", upload-time = 2025-09-08T23:22:48Z, size = 220097, hashes = { sha256 = "b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062" } }] + +[[packages]] +name = "charset-normalizer" +version = "3.4.7" +sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", upload-time = 2026-04-02T09:28:39Z, size = 144271, hashes = { sha256 = "ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f8/e3/0fadc706008ac9d7b9b5be6dc767c05f9d3e5df51744ce4cc9605de7b9f4/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-04-02T09:26:25Z, size = 208061, hashes = { sha256 = "6178f72c5508bfc5fd446a5905e698c6212932f25bcdd4b47a757a50605a90e2" } }, + { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", upload-time = 2026-04-02T09:28:37Z, size = 61958, hashes = { sha256 = "3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d" } }, +] + +[[packages]] +name = "click" +version = "8.1.8" +sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", upload-time = 2024-12-21T18:38:44Z, size = 226593, hashes = { sha256 = "ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", upload-time = 2024-12-21T18:38:41Z, size = 98188, hashes = { sha256 = "63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2" } }] + +[[packages]] +name = "decorator" +version = "5.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", upload-time = 2025-02-24T04:41:34Z, size = 56711, hashes = { sha256 = "65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", upload-time = 2025-02-24T04:41:32Z, size = 9190, hashes = { sha256 = "d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a" } }] + +[[packages]] +name = "filelock" +version = "3.29.0" +sdist = { url = "https://files.pythonhosted.org/packages/b5/fe/997687a931ab51049acce6fa1f23e8f01216374ea81374ddee763c493db5/filelock-3.29.0.tar.gz", upload-time = 2026-04-19T15:39:10Z, size = 57571, hashes = { sha256 = "69974355e960702e789734cb4871f884ea6fe50bd8404051a3530bc07809cf90" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/81/47/dd9a212ef6e343a6857485ffe25bba537304f1913bdbed446a23f7f592e1/filelock-3.29.0-py3-none-any.whl", upload-time = 2026-04-19T15:39:08Z, size = 39812, hashes = { sha256 = "96f5f6344709aa1572bbf631c640e4ebeeb519e08da902c39a001882f30ac258" } }] + +[[packages]] +name = "fsspec" +version = "2025.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/34/f4/5721faf47b8c499e776bc34c6a8fc17efdf7fdef0b00f398128bc5dcb4ac/fsspec-2025.3.0.tar.gz", upload-time = 2025-03-07T21:47:56Z, size = 298491, hashes = { sha256 = "a935fd1ea872591f2b5148907d103488fc523295e6c64b835cfad8c3eca44972" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/56/53/eb690efa8513166adef3e0669afd31e95ffde69fb3c52ec2ac7223ed6018/fsspec-2025.3.0-py3-none-any.whl", upload-time = 2025-03-07T21:47:54Z, size = 193615, hashes = { sha256 = "efb87af3efa9103f94ca91a7f8cb7a4df91af9f74fc106c9c7ea0efd7277c1b3" } }] + +[[packages]] +name = "gliner2" +version = "2.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/b2/a8/2dcfdb8862dbeb488b6b86047075a213cc101ca592eae1a43b824cca74dd/gliner2-2.0.0.tar.gz", upload-time = 2026-08-24T15:13:43Z, size = 565826, hashes = { sha256 = "82b149f893ba0f6adf75ef1db599b6dbecd9811cca34dbd0bac7cd9e90b90ce4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/00/44/87d2803c5c5c6c0bd22bce4d52c66c965dacae29e0121d7e04c9883711df/gliner2-2.0.0-py3-none-any.whl", upload-time = 2026-08-24T15:13:41Z, size = 326214, hashes = { sha256 = "6f7c4cba0ef3173636d8bd9404aa94d4e0ccf36d4b4b9a0d27d740dd2d3236c3" } }] + +[[packages]] +name = "h11" +version = "0.16.0" +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", upload-time = 2025-04-24T03:35:25Z, size = 101250, hashes = { sha256 = "4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", upload-time = 2025-04-24T03:35:24Z, size = 37515, hashes = { sha256 = "63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86" } }] + +[[packages]] +name = "hf-xet" +version = "1.4.3" +marker = "platform_machine == 'AMD64' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" +sdist = { url = "https://files.pythonhosted.org/packages/53/92/ec9ad04d0b5728dca387a45af7bc98fbb0d73b2118759f5f6038b61a57e8/hf_xet-1.4.3.tar.gz", upload-time = 2026-03-31T22:40:07Z, size = 670477, hashes = { sha256 = "8ddedb73c8c08928c793df2f3401ec26f95be7f7e516a7bee2fbb546f6676113" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/53/60/46d493db155d2ee2801b71fb1b0fd67696359047fdd8caee2c914cc50c79/hf_xet-1.4.3-cp37-abi3-manylinux_2_28_aarch64.whl", upload-time = 2026-03-31T22:39:41Z, size = 3991546, hashes = { sha256 = "39f2d2e9654cd9b4319885733993807aab6de9dfbd34c42f0b78338d6617421f" } }] + +[[packages]] +name = "httpcore" +version = "1.0.9" +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", upload-time = 2025-04-24T22:06:22Z, size = 85484, hashes = { sha256 = "6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", upload-time = 2025-04-24T22:06:20Z, size = 78784, hashes = { sha256 = "2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55" } }] + +[[packages]] +name = "httpx" +version = "0.28.1" +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", upload-time = 2024-12-06T15:37:23Z, size = 141406, hashes = { sha256 = "75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", upload-time = 2024-12-06T15:37:21Z, size = 73517, hashes = { sha256 = "d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad" } }] + +[[packages]] +name = "huggingface-hub" +version = "1.16.1" +sdist = { url = "https://files.pythonhosted.org/packages/48/0f/ed994dbade67a54407c28cab96ef845e0e6d25500be56aca6394f8bfc9dd/huggingface_hub-1.16.1.tar.gz", upload-time = 2026-05-21T18:40:00Z, size = 792534, hashes = { sha256 = "7f1dc4c5ec21aed69be630ad0c3378616be16f3de1a47b141c0e812965d9c832" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/49/79/621a7dbb80c70974f73a597275351ebe03ce5bc65cb5f8f4acb5859252bc/huggingface_hub-1.16.1-py3-none-any.whl", upload-time = 2026-05-21T18:39:58Z, size = 668176, hashes = { sha256 = "64340de934b9ce37857ef85a82de72f5629e8a270f9119eabb12bf495eb53c22" } }] + +[[packages]] +name = "idna" +version = "3.17" +sdist = { url = "https://files.pythonhosted.org/packages/b9/28/99c51f664567218d824af024c0251650fb27e4ca066df188dab0769c5b91/idna-3.17.tar.gz", upload-time = 2026-05-28T14:32:38Z, size = 196048, hashes = { sha256 = "5eb0cb53bc467c12eadcf6de83163ad8527cec9416f44b9b61b19caedad2b87f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/de/a7/f76514cc40ad6234098ecdebda08732d75964776c51a42845b7da10649e2/idna-3.17-py3-none-any.whl", upload-time = 2026-05-28T14:32:37Z, size = 65316, hashes = { sha256 = "466e48829084efe2548012b855df21540b96f2e20e51bd124c851536556a592c" } }] + +[[packages]] +name = "jinja2" +version = "3.1.6" +wheels = [{ url = "https://download.pytorch.org/whl/jinja2-3.1.6-py3-none-any.whl", upload-time = 2025-10-14T18:38:59Z, hashes = { sha256 = "85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67" } }] + +[[packages]] +name = "joblib" +version = "1.5.3" +sdist = { url = "https://files.pythonhosted.org/packages/41/f2/d34e8b3a08a9cc79a50b2208a93dce981fe615b64d5a4d4abee421d898df/joblib-1.5.3.tar.gz", upload-time = 2025-12-15T08:41:46Z, size = 331603, hashes = { sha256 = "8561a3269e6801106863fd0d6d84bb737be9e7631e33aaed3fb9ce5953688da3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7b/91/984aca2ec129e2757d1e4e3c81c3fcda9d0f85b74670a094cc443d9ee949/joblib-1.5.3-py3-none-any.whl", upload-time = 2025-12-15T08:41:44Z, size = 309071, hashes = { sha256 = "5fc3c5039fc5ca8c0276333a188bbd59d6b7ab37fe6632daa76bc7f9ec18e713" } }] + +[[packages]] +name = "lazy-loader" +version = "0.6" +sdist = { url = "https://files.pythonhosted.org/packages/19/8c/0f2ff2a8b7513e68871a74740c17a504b0488c679b379e6445ebb7bd78dc/lazy_loader-0.6.tar.gz", upload-time = 2026-09-21T21:31:32Z, size = 18438, hashes = { sha256 = "2f4b7824d6401958639008a0cae20c776b61dff619accd6890693e2de8260167" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/23/93/4e45e37f26c820216704b36b8e67cc55c490a7abd287a78a26a2c0e21386/lazy_loader-0.6-py3-none-any.whl", upload-time = 2026-09-21T21:31:31Z, size = 8791, hashes = { sha256 = "77253be3391b06124a0e16105bd663b6c54470af1a9ca8e1cf026f38d58ed056" } }] + +[[packages]] +name = "librosa" +version = "1.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/8e/c1/ce66b20953b7370421dd13d22b4e04e401346c824ceacb9f4e722eec84dc/librosa-1.0.0.tar.gz", upload-time = 2026-08-11T15:37:37Z, size = 377965, hashes = { sha256 = "73ed480d4022e436e85dfa6f6b06ff38a259b9210039ac99939cd64854b61a57" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/96/14/0b2e4cc8017796dc8f69de740708601832c1e8d5377166eedb4db0a92264/librosa-1.0.0-py3-none-any.whl", upload-time = 2026-08-11T15:37:35Z, size = 294628, hashes = { sha256 = "5910a6c0e1b2e494b92758c1615a7acbd0515a2315e138927ba2982f2af88857" } }] + +[[packages]] +name = "llvmlite" +version = "0.50.0" +sdist = { url = "https://files.pythonhosted.org/packages/11/c5/907cec40688a34eb489cded74d555e1ee4af8cf49d83e03dba2c2d4cfe27/llvmlite-0.50.0.tar.gz", upload-time = 2026-09-29T18:44:46Z, size = 194522, hashes = { sha256 = "f2a2cd6ec9ffcc1b7147dea0d7a49efebf17a2b434e0c2844fe175999d571eb4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7a/c4/e86f30b2b09c310c02ffdd8afd00f7e127d365131d163c926c98fc3ece22/llvmlite-0.50.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-09-29T18:43:00Z, size = 58344485, hashes = { sha256 = "6e8df54380110ea5e9127386e739d2b0829cc6dfa4a24a9195226336c91b06d5" } }] + +[[packages]] +name = "markdown-it-py" +version = "4.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", upload-time = 2025-08-11T12:57:52Z, size = 73070, hashes = { sha256 = "cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", upload-time = 2025-08-11T12:57:51Z, size = 87321, hashes = { sha256 = "87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147" } }] + +[[packages]] +name = "markupsafe" +version = "3.0.3" +wheels = [{ url = "https://download.pytorch.org/whl/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-03-27T13:54:33Z, hashes = { sha256 = "3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d" } }] + +[[packages]] +name = "mdurl" +version = "0.1.2" +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", upload-time = 2022-08-14T12:40:10Z, size = 8729, hashes = { sha256 = "bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", upload-time = 2022-08-14T12:40:09Z, size = 9979, hashes = { sha256 = "84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8" } }] + +[[packages]] +name = "mpmath" +version = "1.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", upload-time = 2023-03-07T16:47:11Z, size = 508106, hashes = { sha256 = "7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", upload-time = 2023-03-07T16:47:09Z, size = 536198, hashes = { sha256 = "a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c" } }] + +[[packages]] +name = "msgpack" +version = "1.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/31/f9/c0a1c127f9049db9155afc316952ea571720dd01833ff5e4d7e8e6352dbb/msgpack-1.2.1.tar.gz", upload-time = 2026-06-18T16:13:52Z, size = 183960, hashes = { sha256 = "04c721c2c7448767e9e3f2520a475663d8ee0f09c31890f6d2bd70fd636a9647" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/26/aa/753ad8b007b464e1d8aa0c8e650b9c5f4f725e658fc5ac8a7635c55b7f6e/msgpack-1.2.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-06-18T16:13:00Z, size = 410634, hashes = { sha256 = "60926b75d00c8e816ef98f3034f484a8bc64242d66839cef4cf7e503142316a0" } }] + +[[packages]] +name = "networkx" +version = "3.6.1" +sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", upload-time = 2025-12-08T17:02:39Z, size = 2517025, hashes = { sha256 = "26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", upload-time = 2025-12-08T17:02:38Z, size = 2068504, hashes = { sha256 = "d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762" } }] + +[[packages]] +name = "numba" +version = "0.68.0" +sdist = { url = "https://files.pythonhosted.org/packages/4e/cd/e8280f9ffa30fea9fabc5341223701231fcc5d53a31f51419d42d4bec3a6/numba-0.68.0.tar.gz", upload-time = 2026-09-30T15:05:44Z, size = 2855363, hashes = { sha256 = "8a781de54b980b98f43bff7f1093701b5f07c80d031c7cfa8a87493d8bf73f2d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/af/4d/aa2cefeef784c5695790931938944f76ee66d3c7c640f62326f64642f1c6/numba-0.68.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-09-30T15:04:55Z, size = 3600404, hashes = { sha256 = "e3ee1f49b62efbbb804f731f2bd602bd1f8b8d3cc13009f25d69955675f82407" } }] + +[[packages]] +name = "numpy" +version = "2.4.4" +sdist = { url = "https://files.pythonhosted.org/packages/d7/9f/b8cef5bffa569759033adda9481211426f12f53299629b410340795c2514/numpy-2.4.4.tar.gz", upload-time = 2026-03-29T13:22:01Z, size = 20731587, hashes = { sha256 = "2d390634c5182175533585cc89f3608a4682ccb173cc9bb940b2881c8d6f8fa0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7f/37/eed308a8f56cba4d1fdf467a4fc67ef4ff4bf1c888f5fc980481890104b1/numpy-2.4.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-03-29T13:19:00Z, size = 15670666, hashes = { sha256 = "f9e75681b59ddaa5e659898085ae0eaea229d054f2ac0c7e563a62205a700121" } }] + +[[packages]] +name = "opf" +version = "0.1.0" +vcs = { type = "git", url = "https://github.com/openai/privacy-filter", requested-revision = "f7f00ca7fb869683eb732c010299d901457f19c3", commit-id = "f7f00ca7fb869683eb732c010299d901457f19c3" } + +[[packages]] +name = "packaging" +version = "24.2" +sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", upload-time = 2024-11-08T09:47:47Z, size = 163950, hashes = { sha256 = "c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", upload-time = 2024-11-08T09:47:44Z, size = 65451, hashes = { sha256 = "09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759" } }] + +[[packages]] +name = "pillow" +version = "12.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/1c/3d/bb7fca845737cf9d7dbde16ed1843984665ff2e0a518f5db43e77ec540b9/pillow-12.3.0.tar.gz", upload-time = 2026-07-01T11:56:38Z, size = 47025035, hashes = { sha256 = "3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/25/27/ac8f99618ffd3dde21db0f4d4b1d2ab00c0880595bfd17df103f7f39fd0c/pillow-12.3.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-07-01T11:54:11Z, size = 6266838, hashes = { sha256 = "d9c7f76c0673154f044e9d78c8655fb4213f6ca31a836df48b40fe5d187717b9" } }] + +[[packages]] +name = "platformdirs" +version = "4.9.6" +sdist = { url = "https://files.pythonhosted.org/packages/9f/4a/0883b8e3802965322523f0b200ecf33d31f10991d0401162f4b23c698b42/platformdirs-4.9.6.tar.gz", upload-time = 2026-04-09T00:04:10Z, size = 29400, hashes = { sha256 = "3bfa75b0ad0db84096ae777218481852c0ebc6c727b3168c1b9e0118e458cf0a" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/75/a6/a0a304dc33b49145b21f4808d763822111e67d1c3a32b524a1baf947b6e1/platformdirs-4.9.6-py3-none-any.whl", upload-time = 2026-04-09T00:04:09Z, size = 21348, hashes = { sha256 = "e61adb1d5e5cb3441b4b7710bea7e4c12250ca49439228cc1021c00dcfac0917" } }] + +[[packages]] +name = "pooch" +version = "1.9.0" +sdist = { url = "https://files.pythonhosted.org/packages/83/43/85ef45e8b36c6a48546af7b266592dc32d7f67837a6514d111bced6d7d75/pooch-1.9.0.tar.gz", upload-time = 2026-01-30T19:15:09Z, size = 61788, hashes = { sha256 = "de46729579b9857ffd3e741987a2f6d5e0e03219892c167c6578c0091fb511ed" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/2d/d4bf65e47cea8ff2c794a600c4fd1273a7902f268757c531e0ee9f18aa58/pooch-1.9.0-py3-none-any.whl", upload-time = 2026-01-30T19:15:08Z, size = 67175, hashes = { sha256 = "f265597baa9f760d25ceb29d0beb8186c243d6607b0f60b83ecf14078dbc703b" } }] + +[[packages]] +name = "pycparser" +version = "3.0" +marker = "implementation_name != 'PyPy'" +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", upload-time = 2026-01-21T14:26:51Z, size = 103492, hashes = { sha256 = "600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", upload-time = 2026-01-21T14:26:50Z, size = 48172, hashes = { sha256 = "b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992" } }] + +[[packages]] +name = "pydantic" +version = "2.12.5" +sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", upload-time = 2025-11-26T15:11:46Z, size = 821591, hashes = { sha256 = "4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", upload-time = 2025-11-26T15:11:44Z, size = 463580, hashes = { sha256 = "e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d" } }] + +[[packages]] +name = "pydantic-core" +version = "2.41.5" +sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", upload-time = 2025-11-04T13:43:49Z, size = 460952, hashes = { sha256 = "08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2025-11-04T13:40:02Z, size = 1919200, hashes = { sha256 = "e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69" } }] + +[[packages]] +name = "pygments" +version = "2.20.0" +sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", upload-time = 2026-03-29T13:29:33Z, size = 4955991, hashes = { sha256 = "6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", upload-time = 2026-03-29T13:29:30Z, size = 1231151, hashes = { sha256 = "81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176" } }] + +[[packages]] +name = "pyyaml" +version = "6.0.3" +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", upload-time = 2025-09-25T21:33:16Z, size = 130960, hashes = { sha256 = "d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2025-09-25T21:32:13Z, size = 775116, hashes = { sha256 = "9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28" } }] + +[[packages]] +name = "regex" +version = "2026.4.4" +sdist = { url = "https://files.pythonhosted.org/packages/cb/0e/3a246dbf05666918bd3664d9d787f84a9108f6f43cc953a077e4a7dfdb7e/regex-2026.4.4.tar.gz", upload-time = 2026-04-03T20:56:28Z, size = 416000, hashes = { sha256 = "e08270659717f6973523ce3afbafa53515c4dc5dcad637dc215b6fd50f689423" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/31/87/3accf55634caad8c0acab23f5135ef7d4a21c39f28c55c816ae012931408/regex-2026.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-04-03T20:53:45Z, size = 796651, hashes = { sha256 = "760ef21c17d8e6a4fe8cf406a97cf2806a4df93416ccc82fc98d25b1c20425be" } }] + +[[packages]] +name = "requests" +version = "2.33.1" +sdist = { url = "https://files.pythonhosted.org/packages/5f/a4/98b9c7c6428a668bf7e42ebb7c79d576a1c3c1e3ae2d47e674b468388871/requests-2.33.1.tar.gz", upload-time = 2026-03-30T16:09:15Z, size = 134120, hashes = { sha256 = "18817f8c57c6263968bc123d237e3b8b08ac046f5456bd1e307ee8f4250d3517" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", upload-time = 2026-03-30T16:09:13Z, size = 64947, hashes = { sha256 = "4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a" } }] + +[[packages]] +name = "rich" +version = "13.9.4" +sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", upload-time = 2024-11-01T16:43:57Z, size = 223149, hashes = { sha256 = "439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", upload-time = 2024-11-01T16:43:55Z, size = 242424, hashes = { sha256 = "6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90" } }] + +[[packages]] +name = "safetensors" +version = "0.8.0" +sdist = { url = "https://files.pythonhosted.org/packages/45/06/f955dbbb1859e3bd23c8ac6141af5106e7ad5fedec4a3a6e3d60f94b7001/safetensors-0.8.0.tar.gz", upload-time = 2026-06-09T07:52:25Z, size = 325846, hashes = { sha256 = "fabaf3e0f18a6618d9b36560682562157f77c2b71fcffc7b432be2baed9d753d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/09/7d/65a7de0af421317bb36a067241e4235fff194eed60b961ed6d3f59a3fc60/safetensors-0.8.0-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2026-06-09T07:52:07Z, size = 502844, hashes = { sha256 = "7a46e5ff292c356d6991e60942ba7f79817682d3a2cef0702136448cb9c4d235" } }] + +[[packages]] +name = "scikit-learn" +version = "1.8.0" +sdist = { url = "https://files.pythonhosted.org/packages/0e/d4/40988bf3b8e34feec1d0e6a051446b1f66225f8529b9309becaeef62b6c4/scikit_learn-1.8.0.tar.gz", upload-time = 2025-12-10T07:08:53Z, size = 7335585, hashes = { sha256 = "9bccbb3b40e3de10351f8f5068e105d0f4083b1a65fa07b6634fbc401a6287fd" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/dd/47/f187b4636ff80cc63f21cd40b7b2d177134acaa10f6bb73746130ee8c2e5/scikit_learn-1.8.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2025-12-10T07:07:55Z, size = 8660492, hashes = { sha256 = "4496bb2cf7a43ce1a2d7524a79e40bc5da45cf598dbf9545b7e8316ccba47bb4" } }] + +[[packages]] +name = "scipy" +version = "1.17.1" +sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", upload-time = 2026-02-23T00:26:24Z, size = 30573822, hashes = { sha256 = "95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/da/34/16f10e3042d2f1d6b66e0428308ab52224b6a23049cb2f5c1756f713815f/scipy-1.17.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-02-23T00:18:35Z, size = 32927842, hashes = { sha256 = "e19ebea31758fac5893a2ac360fedd00116cbb7628e650842a6691ba7ca28a21" } }] + +[[packages]] +name = "sentence-transformers" +version = "5.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/9d/59/867381b1414a975da6c9953f48a07c05cb0629305e2d37c9bcc9764367b2/sentence_transformers-5.7.0.tar.gz", upload-time = 2026-08-06T12:12:33Z, size = 466382, hashes = { sha256 = "fd8c8fc35e6323631dff9f3760969ebf7980dc3cfda0ab1354bc6a774cc0e5d8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e8/c8/f63d99e354532f5b83e735dd1e001bda92495fbfde934f65d924abf2b071/sentence_transformers-5.7.0-py3-none-any.whl", upload-time = 2026-08-06T12:12:31Z, size = 611333, hashes = { sha256 = "b78141da3d8137e70d965866e2ca43190b9266f3d4d8752e250ded75e7136730" } }] + +[[packages]] +name = "setuptools" +version = "83.0.0" +marker = "python_full_version >= '3.12'" +sdist = { url = "https://files.pythonhosted.org/packages/34/26/f5d29e25ffdb535afef2d35cdb55b325298f96debd670da4c325e08d70f4/setuptools-83.0.0.tar.gz", upload-time = 2026-07-04T15:31:22Z, size = 1154254, hashes = { sha256 = "025bccbbf0fa05b6192bc64ae1e7b16e001fd6d6d4d5de03c97b1c1ade523bef" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5d/40/e1e72872c6354b306daef1703549e8e83b4d43cfea356311bf722a043752/setuptools-83.0.0-py3-none-any.whl", upload-time = 2026-07-04T15:31:20Z, size = 1008090, hashes = { sha256 = "29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3" } }] + +[[packages]] +name = "shellingham" +version = "1.5.4" +sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", upload-time = 2023-10-24T04:13:40Z, size = 10310, hashes = { sha256 = "8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", upload-time = 2023-10-24T04:13:38Z, size = 9755, hashes = { sha256 = "7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686" } }] + +[[packages]] +name = "soundfile" +version = "0.14.0" +sdist = { url = "https://files.pythonhosted.org/packages/d2/db/949331952a6fb1c5b12e9de80fd08747966c2039d1a61db4764fbd3981c2/soundfile-0.14.0.tar.gz", upload-time = 2026-06-06T08:58:47Z, size = 47842, hashes = { sha256 = "ba1c1a2d618bca5c406647c83b89f07cc8810fa506a50622a6993ba130c1de11" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/d1/5e338af9ca6ed0786cd5bb03f6d60de1c325728c1189014f3b59aae7403c/soundfile-0.14.0-py2.py3-none-any.whl", upload-time = 2026-06-06T08:58:33Z, size = 26799, hashes = { sha256 = "8ba81ae3a89fd5ab3bef8a8eb481fbbe794e806309675a89b4df48b8d31908a8" } }, + { url = "https://files.pythonhosted.org/packages/4a/f8/fc39fad6f879633461d27394cd1ddaf1f769ffa0597dca35872f51b16461/soundfile-0.14.0-py2.py3-none-manylinux_2_28_aarch64.whl", upload-time = 2026-06-06T08:58:39Z, size = 1238050, hashes = { sha256 = "e85724a90bc99a6e8062c0b4ddf725f53b2a3b70afd4da875e9d2cfc4e92f377" } }, +] + +[[packages]] +name = "soxr" +version = "1.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/ed/11/27cebce4a108f77afea7c80545115536b45e3f11ebfb914f638fdd9ba847/soxr-1.1.0.tar.gz", upload-time = 2026-05-03T00:15:18Z, size = 173067, hashes = { sha256 = "9f228ae21c78fa9359ca98d8a5e8e91f30639e438e574133dace62c5b5309e44" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/88/2b/2e5eba817a762a2ec589ff165b8bc5955b25a0ad140045f7cd8e45410543/soxr-1.1.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-05-03T00:14:57Z, size = 206529, hashes = { sha256 = "bf98c0d7b7d5ef5bf072fee8d3020e8b664f2d195933ea7bc5089267c2e22a06" } }] + +[[packages]] +name = "sympy" +version = "1.14.0" +sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", upload-time = 2025-04-27T18:05:01Z, size = 7793921, hashes = { sha256 = "d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", upload-time = 2025-04-27T18:04:59Z, size = 6299353, hashes = { sha256 = "e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5" } }] + +[[packages]] +name = "threadpoolctl" +version = "3.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/b7/4d/08c89e34946fce2aec4fbb45c9016efd5f4d7f24af8e5d93296e935631d8/threadpoolctl-3.6.0.tar.gz", upload-time = 2025-03-13T13:49:23Z, size = 21274, hashes = { sha256 = "8ab8b4aa3491d812b623328249fab5302a68d2d71745c8a4c719a2fcaba9f44e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", upload-time = 2025-03-13T13:49:21Z, size = 18638, hashes = { sha256 = "43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb" } }] + +[[packages]] +name = "tiktoken" +version = "0.12.0" +sdist = { url = "https://files.pythonhosted.org/packages/7d/ab/4d017d0f76ec3171d469d80fc03dfbb4e48a4bcaddaa831b31d526f05edc/tiktoken-0.12.0.tar.gz", upload-time = 2025-10-06T20:22:45Z, size = 37806, hashes = { sha256 = "b18ba7ee2b093863978fcb14f74b3707cdc8d4d4d3836853ce7ec60772139931" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/66/c5/ed88504d2f4a5fd6856990b230b56d85a777feab84e6129af0822f5d0f70/tiktoken-0.12.0-cp312-cp312-manylinux_2_28_aarch64.whl", upload-time = 2025-10-06T20:21:54Z, size = 1129008, hashes = { sha256 = "65b26c7a780e2139e73acc193e5c63ac754021f160df919add909c1492c0fb37" } }] + +[[packages]] +name = "tokenizers" +version = "0.23.3" +sdist = { url = "https://files.pythonhosted.org/packages/e0/7c/2cabb2174e772636683008f2c5621949b645da7d303c596589e84516a184/tokenizers-0.23.3.tar.gz", upload-time = 2026-10-09T10:16:55Z, size = 385286, hashes = { sha256 = "cded33237c77caeef62944d32aa9a7ef42bdce2b3497e18d137e072a8c4be438" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/15/fc/ae987741829b1cd547668c4c94be732ae3eefd1d74344e64c3d2ca714acd/tokenizers-0.23.3-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2026-10-09T10:00:55Z, size = 3519944, hashes = { sha256 = "ec82e80e65a862275b97c3d90b7a523df8d9519ee48aeb4e9625b2cc909274e0" } }] + +[[packages]] +name = "torch" +version = "2.9.1+cpu" +wheels = [{ url = "https://download-r2.pytorch.org/whl/cpu/torch-2.9.1%2Bcpu-cp312-cp312-manylinux_2_28_aarch64.whl", upload-time = 2026-01-23T15:13:02Z, hashes = { sha256 = "3bf9b442a51a2948e41216a76d7ab00f0694cfcaaa51b6f9bcab57b7f89843e6" } }] + +[[packages]] +name = "torchvision" +version = "0.24.1" +wheels = [{ url = "https://download-r2.pytorch.org/whl/cpu/torchvision-0.24.1-cp312-cp312-manylinux_2_28_aarch64.whl", upload-time = 2025-11-15T18:12:46Z, hashes = { sha256 = "28157649758fb97491de0db478d5d6e73c23b508e54de20adbc35e6b3aa72443" } }] + +[[packages]] +name = "tqdm" +version = "4.67.3" +sdist = { url = "https://files.pythonhosted.org/packages/09/a9/6ba95a270c6f1fbcd8dac228323f2777d886cb206987444e4bce66338dd4/tqdm-4.67.3.tar.gz", upload-time = 2026-02-03T17:35:53Z, size = 169598, hashes = { sha256 = "7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", upload-time = 2026-02-03T17:35:50Z, size = 78374, hashes = { sha256 = "ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf" } }] + +[[packages]] +name = "transformers" +version = "5.17.0" +sdist = { url = "https://files.pythonhosted.org/packages/0e/9e/750649904a065007a838981785b2bd8d9ff26154c6c341ac67d0b7f82c68/transformers-5.17.0.tar.gz", upload-time = 2026-09-09T15:39:56Z, size = 9817878, hashes = { sha256 = "a153be279169b55b92d8000bf4af294aed684503d091cca7804da2dd8a9de000" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e8/d0/c502b60d684adbd98a8dc7d5bb866842772b816ac4354e4608be240041ae/transformers-5.17.0-py3-none-any.whl", upload-time = 2026-09-09T15:39:53Z, size = 12295140, hashes = { sha256 = "78ec1ce21579b38dfb83950a0658cd119f87212a2fcfdff478096ce9d6c03801" } }] + +[[packages]] +name = "typer" +version = "0.21.2" +sdist = { url = "https://files.pythonhosted.org/packages/f2/1e/a27cc02a0cd715118c71fa2aef2c687fdefc3c28d90fd0dd789c5118154c/typer-0.21.2.tar.gz", upload-time = 2026-02-10T19:33:46Z, size = 120426, hashes = { sha256 = "1abd95a3b675e17ff61b0838ac637fe9478d446d62ad17fa4bb81ea57cc54028" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b8/cc/d59f893fbdfb5f58770c05febfc4086a46875f1084453621c35605cec946/typer-0.21.2-py3-none-any.whl", upload-time = 2026-02-10T19:33:48Z, size = 56728, hashes = { sha256 = "c3d8de54d00347ef90b82131ca946274f017cffb46683ae3883c360fa958f55c" } }] + +[[packages]] +name = "typing-extensions" +version = "4.15.0" +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", upload-time = 2025-08-25T13:49:26Z, size = 109391, hashes = { sha256 = "0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", upload-time = 2025-08-25T13:49:24Z, size = 44614, hashes = { sha256 = "f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548" } }] + +[[packages]] +name = "typing-inspection" +version = "0.4.2" +sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", upload-time = 2025-10-01T02:14:41Z, size = 75949, hashes = { sha256 = "ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", upload-time = 2025-10-01T02:14:40Z, size = 14611, hashes = { sha256 = "4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7" } }] + +[[packages]] +name = "urllib3" +version = "2.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", upload-time = 2026-05-07T16:13:18Z, size = 433602, hashes = { sha256 = "231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", upload-time = 2026-05-07T16:13:17Z, size = 131087, hashes = { sha256 = "9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897" } }] diff --git a/packages/sie_server/bundle-locks/cuda12-ctranslate2-amd64/manifest.json b/packages/sie_server/bundle-locks/cuda12-ctranslate2-amd64/manifest.json new file mode 100644 index 000000000..2dc8ad650 --- /dev/null +++ b/packages/sie_server/bundle-locks/cuda12-ctranslate2-amd64/manifest.json @@ -0,0 +1,24 @@ +{ + "completed_artifact_hashes": [], + "exceptions_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", + "exclude_newer": "2026-10-18T00:00:00Z", + "indexes": [ + "--default-index", + "https://pypi.org/simple" + ], + "inputs": { + "requirements_sha256": "06013808500bdd0b62b916d46f4b7a308290f5c07567315faf967cfe9f7f5888", + "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" + }, + "lock_sha256": "1f2350156ca95ae0ed398f20d94458135d6c9ac1fd4985419e1ea6873576e718", + "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "schema_version": 1, + "target": { + "architecture": "amd64", + "bundle": "ctranslate2", + "platform": "cuda12", + "python_platform": "x86_64-manylinux_2_35", + "python_version": "3.12" + }, + "uv_version": "0.9.28" +} diff --git a/packages/sie_server/bundle-locks/cuda12-ctranslate2-amd64/pylock.toml b/packages/sie_server/bundle-locks/cuda12-ctranslate2-amd64/pylock.toml new file mode 100644 index 000000000..c90321074 --- /dev/null +++ b/packages/sie_server/bundle-locks/cuda12-ctranslate2-amd64/pylock.toml @@ -0,0 +1,26 @@ +lock-version = "1.0" +created-by = "uv" +requires-python = ">=3.12" + +[[packages]] +name = "ctranslate2" +version = "4.8.1" +wheels = [{ url = "https://files.pythonhosted.org/packages/47/c9/976a565398a03fb2973cbe5edd5ca03c4332d86b634799e0ee562420d3bc/ctranslate2-4.8.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-03T12:39:20Z, size = 39529060, hashes = { sha256 = "dacc408f716ebc73b3b3c6ddd937700e776c4c68b6d9c81862990150ff0f6af6" } }] + +[[packages]] +name = "numpy" +version = "2.4.4" +sdist = { url = "https://files.pythonhosted.org/packages/d7/9f/b8cef5bffa569759033adda9481211426f12f53299629b410340795c2514/numpy-2.4.4.tar.gz", upload-time = 2026-03-29T13:22:01Z, size = 20731587, hashes = { sha256 = "2d390634c5182175533585cc89f3608a4682ccb173cc9bb940b2881c8d6f8fa0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0a/0d/0e3ecece05b7a7e87ab9fb587855548da437a061326fff64a223b6dcb78a/numpy-2.4.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-29T13:19:03Z, size = 16645480, hashes = { sha256 = "81f4a14bee47aec54f883e0cad2d73986640c1590eb9bfaaba7ad17394481e6e" } }] + +[[packages]] +name = "pyyaml" +version = "6.0.3" +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", upload-time = 2025-09-25T21:33:16Z, size = 130960, hashes = { sha256 = "d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-09-25T21:32:16Z, size = 807870, hashes = { sha256 = "ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc" } }] + +[[packages]] +name = "setuptools" +version = "83.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/34/26/f5d29e25ffdb535afef2d35cdb55b325298f96debd670da4c325e08d70f4/setuptools-83.0.0.tar.gz", upload-time = 2026-07-04T15:31:22Z, size = 1154254, hashes = { sha256 = "025bccbbf0fa05b6192bc64ae1e7b16e001fd6d6d4d5de03c97b1c1ade523bef" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5d/40/e1e72872c6354b306daef1703549e8e83b4d43cfea356311bf722a043752/setuptools-83.0.0-py3-none-any.whl", upload-time = 2026-07-04T15:31:20Z, size = 1008090, hashes = { sha256 = "29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3" } }] diff --git a/packages/sie_server/bundle-locks/cuda12-default-amd64/manifest.json b/packages/sie_server/bundle-locks/cuda12-default-amd64/manifest.json new file mode 100644 index 000000000..f89a01ae3 --- /dev/null +++ b/packages/sie_server/bundle-locks/cuda12-default-amd64/manifest.json @@ -0,0 +1,24 @@ +{ + "completed_artifact_hashes": [], + "exceptions_sha256": "99c2c6f4cb441dcac5f4a95627ecdc924ab2222d89e65f007822069fcb5f2155", + "exclude_newer": "2026-10-18T00:00:00Z", + "indexes": [ + "--default-index", + "https://pypi.org/simple" + ], + "inputs": { + "requirements_sha256": "dec989589f6cfea36a7a0dc03ad0b837d8f8e22d4764a396b0651554cae16285", + "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" + }, + "lock_sha256": "913c67d8a1215c8b68a1bf909c86742b14b12fc3f8e17dbbe11951505d603c2b", + "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "schema_version": 1, + "target": { + "architecture": "amd64", + "bundle": "default", + "platform": "cuda12", + "python_platform": "x86_64-manylinux_2_35", + "python_version": "3.12" + }, + "uv_version": "0.9.28" +} diff --git a/packages/sie_server/bundle-locks/cuda12-default-amd64/pylock.toml b/packages/sie_server/bundle-locks/cuda12-default-amd64/pylock.toml new file mode 100644 index 000000000..408bcc58c --- /dev/null +++ b/packages/sie_server/bundle-locks/cuda12-default-amd64/pylock.toml @@ -0,0 +1,993 @@ +lock-version = "1.0" +created-by = "uv" +requires-python = ">=3.12" + +[[packages]] +name = "accelerate" +version = "1.15.0" +sdist = { url = "https://files.pythonhosted.org/packages/f5/b5/1d3ed029ac71d3f2961346829a268da923698e9fd63f218f78841f216bfd/accelerate-1.15.0.tar.gz", upload-time = 2026-09-09T13:04:49Z, size = 422615, hashes = { sha256 = "5654f8c5eaa0d4fa68b33e287a97765da6849bf6d51dcac874e73fbbddfb6134" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8a/4c/34f0450479d01195027260da68d8a3880683f1640c3ca5adf64acb3185f1/accelerate-1.15.0-py3-none-any.whl", upload-time = 2026-09-09T13:04:47Z, size = 394295, hashes = { sha256 = "97eacca0b73e45cb867dbf8c5d5d4dc32219544300e0c8992c7334dc2ef33cec" } }] + +[[packages]] +name = "aiohappyeyeballs" +version = "2.6.1" +sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", upload-time = 2025-03-12T01:42:48Z, size = 22760, hashes = { sha256 = "c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", upload-time = 2025-03-12T01:42:47Z, size = 15265, hashes = { sha256 = "f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8" } }] + +[[packages]] +name = "aiohttp" +version = "3.14.3" +sdist = { url = "https://files.pythonhosted.org/packages/58/d9/22ce5786ac0c1653ae8b6c23bded02c1686d11f0dbb45b31ce128e0df985/aiohttp-3.14.3.tar.gz", upload-time = 2026-07-23T01:57:27Z, size = 7971213, hashes = { sha256 = "9491196535a88924a60afd5b5f434b5b203b6cc616250878dbdb223a8f7844bc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/52/b7/7cd31f29d6055bd711ae6e669367fba6f5ae9de463910a793e30556a8db7/aiohttp-3.14.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-23T01:54:15Z, size = 1792122, hashes = { sha256 = "543906c127fb1d929b95076db19b83fa2d46751006ff1e23b093aa5ac4d8db42" } }] + +[[packages]] +name = "aiosignal" +version = "1.4.0" +sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", upload-time = 2025-07-03T22:54:43Z, size = 25007, hashes = { sha256 = "f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", upload-time = 2025-07-03T22:54:42Z, size = 7490, hashes = { sha256 = "053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e" } }] + +[[packages]] +name = "annotated-doc" +version = "0.0.4" +sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", upload-time = 2025-11-10T22:07:42Z, size = 7288, hashes = { sha256 = "fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", upload-time = 2025-11-10T22:07:40Z, size = 5303, hashes = { sha256 = "571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320" } }] + +[[packages]] +name = "annotated-types" +version = "0.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", upload-time = 2024-05-20T21:33:25Z, size = 16081, hashes = { sha256 = "aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", upload-time = 2024-05-20T21:33:24Z, size = 13643, hashes = { sha256 = "1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53" } }] + +[[packages]] +name = "antlr4-python3-runtime" +version = "4.9.3" +sdist = { url = "https://files.pythonhosted.org/packages/3e/38/7859ff46355f76f8d19459005ca000b6e7012f2f1ca597746cbcd1fbfe5e/antlr4-python3-runtime-4.9.3.tar.gz", upload-time = 2021-11-06T17:52:23Z, size = 117034, hashes = { sha256 = "f224469b4168294902bb1efa80a8bf7855f24c99aef99cbefc1bcd3cce77881b" } } + +[[packages]] +name = "anyio" +version = "4.14.2" +sdist = { url = "https://files.pythonhosted.org/packages/61/cc/a381afa6efea9f496eff839d4a6a1aed3bfafc7b3ab4b0d1b243a12573dd/anyio-4.14.2.tar.gz", upload-time = 2026-07-12T20:29:07Z, size = 260176, hashes = { sha256 = "cfa139f3ed1a23ee8f88a145ddb5ac7605b8bbfd8592baacd7ce3d8bb4313c7f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/da/35/f2287558c17e29fafc8ef3daf819bb9834061cfa43bff8014f7df7f63bdc/anyio-4.14.2-py3-none-any.whl", upload-time = 2026-07-12T20:29:05Z, size = 125813, hashes = { sha256 = "9f505dda5ac9f0c8309b5e8bd445a8c2bf7246f3ce950121e45ea15bc41d1494" } }] + +[[packages]] +name = "attrs" +version = "26.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", upload-time = 2026-03-19T14:22:25Z, size = 952055, hashes = { sha256 = "d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", upload-time = 2026-03-19T14:22:23Z, size = 67548, hashes = { sha256 = "c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309" } }] + +[[packages]] +name = "beautifulsoup4" +version = "4.14.3" +sdist = { url = "https://files.pythonhosted.org/packages/c3/b0/1c6a16426d389813b48d95e26898aff79abbde42ad353958ad95cc8c9b21/beautifulsoup4-4.14.3.tar.gz", upload-time = 2025-11-30T15:08:26Z, size = 627737, hashes = { sha256 = "6292b1c5186d356bba669ef9f7f051757099565ad9ada5dd630bd9de5fa7fb86" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1a/39/47f9197bdd44df24d67ac8893641e16f386c984a0619ef2ee4c51fbbc019/beautifulsoup4-4.14.3-py3-none-any.whl", upload-time = 2025-11-30T15:08:24Z, size = 107721, hashes = { sha256 = "0918bfe44902e6ad8d57732ba310582e98da931428d231a5ecb9e7c703a735bb" } }] + +[[packages]] +name = "cbor" +version = "1.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/9b/99/01c6a987c920500189eb74a291bd3a388e6c7cf85736bb6b066d9833315e/cbor-1.0.0.tar.gz", upload-time = 2016-02-09T23:11:12Z, size = 20096, hashes = { sha256 = "13225a262ddf5615cbd9fd55a76a0d53069d18b07d2e9f19c39e6acb8609bbb6" } } + +[[packages]] +name = "certifi" +version = "2026.4.22" +sdist = { url = "https://files.pythonhosted.org/packages/25/ee/6caf7a40c36a1220410afe15a1cc64993a1f864871f698c0f93acb72842a/certifi-2026.4.22.tar.gz", upload-time = 2026-04-22T11:26:11Z, size = 137077, hashes = { sha256 = "8d455352a37b71bf76a79caa83a3d6c25afee4a385d632127b6afb3963f1c580" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/22/30/7cd8fdcdfbc5b869528b079bfb76dcdf6056b1a2097a662e5e8c04f42965/certifi-2026.4.22-py3-none-any.whl", upload-time = 2026-04-22T11:26:09Z, size = 135707, hashes = { sha256 = "3cb2210c8f88ba2318d29b0388d1023c8492ff72ecdde4ebdaddbb13a31b1c4a" } }] + +[[packages]] +name = "charset-normalizer" +version = "3.4.7" +sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", upload-time = 2026-04-02T09:28:39Z, size = 144271, hashes = { sha256 = "ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4b/f8/d0118a2f5f23b02cd166fa385c60f9b0d4f9194f574e2b31cef350ad7223/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-02T09:26:29Z, size = 216589, hashes = { sha256 = "5649fd1c7bade02f320a462fdefd0b4bd3ce036065836d4f42e0de958038e116" } }, + { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", upload-time = 2026-04-02T09:28:37Z, size = 61958, hashes = { sha256 = "3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d" } }, +] + +[[packages]] +name = "click" +version = "8.1.8" +sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", upload-time = 2024-12-21T18:38:44Z, size = 226593, hashes = { sha256 = "ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", upload-time = 2024-12-21T18:38:41Z, size = 98188, hashes = { sha256 = "63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2" } }] + +[[packages]] +name = "colorlog" +version = "6.10.1" +sdist = { url = "https://files.pythonhosted.org/packages/a2/61/f083b5ac52e505dfc1c624eafbf8c7589a0d7f32daa398d2e7590efa5fda/colorlog-6.10.1.tar.gz", upload-time = 2025-10-16T16:14:11Z, size = 17162, hashes = { sha256 = "eb4ae5cb65fe7fec7773c2306061a8e63e02efc2c72eba9d27b0fa23c94f1321" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/6d/c1/e419ef3723a074172b68aaa89c9f3de486ed4c2399e2dbd8113a4fdcaf9e/colorlog-6.10.1-py3-none-any.whl", upload-time = 2025-10-16T16:14:10Z, size = 11743, hashes = { sha256 = "2d7e8348291948af66122cff006c9f8da6255d224e7cf8e37d8de2df3bad8c9c" } }] + +[[packages]] +name = "datasets" +version = "3.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/1a/89/d3d6fef58a488f8569c82fd293ab7cbd4250244d67f425dcae64c63800ea/datasets-3.6.0.tar.gz", upload-time = 2025-05-07T15:15:02Z, size = 569336, hashes = { sha256 = "1b2bf43b19776e2787e181cfd329cb0ca1a358ea014780c3581e0f276375e041" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/20/34/a08b0ee99715eaba118cbe19a71f7b5e2425c2718ef96007c325944a1152/datasets-3.6.0-py3-none-any.whl", upload-time = 2025-05-07T15:14:59Z, size = 491546, hashes = { sha256 = "25000c4a2c0873a710df127d08a202a06eab7bf42441a6bc278b499c2f72cd1b" } }] + +[[packages]] +name = "defusedxml" +version = "0.7.1" +sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", upload-time = 2021-03-08T10:59:26Z, size = 75520, hashes = { sha256 = "1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", upload-time = 2021-03-08T10:59:24Z, size = 25604, hashes = { sha256 = "a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61" } }] + +[[packages]] +name = "dill" +version = "0.3.8" +sdist = { url = "https://files.pythonhosted.org/packages/17/4d/ac7ffa80c69ea1df30a8aa11b3578692a5118e7cd1aa157e3ef73b092d15/dill-0.3.8.tar.gz", upload-time = 2024-01-27T23:42:16Z, size = 184847, hashes = { sha256 = "3ebe3c479ad625c4553aca177444d89b486b1d84982eeacded644afc0cf797ca" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c9/7a/cef76fd8438a42f96db64ddaa85280485a9c395e7df3db8158cfec1eee34/dill-0.3.8-py3-none-any.whl", upload-time = 2024-01-27T23:42:14Z, size = 116252, hashes = { sha256 = "c36ca9ffb54365bdd2f8eb3eff7d2a21237f8452b57ace88b1ac615b7e815bd7" } }] + +[[packages]] +name = "docling" +version = "2.99.0" +sdist = { url = "https://files.pythonhosted.org/packages/61/73/f6a0d6ada626281c1914dfb2de30c6e0067b1f8e3993e77eabb05fb08bf6/docling-2.99.0.tar.gz", upload-time = 2026-06-08T15:14:20Z, size = 8755, hashes = { sha256 = "306ea071d935f3852f75c873fe1b8663da580d2c359b8de162da52a6151c4c91" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/05/cc/cd8bea43057e64ec7755a18e009270500263f513e058649b909e83e2c0a7/docling-2.99.0-py3-none-any.whl", upload-time = 2026-06-08T15:14:19Z, size = 4798, hashes = { sha256 = "a78d4fd34e4ca495cd50003288b4de4a9b040dbff59f8ca5624aa8fa37d43728" } }] + +[[packages]] +name = "docling-core" +version = "2.79.0" +sdist = { url = "https://files.pythonhosted.org/packages/4d/b3/9196498f28c5a872b76b356df3ccefc20f2978eea12b8459a3398d036a2e/docling_core-2.79.0.tar.gz", upload-time = 2026-06-05T17:48:55Z, size = 334965, hashes = { sha256 = "3a5c6f757a95b93a1bb4c2c46efbe580f35a390f762a4b4105d97b7fca7cdfeb" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d0/f2/2cbf2b8ba8f2ebdefa5ebed29cf1d2eb4306a57ebf6c8b98703b7d4e2054/docling_core-2.79.0-py3-none-any.whl", upload-time = 2026-06-05T17:48:53Z, size = 286672, hashes = { sha256 = "42540cbd7ff8bca264e8e8fda9a66ad4446613f520bee8e130588193bc3e0212" } }] + +[[packages]] +name = "docling-ibm-models" +version = "3.13.2" +sdist = { url = "https://files.pythonhosted.org/packages/c1/25/84166f5751d7837612138966669019a4ef67c09bf6d3ef8d3cc1aa0e6268/docling_ibm_models-3.13.2.tar.gz", upload-time = 2026-04-23T11:04:23Z, size = 98655, hashes = { sha256 = "195e02dd119df34d2ce5f76ac614da82825851013e4898db7b0468cdf8740a3d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a4/fc/584f75ca31aa6694fed5338ecb54dc4c8341704b1e5b7b6a4528651f12fa/docling_ibm_models-3.13.2-py3-none-any.whl", upload-time = 2026-04-23T11:04:22Z, size = 94013, hashes = { sha256 = "5fa0838bf15a4e06d2fcb686d756a6f4c329ea0a8820d085f06d07abe96269ed" } }] + +[[packages]] +name = "docling-parse" +version = "6.2.0" +sdist = { url = "https://files.pythonhosted.org/packages/64/46/2c9c0738452368ad63018f380f4ad6fad8c69b64f04222aa012190bc8a4f/docling_parse-6.2.0.tar.gz", upload-time = 2026-05-28T04:31:53Z, size = 6670444, hashes = { sha256 = "f13d6c49e3b5f9caaf0d626e0dcc7948c5b4700d0eae0559ec353ed07c4f2f50" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3c/dd/572cde51f4c192a2752680e76fcb030cb997f656b4eea3b196fe8b7b7b2b/docling_parse-6.2.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-05-28T04:31:27Z, size = 10191025, hashes = { sha256 = "05f6b1e15408741953ee4beb61442168c3267489634ce16ebd8e9214deec621e" } }] + +[[packages]] +name = "docling-slim" +version = "2.99.0" +sdist = { url = "https://files.pythonhosted.org/packages/a3/10/42e81debe1b7db6ae6dbbcd41f90f2aaa59501a1089fe9f304821783c409/docling_slim-2.99.0.tar.gz", upload-time = 2026-06-08T15:12:53Z, size = 410480, hashes = { sha256 = "b05150cda69e4c24c85aa32d2e329f21188dd4304547928eab32d8bb8b645bba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1c/d8/caa986a093c89238cc4019e10885677ffe4ee7aeb46a807626ac18654dfb/docling_slim-2.99.0-py3-none-any.whl", upload-time = 2026-06-08T15:12:51Z, size = 530895, hashes = { sha256 = "f67e31ca3cc39c5b19df3cfcb8fbe7bcc5ef29ffff320bbafca56e3b9ce40f24" } }] + +[[packages]] +name = "einops" +version = "0.8.2" +sdist = { url = "https://files.pythonhosted.org/packages/2c/77/850bef8d72ffb9219f0b1aac23fbc1bf7d038ee6ea666f331fa273031aa2/einops-0.8.2.tar.gz", upload-time = 2026-01-26T04:13:17Z, size = 56261, hashes = { sha256 = "609da665570e5e265e27283aab09e7f279ade90c4f01bcfca111f3d3e13f2827" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/09/f8d8f8f31e4483c10a906437b4ce31bdf3d6d417b73fe33f1a8b59e34228/einops-0.8.2-py3-none-any.whl", upload-time = 2026-01-26T04:13:18Z, size = 65638, hashes = { sha256 = "54058201ac7087911181bfec4af6091bb59380360f069276601256a76af08193" } }] + +[[packages]] +name = "et-xmlfile" +version = "2.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/d3/38/af70d7ab1ae9d4da450eeec1fa3918940a5fafb9055e934af8d6eb0c2313/et_xmlfile-2.0.0.tar.gz", upload-time = 2024-10-25T17:25:40Z, size = 17234, hashes = { sha256 = "dab3f4764309081ce75662649be815c4c9081e88f0837825f90fd28317d4da54" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c1/8b/5fe2cc11fee489817272089c4203e679c63b570a5aaeb18d852ae3cbba6a/et_xmlfile-2.0.0-py3-none-any.whl", upload-time = 2024-10-25T17:25:39Z, size = 18059, hashes = { sha256 = "7a91720bc756843502c3b7504c77b8fe44217c85c537d85037f0f536151b2caa" } }] + +[[packages]] +name = "faker" +version = "40.15.0" +sdist = { url = "https://files.pythonhosted.org/packages/7f/13/6741787bd91c4109c7bed047d68273965cd52ce8a5f773c471b949334b6d/faker-40.15.0.tar.gz", upload-time = 2026-04-17T20:05:27Z, size = 1967447, hashes = { sha256 = "20f3a6ec8c266b74d4c554e34118b21c3c2056c0b4a519d15c8decb3a4e6e795" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a7/a7/a600f8f30d4505e89166de51dd121bd540ab8e560e8cf0901de00a81de8c/faker-40.15.0-py3-none-any.whl", upload-time = 2026-04-17T20:05:25Z, size = 2004447, hashes = { sha256 = "71ab3c3370da9d2205ab74ffb0fd51273063ad562b3a3bb69d0026a20923e318" } }] + +[[packages]] +name = "filelock" +version = "3.29.0" +sdist = { url = "https://files.pythonhosted.org/packages/b5/fe/997687a931ab51049acce6fa1f23e8f01216374ea81374ddee763c493db5/filelock-3.29.0.tar.gz", upload-time = 2026-04-19T15:39:10Z, size = 57571, hashes = { sha256 = "69974355e960702e789734cb4871f884ea6fe50bd8404051a3530bc07809cf90" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/81/47/dd9a212ef6e343a6857485ffe25bba537304f1913bdbed446a23f7f592e1/filelock-3.29.0-py3-none-any.whl", upload-time = 2026-04-19T15:39:08Z, size = 39812, hashes = { sha256 = "96f5f6344709aa1572bbf631c640e4ebeeb519e08da902c39a001882f30ac258" } }] + +[[packages]] +name = "filetype" +version = "1.2.0" +sdist = { url = "https://files.pythonhosted.org/packages/bb/29/745f7d30d47fe0f251d3ad3dc2978a23141917661998763bebb6da007eb1/filetype-1.2.0.tar.gz", upload-time = 2022-11-02T17:34:04Z, size = 998020, hashes = { sha256 = "66b56cd6474bf41d8c54660347d37afcc3f7d1970648de365c102ef77548aadb" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/18/79/1b8fa1bb3568781e84c9200f951c735f3f157429f44be0495da55894d620/filetype-1.2.0-py2.py3-none-any.whl", upload-time = 2022-11-02T17:34:01Z, size = 19970, hashes = { sha256 = "7ce71b6880181241cf7ac8697a2f1eb6a8bd9b429f7ad6d27b8db9ba5f1c2d25" } }] + +[[packages]] +name = "flagembedding" +version = "1.4.0" +sdist = { url = "https://files.pythonhosted.org/packages/07/51/22dc9c448577542b3c3d75ae48eda0a97dfa29552a56cddd87437fec5940/flagembedding-1.4.0.tar.gz", upload-time = 2026-04-22T16:09:54Z, size = 175024, hashes = { sha256 = "2079c14ecf0341d64519785e53c0401122a752e5b6a0ac497f23c02f0d21b3b9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/73/70/3593ccb1299f8440369fd3c542ef2f5c09718eb8c7628614303e65dd38f8/flagembedding-1.4.0-py3-none-any.whl", upload-time = 2026-04-22T16:09:52Z, size = 247714, hashes = { sha256 = "fb1856b312851591341cf4533187350e9ce43f66bbf195c66f25a73266ff7db9" } }] + +[[packages]] +name = "flash-attn" +version = "2.7.4+cu129torch2.9" +marker = "sys_platform == 'linux'" +archive = { url = "https://github.com/mjun0812/flash-attention-prebuild-wheels/releases/download/v0.7.11/flash_attn-2.7.4+cu129torch2.9-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hashes = { sha256 = "0a8f6219e61f8ff923cfd2cdad105d95a66106a6c9e754486d778c3a25e7707f" } } + +[[packages]] +name = "flatbuffers" +version = "25.12.19" +wheels = [{ url = "https://files.pythonhosted.org/packages/e8/2d/d2a548598be01649e2d46231d151a6c56d10b964d94043a335ae56ea2d92/flatbuffers-25.12.19-py2.py3-none-any.whl", upload-time = 2025-12-19T23:16:13Z, size = 26661, hashes = { sha256 = "7634f50c427838bb021c2d66a3d1168e9d199b0607e6329399f04846d42e20b4" } }] + +[[packages]] +name = "frozenlist" +version = "1.8.0" +sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", upload-time = 2025-10-06T05:38:17Z, size = 45875, hashes = { sha256 = "3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2025-10-06T05:36:09Z, size = 242411, hashes = { sha256 = "494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383" } }, + { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", upload-time = 2025-10-06T05:38:16Z, size = 13409, hashes = { sha256 = "0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d" } }, +] + +[[packages]] +name = "fsspec" +version = "2025.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/34/f4/5721faf47b8c499e776bc34c6a8fc17efdf7fdef0b00f398128bc5dcb4ac/fsspec-2025.3.0.tar.gz", upload-time = 2025-03-07T21:47:56Z, size = 298491, hashes = { sha256 = "a935fd1ea872591f2b5148907d103488fc523295e6c64b835cfad8c3eca44972" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/56/53/eb690efa8513166adef3e0669afd31e95ffde69fb3c52ec2ac7223ed6018/fsspec-2025.3.0-py3-none-any.whl", upload-time = 2025-03-07T21:47:54Z, size = 193615, hashes = { sha256 = "efb87af3efa9103f94ca91a7f8cb7a4df91af9f74fc106c9c7ea0efd7277c1b3" } }] + +[[packages]] +name = "ftfy" +version = "6.3.1" +sdist = { url = "https://files.pythonhosted.org/packages/a5/d3/8650919bc3c7c6e90ee3fa7fd618bf373cbbe55dff043bd67353dbb20cd8/ftfy-6.3.1.tar.gz", upload-time = 2024-10-26T00:50:35Z, size = 308927, hashes = { sha256 = "9b3c3d90f84fb267fe64d375a07b7f8912d817cf86009ae134aa03e1819506ec" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ab/6e/81d47999aebc1b155f81eca4477a616a70f238a2549848c38983f3c22a82/ftfy-6.3.1-py3-none-any.whl", upload-time = 2024-10-26T00:50:33Z, size = 44821, hashes = { sha256 = "7c70eb532015cd2f9adb53f101fb6c7945988d023a085d127d1573dc49dd0083" } }] + +[[packages]] +name = "gliclass" +version = "0.1.17" +sdist = { url = "https://files.pythonhosted.org/packages/f5/4d/a14af220823eccbd4f2edfff303b24f0e2acf1a0f4177318347bf0c8524e/gliclass-0.1.17.tar.gz", upload-time = 2026-04-30T14:35:58Z, size = 47472, hashes = { sha256 = "17d2ec477da2270337cad9d8ae4ae90b8c675d1bfed9c73bc77d44996d36b522" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/52/3f/0b4e6253a14af7bd1e7306f0b1a8dc6af607caa4a9868015234ee94ad27c/gliclass-0.1.17-py3-none-any.whl", upload-time = 2026-04-30T14:35:57Z, size = 48821, hashes = { sha256 = "330c89e4fb39b50cc9c62d52c44dc7c5a13303883680706c71b598ecf88ab354" } }] + +[[packages]] +name = "gliformer" +version = "0.1.2" +sdist = { url = "https://files.pythonhosted.org/packages/5e/a7/c0e8c23f576de77c3fd323a045cb56fb4d8821e7c13be7b06ca5c0435d5d/gliformer-0.1.2.tar.gz", upload-time = 2026-09-15T15:40:35Z, size = 422264, hashes = { sha256 = "7b1ae88206dcddce33dacf60f750f509d4188d07f6aa82a7df40d4a1134f800b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3c/06/49c0c4eefd7672025909359ed534a862ea8217fc1e08460ee8957d5cc25b/gliformer-0.1.2-py3-none-any.whl", upload-time = 2026-09-15T15:40:33Z, size = 435508, hashes = { sha256 = "b9a1194b56fc0ab193fef919ad68d0b3086ce2fe3f0b4392ce26873139ac8768" } }] + +[[packages]] +name = "gliner" +version = "0.2.26" +sdist = { url = "https://files.pythonhosted.org/packages/49/18/e199cb97147c4a9260c75e4caf51e17be6ff969b0604a029c9c62810cbe0/gliner-0.2.26.tar.gz", upload-time = 2026-03-19T15:07:22Z, size = 181224, hashes = { sha256 = "6783be92b4b81caa878dcc4269ba37800207c37118d8ff9be028b93bddd6813d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7c/6e/d54d3d2867e29b68a22b144f570c8204209647fccc7879cec5218d6ed5fb/gliner-0.2.26-py3-none-any.whl", upload-time = 2026-03-19T15:07:19Z, size = 170429, hashes = { sha256 = "b9baa47641efb90b9d069add0528ed2464d137991ff097f42b0cab37a91ba991" } }] + +[[packages]] +name = "gliner2" +version = "2.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/b2/a8/2dcfdb8862dbeb488b6b86047075a213cc101ca592eae1a43b824cca74dd/gliner2-2.0.0.tar.gz", upload-time = 2026-08-24T15:13:43Z, size = 565826, hashes = { sha256 = "82b149f893ba0f6adf75ef1db599b6dbecd9811cca34dbd0bac7cd9e90b90ce4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/00/44/87d2803c5c5c6c0bd22bce4d52c66c965dacae29e0121d7e04c9883711df/gliner2-2.0.0-py3-none-any.whl", upload-time = 2026-08-24T15:13:41Z, size = 326214, hashes = { sha256 = "6f7c4cba0ef3173636d8bd9404aa94d4e0ccf36d4b4b9a0d27d740dd2d3236c3" } }] + +[[packages]] +name = "glirel" +version = "1.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/aa/17/366a8bcdf3631af9f11b989c3387b952cf3fd3b786df95952e826d64374a/glirel-1.2.1.tar.gz", upload-time = 2025-04-11T10:10:58Z, size = 49623, hashes = { sha256 = "96e0636810c6f020707a515d4f08aa36b7950c7d06030b5fe149b86d716e00e4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2f/62/fce91d0f41f493d1fb69db3df828aa6c2a76390a4a38db5db6a40b3b2150/glirel-1.2.1-py3-none-any.whl", upload-time = 2025-04-11T10:10:57Z, size = 54298, hashes = { sha256 = "ecbe2f955d8f2a406931022a10753e889761de7a736ec4090187830e49689aaf" } }] + +[[packages]] +name = "h11" +version = "0.16.0" +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", upload-time = 2025-04-24T03:35:25Z, size = 101250, hashes = { sha256 = "4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", upload-time = 2025-04-24T03:35:24Z, size = 37515, hashes = { sha256 = "63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86" } }] + +[[packages]] +name = "hf-xet" +version = "1.4.3" +marker = "platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" +sdist = { url = "https://files.pythonhosted.org/packages/53/92/ec9ad04d0b5728dca387a45af7bc98fbb0d73b2118759f5f6038b61a57e8/hf_xet-1.4.3.tar.gz", upload-time = 2026-03-31T22:40:07Z, size = 670477, hashes = { sha256 = "8ddedb73c8c08928c793df2f3401ec26f95be7f7e516a7bee2fbb546f6676113" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/df/9a/a24b26dc8a65f0ecc0fe5be981a19e61e7ca963b85e062c083f3a9100529/hf_xet-1.4.3-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-03-31T22:39:42Z, size = 4212320, hashes = { sha256 = "fc360b70c815bf340ed56c7b8c63aacf11762a4b099b2fe2c9bd6d6068668c08" } }] + +[[packages]] +name = "httpcore" +version = "1.0.9" +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", upload-time = 2025-04-24T22:06:22Z, size = 85484, hashes = { sha256 = "6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", upload-time = 2025-04-24T22:06:20Z, size = 78784, hashes = { sha256 = "2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55" } }] + +[[packages]] +name = "httpx" +version = "0.28.1" +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", upload-time = 2024-12-06T15:37:23Z, size = 141406, hashes = { sha256 = "75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", upload-time = 2024-12-06T15:37:21Z, size = 73517, hashes = { sha256 = "d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad" } }] + +[[packages]] +name = "huggingface-hub" +version = "0.36.2" +sdist = { url = "https://files.pythonhosted.org/packages/7c/b7/8cb61d2eece5fb05a83271da168186721c450eb74e3c31f7ef3169fa475b/huggingface_hub-0.36.2.tar.gz", upload-time = 2026-02-06T09:24:13Z, size = 649782, hashes = { sha256 = "1934304d2fb224f8afa3b87007d58501acfda9215b334eed53072dd5e815ff7a" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a8/af/48ac8483240de756d2438c380746e7130d1c6f75802ef22f3c6d49982787/huggingface_hub-0.36.2-py3-none-any.whl", upload-time = 2026-02-06T09:24:11Z, size = 566395, hashes = { sha256 = "48f0c8eac16145dfce371e9d2d7772854a4f591bcb56c9cf548accf531d54270" } }] + +[[packages]] +name = "idna" +version = "3.17" +sdist = { url = "https://files.pythonhosted.org/packages/b9/28/99c51f664567218d824af024c0251650fb27e4ca066df188dab0769c5b91/idna-3.17.tar.gz", upload-time = 2026-05-28T14:32:38Z, size = 196048, hashes = { sha256 = "5eb0cb53bc467c12eadcf6de83163ad8527cec9416f44b9b61b19caedad2b87f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/de/a7/f76514cc40ad6234098ecdebda08732d75964776c51a42845b7da10649e2/idna-3.17-py3-none-any.whl", upload-time = 2026-05-28T14:32:37Z, size = 65316, hashes = { sha256 = "466e48829084efe2548012b855df21540b96f2e20e51bd124c851536556a592c" } }] + +[[packages]] +name = "ijson" +version = "3.5.0" +sdist = { url = "https://files.pythonhosted.org/packages/f4/57/60d1a6a512f2f0508d0bc8b4f1cc5616fd3196619b66bd6a01f9155a1292/ijson-3.5.0.tar.gz", upload-time = 2026-02-24T03:58:30Z, size = 68658, hashes = { sha256 = "94688760720e3f5212731b3cb8d30267f9a045fb38fb3870254e7b9504246f31" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/6d/81/2fee58f9024a3449aee83edfa7167fb5ccd7e1af2557300e28531bb68e16/ijson-3.5.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-02-24T03:57:14Z, size = 149729, hashes = { sha256 = "7389a56b8562a19948bdf1d7bae3a2edc8c7f86fb59834dcb1c4c722818e645a" } }] + +[[packages]] +name = "inscriptis" +version = "2.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/23/f0/77b6eeaa0cde44b8ef0d5d0c2c0ee7ddeb6e6e4aebec33e15b8d0abbf3ed/inscriptis-2.6.0.tar.gz", upload-time = 2025-03-22T18:23:26Z, size = 41620, hashes = { sha256 = "6f164bf45ea6972d61fd048a8e074d5125d215eaa837f8e70c158c97c31c3181" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5e/c4/e1a68d42fa4609231da5f14e159c3d6256fb9e2951928592cebf7c899379/inscriptis-2.6.0-py3-none-any.whl", upload-time = 2025-03-22T18:23:24Z, size = 45120, hashes = { sha256 = "654dbcd0551c2f6004f8069a05cafff3eed2d327d5057adc6e657ba2610f52af" } }] + +[[packages]] +name = "ir-datasets" +version = "0.5.11" +sdist = { url = "https://files.pythonhosted.org/packages/80/c6/f02811c51fec845ee87a10bb3675516a2d71935b203e5ddb80b7eb59b1da/ir_datasets-0.5.11.tar.gz", upload-time = 2025-06-24T07:58:31Z, size = 758463, hashes = { sha256 = "06c90af634ae5063c813286b35065debca1a974d26e136403d899f3ecd7ad463" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/81/38/73fa582d6997362d9b4901b2a8ba1177b2d2896aa59ab8d069a3884e2e0d/ir_datasets-0.5.11-py3-none-any.whl", upload-time = 2025-06-24T07:58:29Z, size = 866095, hashes = { sha256 = "ae78549e5a7fa45e50462b7acb9f0765fc344fec6054108bf3dd063050555206" } }] + +[[packages]] +name = "jinja2" +version = "3.1.6" +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", upload-time = 2025-03-05T20:05:02Z, size = 245115, hashes = { sha256 = "0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", upload-time = 2025-03-05T20:05:00Z, size = 134899, hashes = { sha256 = "85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67" } }] + +[[packages]] +name = "joblib" +version = "1.5.3" +sdist = { url = "https://files.pythonhosted.org/packages/41/f2/d34e8b3a08a9cc79a50b2208a93dce981fe615b64d5a4d4abee421d898df/joblib-1.5.3.tar.gz", upload-time = 2025-12-15T08:41:46Z, size = 331603, hashes = { sha256 = "8561a3269e6801106863fd0d6d84bb737be9e7631e33aaed3fb9ce5953688da3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7b/91/984aca2ec129e2757d1e4e3c81c3fcda9d0f85b74670a094cc443d9ee949/joblib-1.5.3-py3-none-any.whl", upload-time = 2025-12-15T08:41:44Z, size = 309071, hashes = { sha256 = "5fc3c5039fc5ca8c0276333a188bbd59d6b7ab37fe6632daa76bc7f9ec18e713" } }] + +[[packages]] +name = "jsonlines" +version = "4.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/35/87/bcda8e46c88d0e34cad2f09ee2d0c7f5957bccdb9791b0b934ec84d84be4/jsonlines-4.0.0.tar.gz", upload-time = 2023-09-01T12:34:44Z, size = 11359, hashes = { sha256 = "0c6d2c09117550c089995247f605ae4cf77dd1533041d366351f6f298822ea74" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f8/62/d9ba6323b9202dd2fe166beab8a86d29465c41a0288cbe229fac60c1ab8d/jsonlines-4.0.0-py3-none-any.whl", upload-time = 2023-09-01T12:34:42Z, size = 8701, hashes = { sha256 = "185b334ff2ca5a91362993f42e83588a360cf95ce4b71a73548502bda52a7c55" } }] + +[[packages]] +name = "jsonref" +version = "1.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/aa/0d/c1f3277e90ccdb50d33ed5ba1ec5b3f0a242ed8c1b1a85d3afeb68464dca/jsonref-1.1.0.tar.gz", upload-time = 2023-01-16T16:10:04Z, size = 8814, hashes = { sha256 = "32fe8e1d85af0fdefbebce950af85590b22b60f9e95443176adbde4e1ecea552" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0c/ec/e1db9922bceb168197a558a2b8c03a7963f1afe93517ddd3cf99f202f996/jsonref-1.1.0-py3-none-any.whl", upload-time = 2023-01-16T16:10:02Z, size = 9425, hashes = { sha256 = "590dc7773df6c21cbf948b5dac07a72a251db28b0238ceecce0a2abfa8ec30a9" } }] + +[[packages]] +name = "jsonschema" +version = "4.23.0" +sdist = { url = "https://files.pythonhosted.org/packages/38/2e/03362ee4034a4c917f697890ccd4aec0800ccf9ded7f511971c75451deec/jsonschema-4.23.0.tar.gz", upload-time = 2024-07-08T18:40:05Z, size = 325778, hashes = { sha256 = "d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/69/4a/4f9dbeb84e8850557c02365a0eee0649abe5eb1d84af92a25731c6c0f922/jsonschema-4.23.0-py3-none-any.whl", upload-time = 2024-07-08T18:40:00Z, size = 88462, hashes = { sha256 = "fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566" } }] + +[[packages]] +name = "jsonschema-specifications" +version = "2025.9.1" +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", upload-time = 2025-09-08T01:34:59Z, size = 32855, hashes = { sha256 = "b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", upload-time = 2025-09-08T01:34:57Z, size = 18437, hashes = { sha256 = "98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe" } }] + +[[packages]] +name = "latex2mathml" +version = "3.81.0" +sdist = { url = "https://files.pythonhosted.org/packages/3b/62/35bb816c5c19d4d0cde5bdfb82ebb996306243d5f94e03f201658c629960/latex2mathml-3.81.0.tar.gz", upload-time = 2026-04-15T00:55:27Z, size = 77584, hashes = { sha256 = "4b959cdc3cac8686bc0e3e5aece8127dfb1b81ca1241bed8e00ef31b82bb4022" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e8/b1/c488b530994c4f68e46efa99a4d6ca6741aaf158e35779fe6c4d8a9a427d/latex2mathml-3.81.0-py3-none-any.whl", upload-time = 2026-04-15T00:55:29Z, size = 79185, hashes = { sha256 = "d317710393fe20579aea39cfe8928fa2ad9b8780896e585326c75e89c1d1d1a4" } }] + +[[packages]] +name = "loguru" +version = "0.7.3" +sdist = { url = "https://files.pythonhosted.org/packages/3a/05/a1dae3dffd1116099471c643b8924f5aa6524411dc6c63fdae648c4f1aca/loguru-0.7.3.tar.gz", upload-time = 2024-12-06T11:20:56Z, size = 63559, hashes = { sha256 = "19480589e77d47b8d85b2c827ad95d49bf31b0dcde16593892eb51dd18706eb6" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl", upload-time = 2024-12-06T11:20:54Z, size = 61595, hashes = { sha256 = "31a33c10c8e1e10422bfd431aeb5d351c7cf7fa671e3c4df004162264b28220c" } }] + +[[packages]] +name = "lxml" +version = "6.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/28/30/9abc9e34c657c33834eaf6cd02124c61bdf5944d802aa48e69be8da3585d/lxml-6.1.0.tar.gz", upload-time = 2026-04-18T04:32:51Z, size = 4197006, hashes = { sha256 = "bfd57d8008c4965709a919c3e9a98f76c2c7cb319086b3d26858250620023b13" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/7c/e08a970727d556caa040a44773c7b7e3ad0f0d73dedc863543e9a8b931f2/lxml-6.1.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-04-18T04:32:58Z, size = 5093820, hashes = { sha256 = "9147d8e386ec3b82c3b15d88927f734f565b0aaadef7def562b853adca45784a" } }, + { url = "https://files.pythonhosted.org/packages/31/ba/3c13d3fc24b7cacf675f808a3a1baabf43a30d0cd24c98f94548e9aa58eb/lxml-6.1.0-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-18T04:33:06Z, size = 5240445, hashes = { sha256 = "bc783ee3147e60a25aa0445ea82b3e8aabb83b240f2b95d32cb75587ff781814" } }, +] + +[[packages]] +name = "lz4" +version = "4.4.5" +sdist = { url = "https://files.pythonhosted.org/packages/57/51/f1b86d93029f418033dddf9b9f79c8d2641e7454080478ee2aab5123173e/lz4-4.4.5.tar.gz", upload-time = 2025-11-03T13:02:36Z, size = 172886, hashes = { sha256 = "5f0b9e53c1e82e88c10d7c180069363980136b9d7a8306c4dca4f760d60c39f0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/55/d9/e3867222474f6c1b76e89f3bd914595af69f55bf2c1866e984c548afdc15/lz4-4.4.5-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-11-03T13:01:51Z, size = 1368249, hashes = { sha256 = "24092635f47538b392c4eaeff14c7270d2c8e806bf4be2a6446a378591c5e69e" } }] + +[[packages]] +name = "mail-parser" +version = "4.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/01/6b/55b188888abccfc1dba0617a6d99da1c39dc355822900ae9d5bccf8756b2/mail_parser-4.3.0.tar.gz", upload-time = 2026-05-27T22:15:14Z, size = 2792149, hashes = { sha256 = "fb4c64ec0a74ed095b3bad274ab08f6fca024ad5fbf72ff9ccc501ba654ba3b2" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8d/4f/38717202a3be94a37c262907adca700498fbb435a8356cfaed38387469c8/mail_parser-4.3.0-py3-none-any.whl", upload-time = 2026-05-27T22:15:13Z, size = 33895, hashes = { sha256 = "e4092a15023b7075f4666f5040e2fca71fa35a7020753b7e90359c357ed3a099" } }] + +[[packages]] +name = "markdown-it-py" +version = "4.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", upload-time = 2025-08-11T12:57:52Z, size = 73070, hashes = { sha256 = "cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", upload-time = 2025-08-11T12:57:51Z, size = 87321, hashes = { sha256 = "87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147" } }] + +[[packages]] +name = "marko" +version = "2.2.2" +sdist = { url = "https://files.pythonhosted.org/packages/e3/2f/050b6d485f052ddf17d76a41f9334d6fb2a8a85df35347a12d97ed3bc5c1/marko-2.2.2.tar.gz", upload-time = 2026-01-05T11:04:41Z, size = 143641, hashes = { sha256 = "6940308e655f63733ca518c47a68ec9510279dbb916c83616e4c4b5829f052e8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/83/f8/36d79bac5701e6786f9880c61bbe57574760a13c1af84ab71e5ed21faecc/marko-2.2.2-py3-none-any.whl", upload-time = 2026-01-05T11:04:40Z, size = 42701, hashes = { sha256 = "f064ae8c10416285ad1d96048dc11e98ef04e662d3342ae416f662b70aa7959e" } }] + +[[packages]] +name = "markupsafe" +version = "3.0.3" +sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", upload-time = 2025-09-27T18:37:40Z, size = 80313, hashes = { sha256 = "722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-09-27T18:36:33Z, size = 22947, hashes = { sha256 = "d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d" } }] + +[[packages]] +name = "mdurl" +version = "0.1.2" +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", upload-time = 2022-08-14T12:40:10Z, size = 8729, hashes = { sha256 = "bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", upload-time = 2022-08-14T12:40:09Z, size = 9979, hashes = { sha256 = "84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8" } }] + +[[packages]] +name = "mpire" +version = "2.10.2" +sdist = { url = "https://files.pythonhosted.org/packages/3a/93/80ac75c20ce54c785648b4ed363c88f148bf22637e10c9863db4fbe73e74/mpire-2.10.2.tar.gz", upload-time = 2024-05-07T14:00:31Z, size = 271270, hashes = { sha256 = "f66a321e93fadff34585a4bfa05e95bd946cf714b442f51c529038eb45773d97" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/20/14/1db1729ad6db4999c3a16c47937d601fcb909aaa4224f5eca5a2f145a605/mpire-2.10.2-py3-none-any.whl", upload-time = 2024-05-07T14:00:29Z, size = 272756, hashes = { sha256 = "d627707f7a8d02aa4c7f7d59de399dec5290945ddf7fbd36cbb1d6ebb37a51fb" } }] + +[[packages]] +name = "mpmath" +version = "1.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", upload-time = 2023-03-07T16:47:11Z, size = 508106, hashes = { sha256 = "7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", upload-time = 2023-03-07T16:47:09Z, size = 536198, hashes = { sha256 = "a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c" } }] + +[[packages]] +name = "multidict" +version = "6.7.1" +sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", upload-time = 2026-01-26T02:46:45Z, size = 102010, hashes = { sha256 = "ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-01-26T02:44:03Z, size = 256322, hashes = { sha256 = "bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961" } }, + { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", upload-time = 2026-01-26T02:46:44Z, size = 12319, hashes = { sha256 = "55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56" } }, +] + +[[packages]] +name = "multiprocess" +version = "0.70.16" +sdist = { url = "https://files.pythonhosted.org/packages/b5/ae/04f39c5d0d0def03247c2893d6f2b83c136bf3320a2154d7b8858f2ba72d/multiprocess-0.70.16.tar.gz", upload-time = 2024-01-28T18:52:34Z, size = 1772603, hashes = { sha256 = "161af703d4652a0e1410be6abccecde4a7ddffd19341be0a7011b94aeb171ac1" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bc/f7/7ec7fddc92e50714ea3745631f79bd9c96424cb2702632521028e57d3a36/multiprocess-0.70.16-py310-none-any.whl", upload-time = 2024-01-28T18:52:26Z, size = 134824, hashes = { sha256 = "c4a9944c67bd49f823687463660a2d6daae94c289adff97e0f9d696ba6371d02" } }, + { url = "https://files.pythonhosted.org/packages/50/15/b56e50e8debaf439f44befec5b2af11db85f6e0f344c3113ae0be0593a91/multiprocess-0.70.16-py311-none-any.whl", upload-time = 2024-01-28T18:52:28Z, size = 143519, hashes = { sha256 = "af4cabb0dac72abfb1e794fa7855c325fd2b55a10a44628a3c1ad3311c04127a" } }, + { url = "https://files.pythonhosted.org/packages/0a/7d/a988f258104dcd2ccf1ed40fdc97e26c4ac351eeaf81d76e266c52d84e2f/multiprocess-0.70.16-py312-none-any.whl", upload-time = 2024-01-28T18:52:29Z, size = 146741, hashes = { sha256 = "fc0544c531920dde3b00c29863377f87e1632601092ea2daca74e4beb40faa2e" } }, + { url = "https://files.pythonhosted.org/packages/ea/89/38df130f2c799090c978b366cfdf5b96d08de5b29a4a293df7f7429fa50b/multiprocess-0.70.16-py38-none-any.whl", upload-time = 2024-01-28T18:52:30Z, size = 132628, hashes = { sha256 = "a71d82033454891091a226dfc319d0cfa8019a4e888ef9ca910372a446de4435" } }, + { url = "https://files.pythonhosted.org/packages/da/d9/f7f9379981e39b8c2511c9e0326d212accacb82f12fbfdc1aa2ce2a7b2b6/multiprocess-0.70.16-py39-none-any.whl", upload-time = 2024-01-28T18:52:31Z, size = 133351, hashes = { sha256 = "a0bafd3ae1b732eac64be2e72038231c1ba97724b60b09400d68f229fcc2fbf3" } }, +] + +[[packages]] +name = "networkx" +version = "3.6.1" +sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", upload-time = 2025-12-08T17:02:39Z, size = 2517025, hashes = { sha256 = "26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", upload-time = 2025-12-08T17:02:38Z, size = 2068504, hashes = { sha256 = "d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762" } }] + +[[packages]] +name = "numpy" +version = "2.4.4" +sdist = { url = "https://files.pythonhosted.org/packages/d7/9f/b8cef5bffa569759033adda9481211426f12f53299629b410340795c2514/numpy-2.4.4.tar.gz", upload-time = 2026-03-29T13:22:01Z, size = 20731587, hashes = { sha256 = "2d390634c5182175533585cc89f3608a4682ccb173cc9bb940b2881c8d6f8fa0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0a/0d/0e3ecece05b7a7e87ab9fb587855548da437a061326fff64a223b6dcb78a/numpy-2.4.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-29T13:19:03Z, size = 16645480, hashes = { sha256 = "81f4a14bee47aec54f883e0cad2d73986640c1590eb9bfaaba7ad17394481e6e" } }] + +[[packages]] +name = "nvidia-cublas-cu12" +version = "12.8.4.1" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/dc/61/e24b560ab2e2eaeb3c839129175fb330dfcfc29e5203196e5541a4c44682/nvidia_cublas_cu12-12.8.4.1-py3-none-manylinux_2_27_x86_64.whl", upload-time = 2025-03-07T01:44:31Z, size = 594346921, hashes = { sha256 = "8ac4e771d5a348c551b2a426eda6193c19aa630236b418086020df5ba9667142" } }] + +[[packages]] +name = "nvidia-cuda-cupti-cu12" +version = "12.8.90" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/f8/02/2adcaa145158bf1a8295d83591d22e4103dbfd821bcaf6f3f53151ca4ffa/nvidia_cuda_cupti_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-03-07T01:40:21Z, size = 10248621, hashes = { sha256 = "ea0cb07ebda26bb9b29ba82cda34849e73c166c18162d3913575b0c9db9a6182" } }] + +[[packages]] +name = "nvidia-cuda-nvrtc-cu12" +version = "12.8.93" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/05/6b/32f747947df2da6994e999492ab306a903659555dddc0fbdeb9d71f75e52/nvidia_cuda_nvrtc_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", upload-time = 2025-03-07T01:42:13Z, size = 88040029, hashes = { sha256 = "a7756528852ef889772a84c6cd89d41dfa74667e24cca16bb31f8f061e3e9994" } }] + +[[packages]] +name = "nvidia-cuda-runtime-cu12" +version = "12.8.90" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/0d/9b/a997b638fcd068ad6e4d53b8551a7d30fe8b404d6f1804abf1df69838932/nvidia_cuda_runtime_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-03-07T01:40:01Z, size = 954765, hashes = { sha256 = "adade8dcbd0edf427b7204d480d6066d33902cab2a4707dcfc48a2d0fd44ab90" } }] + +[[packages]] +name = "nvidia-cudnn-cu12" +version = "9.10.2.21" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/ba/51/e123d997aa098c61d029f76663dedbfb9bc8dcf8c60cbd6adbe42f76d049/nvidia_cudnn_cu12-9.10.2.21-py3-none-manylinux_2_27_x86_64.whl", upload-time = 2025-06-06T21:54:08Z, size = 706758467, hashes = { sha256 = "949452be657fa16687d0930933f032835951ef0892b37d2d53824d1a84dc97a8" } }] + +[[packages]] +name = "nvidia-cufft-cu12" +version = "11.3.3.83" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/1f/13/ee4e00f30e676b66ae65b4f08cb5bcbb8392c03f54f2d5413ea99a5d1c80/nvidia_cufft_cu12-11.3.3.83-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-03-07T01:45:27Z, size = 193118695, hashes = { sha256 = "4d2dd21ec0b88cf61b62e6b43564355e5222e4a3fb394cac0db101f2dd0d4f74" } }] + +[[packages]] +name = "nvidia-cufile-cu12" +version = "1.13.1.3" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/bb/fe/1bcba1dfbfb8d01be8d93f07bfc502c93fa23afa6fd5ab3fc7c1df71038a/nvidia_cufile_cu12-1.13.1.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-03-07T01:45:50Z, size = 1197834, hashes = { sha256 = "1d069003be650e131b21c932ec3d8969c1715379251f8d23a1860554b1cb24fc" } }] + +[[packages]] +name = "nvidia-curand-cu12" +version = "10.3.9.90" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/fb/aa/6584b56dc84ebe9cf93226a5cde4d99080c8e90ab40f0c27bda7a0f29aa1/nvidia_curand_cu12-10.3.9.90-py3-none-manylinux_2_27_x86_64.whl", upload-time = 2025-03-07T01:46:23Z, size = 63619976, hashes = { sha256 = "b32331d4f4df5d6eefa0554c565b626c7216f87a06a4f56fab27c3b68a830ec9" } }] + +[[packages]] +name = "nvidia-cusolver-cu12" +version = "11.7.3.90" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/85/48/9a13d2975803e8cf2777d5ed57b87a0b6ca2cc795f9a4f59796a910bfb80/nvidia_cusolver_cu12-11.7.3.90-py3-none-manylinux_2_27_x86_64.whl", upload-time = 2025-03-07T01:47:16Z, size = 267506905, hashes = { sha256 = "4376c11ad263152bd50ea295c05370360776f8c3427b30991df774f9fb26c450" } }] + +[[packages]] +name = "nvidia-cusparse-cu12" +version = "12.5.8.93" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/c2/f5/e1854cb2f2bcd4280c44736c93550cc300ff4b8c95ebe370d0aa7d2b473d/nvidia_cusparse_cu12-12.5.8.93-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-03-07T01:48:13Z, size = 288216466, hashes = { sha256 = "1ec05d76bbbd8b61b06a80e1eaf8cf4959c3d4ce8e711b65ebd0443bb0ebb13b" } }] + +[[packages]] +name = "nvidia-cusparselt-cu12" +version = "0.7.1" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/56/79/12978b96bd44274fe38b5dde5cfb660b1d114f70a65ef962bcbbed99b549/nvidia_cusparselt_cu12-0.7.1-py3-none-manylinux2014_x86_64.whl", upload-time = 2025-02-26T00:15:44Z, size = 287193691, hashes = { sha256 = "f1bb701d6b930d5a7cea44c19ceb973311500847f81b634d802b7b539dc55623" } }] + +[[packages]] +name = "nvidia-nccl-cu12" +version = "2.27.5" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/6e/89/f7a07dc961b60645dbbf42e80f2bc85ade7feb9a491b11a1e973aa00071f/nvidia_nccl_cu12-2.27.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-06-26T04:11:28Z, size = 322348229, hashes = { sha256 = "ad730cf15cb5d25fe849c6e6ca9eb5b76db16a80f13f425ac68d8e2e55624457" } }] + +[[packages]] +name = "nvidia-nvjitlink-cu12" +version = "12.8.93" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/f6/74/86a07f1d0f42998ca31312f998bd3b9a7eff7f52378f4f270c8679c77fb9/nvidia_nvjitlink_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", upload-time = 2025-03-07T01:49:55Z, size = 39254836, hashes = { sha256 = "81ff63371a7ebd6e6451970684f916be2eab07321b73c9d244dc2b4da7f73b88" } }] + +[[packages]] +name = "nvidia-nvshmem-cu12" +version = "3.3.20" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/3b/6c/99acb2f9eb85c29fc6f3a7ac4dccfd992e22666dd08a642b303311326a97/nvidia_nvshmem_cu12-3.3.20-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-08-04T20:25:19Z, size = 124657145, hashes = { sha256 = "d00f26d3f9b2e3c3065be895e3059d6479ea5c638a3f38c9fec49b1b9dd7c1e5" } }] + +[[packages]] +name = "nvidia-nvtx-cu12" +version = "12.8.90" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/a2/eb/86626c1bbc2edb86323022371c39aa48df6fd8b0a1647bc274577f72e90b/nvidia_nvtx_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-03-07T01:42:44Z, size = 89954, hashes = { sha256 = "5b17e2001cc0d751a5bc2c6ec6d26ad95913324a4adb86788c944f8ce9ba441f" } }] + +[[packages]] +name = "omegaconf" +version = "2.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/09/48/6388f1bb9da707110532cb70ec4d2822858ddfb44f1cdf1233c20a80ea4b/omegaconf-2.3.0.tar.gz", upload-time = 2022-12-08T20:59:22Z, size = 3298120, hashes = { sha256 = "d5d4b6d29955cc50ad50c46dc269bcd92c6e00f5f90d23ab5fee7bfca4ba4cc7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e3/94/1843518e420fa3ed6919835845df698c7e27e183cb997394e4a670973a65/omegaconf-2.3.0-py3-none-any.whl", upload-time = 2022-12-08T20:59:19Z, size = 79500, hashes = { sha256 = "7b4df175cdb08ba400f45cae3bdcae7ba8365db4d165fc65fd04b050ab63b46b" } }] + +[[packages]] +name = "onnxruntime" +version = "1.25.0" +wheels = [{ url = "https://files.pythonhosted.org/packages/a9/1b/d681878f227513917d8620e4ea504af5eb3313fc01f8aea7b19a976c65db/onnxruntime-1.25.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-22T17:19:53Z, size = 17996146, hashes = { sha256 = "be93baa694ef8e5831fcb7b542da21f502b122918b5b9612d9f02972e043ee01" } }] + +[[packages]] +name = "open-clip-torch" +version = "2.32.0" +sdist = { url = "https://files.pythonhosted.org/packages/6d/7b/fd38dfd522968135dce71d0b543c2ae776f9c8e27df6ad46b63bab09eef7/open_clip_torch-2.32.0.tar.gz", upload-time = 2025-04-05T21:55:24Z, size = 1491248, hashes = { sha256 = "0220bc111162527eb738c1fe20dbfd6ea45dfe44726b54a4de18d3945d8f2f00" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/32/f9/0458745c1d299411161ee3b6c32228a3de0be1d8497d779fd7f17a8e96aa/open_clip_torch-2.32.0-py3-none-any.whl", upload-time = 2025-04-05T21:55:22Z, size = 1528783, hashes = { sha256 = "80b35b43e37afc2b6173aa5ab0ad68744ab3a3211e624f72dfe743a162707637" } }] + +[[packages]] +name = "opencv-python" +version = "4.13.0.92" +wheels = [ + { url = "https://files.pythonhosted.org/packages/db/07/90b34a8e2cf9c50fe8ed25cac9011cde0676b4d9d9c973751ac7616223a2/opencv_python-4.13.0.92-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-02-05T06:59:19Z, size = 70460872, hashes = { sha256 = "402033cddf9d294693094de5ef532339f14ce821da3ad7df7c9f6e8316da32cf" } }, + { url = "https://files.pythonhosted.org/packages/fd/55/b3b49a1b97aabcfbbd6c7326df9cb0b6fa0c0aefa8e89d500939e04aa229/opencv_python-4.13.0.92-cp37-abi3-manylinux_2_28_x86_64.whl", upload-time = 2026-02-05T06:59:23Z, size = 72927042, hashes = { sha256 = "620d602b8f7d8b8dab5f4b99c6eb353e78d3fb8b0f53db1bd258bb1aa001c1d5" } }, +] + +[[packages]] +name = "openpyxl" +version = "3.1.5" +sdist = { url = "https://files.pythonhosted.org/packages/3d/f9/88d94a75de065ea32619465d2f77b29a0469500e99012523b91cc4141cd1/openpyxl-3.1.5.tar.gz", upload-time = 2024-06-28T14:03:44Z, size = 186464, hashes = { sha256 = "cf0e3cf56142039133628b5acffe8ef0c12bc902d2aadd3e0fe5878dc08d1050" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c0/da/977ded879c29cbd04de313843e76868e6e13408a94ed6b987245dc7c8506/openpyxl-3.1.5-py2.py3-none-any.whl", upload-time = 2024-06-28T14:03:41Z, size = 250910, hashes = { sha256 = "5282c12b107bffeef825f4617dc029afaf41d0ea60823bbb665ef3079dc79de2" } }] + +[[packages]] +name = "packaging" +version = "24.2" +sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", upload-time = 2024-11-08T09:47:47Z, size = 163950, hashes = { sha256 = "c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", upload-time = 2024-11-08T09:47:44Z, size = 65451, hashes = { sha256 = "09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759" } }] + +[[packages]] +name = "pandas" +version = "2.3.3" +sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", upload-time = 2025-09-29T23:34:51Z, size = 4495223, hashes = { sha256 = "e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e5/63/cd7d615331b328e287d8233ba9fdf191a9c2d11b6af0c7a59cfcec23de68/pandas-2.3.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-09-29T23:20:14Z, size = 12362693, hashes = { sha256 = "b3d11d2fda7eb164ef27ffc14b4fcab16a80e1ce67e9f57e19ec0afaf715ba89" } }] + +[[packages]] +name = "peft" +version = "0.19.1" +sdist = { url = "https://files.pythonhosted.org/packages/86/cf/037f1e3d5186496c05513a6754639e2dab3038a05f384284d49a9bd06a2d/peft-0.19.1.tar.gz", upload-time = 2026-04-16T15:46:45Z, size = 763738, hashes = { sha256 = "0d97542fe96dcdaa20d3b81c06f26f988618f416a73544ab23c3618ccb674a40" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e8/b6/f54d676ed93cc2dd2234c3b172ea9c8c3d7d29361e66b1b23dec57a67465/peft-0.19.1-py3-none-any.whl", upload-time = 2026-04-16T15:46:42Z, size = 680692, hashes = { sha256 = "2113f72a81621b5913ef28f9022204c742df111890c5f49d812716a4a301e356" } }] + +[[packages]] +name = "pillow" +version = "12.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/1c/3d/bb7fca845737cf9d7dbde16ed1843984665ff2e0a518f5db43e77ec540b9/pillow-12.3.0.tar.gz", upload-time = 2026-07-01T11:56:38Z, size = 47025035, hashes = { sha256 = "3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/84/21/a35af28dcc61f37ed850a2d64c65c701321dfbf25085e469d5559360cbbf/pillow-12.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-01T11:54:13Z, size = 6940830, hashes = { sha256 = "78cb2c6865a35ab8ff8b75fd122f6033b92a62c82801110e48ddd6c936a45d91" } }] + +[[packages]] +name = "pluggy" +version = "1.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", upload-time = 2025-05-15T12:30:07Z, size = 69412, hashes = { sha256 = "7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", upload-time = 2025-05-15T12:30:06Z, size = 20538, hashes = { sha256 = "e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746" } }] + +[[packages]] +name = "polyfactory" +version = "3.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/85/68/7717bd9e63ed254617a7d3dc9260904fb736d6ea203e58ffddcb186c64e4/polyfactory-3.3.0.tar.gz", upload-time = 2026-02-22T09:46:28Z, size = 348668, hashes = { sha256 = "237258b6ff43edf362ffd1f68086bb796466f786adfa002b0ac256dbf2246e9a" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/dd/34/b6f19941adcdaf415b5e8a8d577499f5b6a76b59cbae37f9b125a9ffe9f2/polyfactory-3.3.0-py3-none-any.whl", upload-time = 2026-02-22T09:46:25Z, size = 62707, hashes = { sha256 = "686abcaa761930d3df87b91e95b26b8d8cb9fdbbbe0b03d5f918acff5c72606e" } }] + +[[packages]] +name = "propcache" +version = "0.4.1" +sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", upload-time = 2025-10-08T19:49:02Z, size = 46442, hashes = { sha256 = "f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/46/4b/3aae6835b8e5f44ea6a68348ad90f78134047b503765087be2f9912140ea/propcache-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-10-08T19:46:54Z, size = 221575, hashes = { sha256 = "15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf" } }, + { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", upload-time = 2025-10-08T19:49:00Z, size = 13305, hashes = { sha256 = "af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237" } }, +] + +[[packages]] +name = "protobuf" +version = "6.33.6" +sdist = { url = "https://files.pythonhosted.org/packages/66/70/e908e9c5e52ef7c3a6c7902c9dfbb34c7e29c25d2f81ade3856445fd5c94/protobuf-6.33.6.tar.gz", upload-time = 2026-03-18T19:05:00Z, size = 444531, hashes = { sha256 = "a6768d25248312c297558af96a9f9c929e8c4cee0659cb07e780731095f38135" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/16/92/d1e32e3e0d894fe00b15ce28ad4944ab692713f2e7f0a99787405e43533a/protobuf-6.33.6-cp39-abi3-manylinux2014_x86_64.whl", upload-time = 2026-03-18T19:04:55Z, size = 323436, hashes = { sha256 = "e9db7e292e0ab79dd108d7f1a94fe31601ce1ee3f7b79e0692043423020b0593" } }, + { url = "https://files.pythonhosted.org/packages/c4/72/02445137af02769918a93807b2b7890047c32bfb9f90371cbc12688819eb/protobuf-6.33.6-py3-none-any.whl", upload-time = 2026-03-18T19:04:59Z, size = 170656, hashes = { sha256 = "77179e006c476e69bf8e8ce866640091ec42e1beb80b213c3900006ecfba6901" } }, +] + +[[packages]] +name = "psutil" +version = "7.2.2" +sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", upload-time = 2026-01-28T18:14:54Z, size = 493740, hashes = { sha256 = "0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-01-28T18:15:25Z, size = 155560, hashes = { sha256 = "076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9" } }] + +[[packages]] +name = "pyarrow" +version = "23.0.1" +sdist = { url = "https://files.pythonhosted.org/packages/88/22/134986a4cc224d593c1afde5494d18ff629393d74cc2eddb176669f234a4/pyarrow-23.0.1.tar.gz", upload-time = 2026-02-16T10:14:12Z, size = 1167336, hashes = { sha256 = "b8c5873e33440b2bc2f4a79d2b47017a89c5a24116c055625e6f2ee50523f019" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2c/a5/da83046273d990f256cb79796a190bbf7ec999269705ddc609403f8c6b06/pyarrow-23.0.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-02-16T10:10:17Z, size = 47586063, hashes = { sha256 = "813d99f31275919c383aab17f0f455a04f5a429c261cc411b1e9a8f5e4aaaa05" } }] + +[[packages]] +name = "pyclipper" +version = "1.4.0" +sdist = { url = "https://files.pythonhosted.org/packages/f6/21/3c06205bb407e1f79b73b7b4dfb3950bd9537c4f625a68ab5cc41177f5bc/pyclipper-1.4.0.tar.gz", upload-time = 2025-12-01T13:15:35Z, size = 54489, hashes = { sha256 = "9882bd889f27da78add4dd6f881d25697efc740bf840274e749988d25496c8e1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7a/06/6e3e241882bf7d6ab23d9c69ba4e85f1ec47397cbbeee948a16cf75e21ed/pyclipper-1.4.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-12-01T13:15:06Z, size = 978235, hashes = { sha256 = "d1f807e2b4760a8e5c6d6b4e8c1d71ef52b7fe1946ff088f4fa41e16a881a5ca" } }] + +[[packages]] +name = "pydantic" +version = "2.12.5" +sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", upload-time = 2025-11-26T15:11:46Z, size = 821591, hashes = { sha256 = "4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", upload-time = 2025-11-26T15:11:44Z, size = 463580, hashes = { sha256 = "e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d" } }] + +[[packages]] +name = "pydantic-core" +version = "2.41.5" +sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", upload-time = 2025-11-04T13:43:49Z, size = 460952, hashes = { sha256 = "08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-04T13:40:09Z, size = 2075366, hashes = { sha256 = "eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c" } }] + +[[packages]] +name = "pydantic-settings" +version = "2.14.2" +sdist = { url = "https://files.pythonhosted.org/packages/5c/b5/8f48e906c3e0205276e8bd8cb7512217a87b2685304d64be27cad5b3019f/pydantic_settings-2.14.2.tar.gz", upload-time = 2026-06-19T13:44:56Z, size = 237700, hashes = { sha256 = "c19dd64b19097f1de80184f0cc7b0272a13ae6e170cbf240a3e27e381ed14a5f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/77/c1/6e422f34e569cf8e18df68d1939c81c099d2b61e4f7d9621c8a77560799c/pydantic_settings-2.14.2-py3-none-any.whl", upload-time = 2026-06-19T13:44:55Z, size = 61715, hashes = { sha256 = "a20c97b37910b6550d5ea50fbcc2d4187defe58cd57070b73863d069419c9440" } }] + +[[packages]] +name = "pygments" +version = "2.20.0" +sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", upload-time = 2026-03-29T13:29:33Z, size = 4955991, hashes = { sha256 = "6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", upload-time = 2026-03-29T13:29:30Z, size = 1231151, hashes = { sha256 = "81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176" } }] + +[[packages]] +name = "pylatexenc" +version = "2.10" +sdist = { url = "https://files.pythonhosted.org/packages/5d/ab/34ec41718af73c00119d0351b7a2531d2ebddb51833a36448fc7b862be60/pylatexenc-2.10.tar.gz", upload-time = 2021-04-06T07:56:07Z, size = 162597, hashes = { sha256 = "3dd8fd84eb46dc30bee1e23eaab8d8fb5a7f507347b23e5f38ad9675c84f40d3" } } + +[[packages]] +name = "pypdfium2" +version = "5.7.1" +sdist = { url = "https://files.pythonhosted.org/packages/bc/13/ee794b8a810b7226426c8b50d6c28637c059e7da0caf9936164f352ef858/pypdfium2-5.7.1.tar.gz", upload-time = 2026-04-20T15:01:02Z, size = 266791, hashes = { sha256 = "3b3b20a56048dbe3fd4bf397f9bec854c834668bc47ef6a7d9041b23bb04317b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/03/4b/fff16a831a6f07aad02da0d02b620c455310b8bf4e2642909175dcb7ccae/pypdfium2-5.7.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-04-20T15:00:38Z, size = 3657630, hashes = { sha256 = "fc2cdf603ac766b91b7c1b455197ec1c3471089d75f999b046edb65ed6cedd80" } }] + +[[packages]] +name = "python-dateutil" +version = "2.9.0.post0" +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", upload-time = 2024-03-01T18:36:20Z, size = 342432, hashes = { sha256 = "37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", upload-time = 2024-03-01T18:36:18Z, size = 229892, hashes = { sha256 = "a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427" } }] + +[[packages]] +name = "python-docx" +version = "1.2.0" +sdist = { url = "https://files.pythonhosted.org/packages/a9/f7/eddfe33871520adab45aaa1a71f0402a2252050c14c7e3009446c8f4701c/python_docx-1.2.0.tar.gz", upload-time = 2025-06-16T20:46:27Z, size = 5723256, hashes = { sha256 = "7bc9d7b7d8a69c9c02ca09216118c86552704edc23bac179283f2e38f86220ce" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d0/00/1e03a4989fa5795da308cd774f05b704ace555a70f9bf9d3be057b680bcf/python_docx-1.2.0-py3-none-any.whl", upload-time = 2025-06-16T20:46:22Z, size = 252987, hashes = { sha256 = "3fd478f3250fbbbfd3b94fe1e985955737c145627498896a8a6bf81f4baf66c7" } }] + +[[packages]] +name = "python-dotenv" +version = "1.2.2" +sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", upload-time = 2026-03-01T16:00:26Z, size = 50135, hashes = { sha256 = "2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", upload-time = 2026-03-01T16:00:25Z, size = 22101, hashes = { sha256 = "1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a" } }] + +[[packages]] +name = "python-pptx" +version = "1.0.2" +sdist = { url = "https://files.pythonhosted.org/packages/52/a9/0c0db8d37b2b8a645666f7fd8accea4c6224e013c42b1d5c17c93590cd06/python_pptx-1.0.2.tar.gz", upload-time = 2024-08-07T17:33:37Z, size = 10109297, hashes = { sha256 = "479a8af0eaf0f0d76b6f00b0887732874ad2e3188230315290cd1f9dd9cc7095" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d9/4f/00be2196329ebbff56ce564aa94efb0fbc828d00de250b1980de1a34ab49/python_pptx-1.0.2-py3-none-any.whl", upload-time = 2024-08-07T17:33:28Z, size = 472788, hashes = { sha256 = "160838e0b8565a8b1f67947675886e9fea18aa5e795db7ae531606d68e785cba" } }] + +[[packages]] +name = "pytz" +version = "2026.1.post1" +sdist = { url = "https://files.pythonhosted.org/packages/56/db/b8721d71d945e6a8ac63c0fc900b2067181dbb50805958d4d4661cf7d277/pytz-2026.1.post1.tar.gz", upload-time = 2026-03-03T07:47:50Z, size = 321088, hashes = { sha256 = "3378dde6a0c3d26719182142c56e60c7f9af7e968076f31aae569d72a0358ee1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/10/99/781fe0c827be2742bcc775efefccb3b048a3a9c6ce9aec0cbf4a101677e5/pytz-2026.1.post1-py2.py3-none-any.whl", upload-time = 2026-03-03T07:47:49Z, size = 510489, hashes = { sha256 = "f2fd16142fda348286a75e1a524be810bb05d444e5a081f37f7affc635035f7a" } }] + +[[packages]] +name = "pyyaml" +version = "6.0.3" +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", upload-time = 2025-09-25T21:33:16Z, size = 130960, hashes = { sha256 = "d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-09-25T21:32:16Z, size = 807870, hashes = { sha256 = "ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc" } }] + +[[packages]] +name = "rapidocr" +version = "3.8.1" +wheels = [{ url = "https://files.pythonhosted.org/packages/ea/4a/fa521d947f0fc7bb304bf11bec4cb66266bd81494588b4cb48dc01001719/rapidocr-3.8.1-py3-none-any.whl", upload-time = 2026-04-11T07:13:22Z, size = 15080319, hashes = { sha256 = "650044b1fbce9e6bae5cae462dcf8be754cde11e2f23fc51f65dcc08deae2c46" } }] + +[[packages]] +name = "referencing" +version = "0.37.0" +sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", upload-time = 2025-10-13T15:30:48Z, size = 78036, hashes = { sha256 = "44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", upload-time = 2025-10-13T15:30:47Z, size = 26766, hashes = { sha256 = "381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231" } }] + +[[packages]] +name = "regex" +version = "2026.4.4" +sdist = { url = "https://files.pythonhosted.org/packages/cb/0e/3a246dbf05666918bd3664d9d787f84a9108f6f43cc953a077e4a7dfdb7e/regex-2026.4.4.tar.gz", upload-time = 2026-04-03T20:56:28Z, size = 416000, hashes = { sha256 = "e08270659717f6973523ce3afbafa53515c4dc5dcad637dc215b6fd50f689423" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/11/0e/a9f6f81013e0deaf559b25711623864970fe6a098314e374ccb1540a4152/regex-2026.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-03T20:53:51Z, size = 801126, hashes = { sha256 = "993f657a7c1c6ec51b5e0ba97c9817d06b84ea5fa8d82e43b9405de0defdc2b9" } }] + +[[packages]] +name = "requests" +version = "2.33.1" +sdist = { url = "https://files.pythonhosted.org/packages/5f/a4/98b9c7c6428a668bf7e42ebb7c79d576a1c3c1e3ae2d47e674b468388871/requests-2.33.1.tar.gz", upload-time = 2026-03-30T16:09:15Z, size = 134120, hashes = { sha256 = "18817f8c57c6263968bc123d237e3b8b08ac046f5456bd1e307ee8f4250d3517" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", upload-time = 2026-03-30T16:09:13Z, size = 64947, hashes = { sha256 = "4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a" } }] + +[[packages]] +name = "rich" +version = "13.9.4" +sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", upload-time = 2024-11-01T16:43:57Z, size = 223149, hashes = { sha256 = "439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", upload-time = 2024-11-01T16:43:55Z, size = 242424, hashes = { sha256 = "6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90" } }] + +[[packages]] +name = "rpds-py" +version = "0.30.0" +sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", upload-time = 2025-11-30T20:24:38Z, size = 69469, hashes = { sha256 = "dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/60/1b/6f8f29f3f995c7ffdde46a626ddccd7c63aefc0efae881dc13b6e5d5bb16/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-30T20:22:27Z, size = 394080, hashes = { sha256 = "47f236970bccb2233267d89173d3ad2703cd36a0e2a6e92d0560d333871a3d23" } }] + +[[packages]] +name = "rtree" +version = "1.4.1" +sdist = { url = "https://files.pythonhosted.org/packages/95/09/7302695875a019514de9a5dd17b8320e7a19d6e7bc8f85dcfb79a4ce2da3/rtree-1.4.1.tar.gz", upload-time = 2025-08-13T19:32:01Z, size = 52425, hashes = { sha256 = "c6b1b3550881e57ebe530cc6cffefc87cd9bf49c30b37b894065a9f810875e46" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d1/75/e5d44be90525cd28503e7f836d077ae6663ec0687a13ba7810b4114b3668/rtree-1.4.1-py3-none-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-08-13T19:31:55Z, size = 507644, hashes = { sha256 = "12de4578f1b3381a93a655846900be4e3d5f4cd5e306b8b00aa77c1121dc7e8c" } }] + +[[packages]] +name = "safetensors" +version = "0.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/29/9c/6e74567782559a63bd040a236edca26fd71bc7ba88de2ef35d75df3bca5e/safetensors-0.7.0.tar.gz", upload-time = 2025-11-19T15:18:43Z, size = 200878, hashes = { sha256 = "07663963b67e8bd9f0b8ad15bb9163606cd27cc5a1b96235a50d8369803b96b0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a0/60/429e9b1cb3fc651937727befe258ea24122d9663e4d5709a48c9cbfceecb/safetensors-0.7.0-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-19T15:18:33Z, size = 507152, hashes = { sha256 = "dac7252938f0696ddea46f5e855dd3138444e82236e3be475f54929f0c510d48" } }] + +[[packages]] +name = "scikit-learn" +version = "1.8.0" +sdist = { url = "https://files.pythonhosted.org/packages/0e/d4/40988bf3b8e34feec1d0e6a051446b1f66225f8529b9309becaeef62b6c4/scikit_learn-1.8.0.tar.gz", upload-time = 2025-12-10T07:08:53Z, size = 7335585, hashes = { sha256 = "9bccbb3b40e3de10351f8f5068e105d0f4083b1a65fa07b6634fbc401a6287fd" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/97/74/b7a304feb2b49df9fafa9382d4d09061a96ee9a9449a7cbea7988dda0828/scikit_learn-1.8.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-12-10T07:07:57Z, size = 8931904, hashes = { sha256 = "a0bcfe4d0d14aec44921545fd2af2338c7471de9cb701f1da4c9d85906ab847a" } }] + +[[packages]] +name = "scipy" +version = "1.17.1" +sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", upload-time = 2026-02-23T00:26:24Z, size = 30573822, hashes = { sha256 = "95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/01/8e/1e35281b8ab6d5d72ebe9911edcdffa3f36b04ed9d51dec6dd140396e220/scipy-1.17.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-02-23T00:18:49Z, size = 35235890, hashes = { sha256 = "02ae3b274fde71c5e92ac4d54bc06c42d80e399fec704383dcd99b301df37458" } }] + +[[packages]] +name = "semchunk" +version = "3.2.5" +sdist = { url = "https://files.pythonhosted.org/packages/a9/a0/ce7e3d6cc76498fd594e667d10a03f17d7cced129e46869daec23523bf5a/semchunk-3.2.5.tar.gz", upload-time = 2025-10-28T02:12:38Z, size = 17667, hashes = { sha256 = "ee15e9a06a69a411937dd8fcf0a25d7ef389c5195863140436872a02c95b0218" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f8/95/12d226ee4d207cb1f77a216baa7e1a8bae2639733c140abe8d0316d23a18/semchunk-3.2.5-py3-none-any.whl", upload-time = 2025-10-28T02:12:36Z, size = 13048, hashes = { sha256 = "fd09cc5f380bd010b8ca773bd81893f7eaf11d37dd8362a83d46cedaf5dae076" } }] + +[[packages]] +name = "sentence-transformers" +version = "5.4.1" +sdist = { url = "https://files.pythonhosted.org/packages/4d/68/7f98c221940ce783b492ad6140384daf2e2918cd7175009d6a362c22b9ee/sentence_transformers-5.4.1.tar.gz", upload-time = 2026-04-14T13:34:59Z, size = 428910, hashes = { sha256 = "436bcb1182a0ff42a8fb2b1c43498a70d0a75b688d182f2cd0d1dd115af61ddc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c5/d9/3a9b6f2ccdedc9dc00fe37b2fc58f58f8efbff44565cf4bf39d8568bb13a/sentence_transformers-5.4.1-py3-none-any.whl", upload-time = 2026-04-14T13:34:57Z, size = 571311, hashes = { sha256 = "a6d640fc363849b63affb8e140e9d328feabab86f83d58ac3e16b1c28140b790" } }] + +[[packages]] +name = "sentencepiece" +version = "0.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/15/15/2e7a025fc62d764b151ae6d0f2a92f8081755ebe8d4a64099accc6f77ba6/sentencepiece-0.2.1.tar.gz", upload-time = 2025-08-12T07:00:51Z, size = 3228515, hashes = { sha256 = "8138cec27c2f2282f4a34d9a016e3374cd40e5c6e9cb335063db66a0a3b71fad" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/04/88/14f2f4a2b922d8b39be45bf63d79e6cd3a9b2f248b2fcb98a69b12af12f5/sentencepiece-0.2.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-08-12T06:59:46Z, size = 1387881, hashes = { sha256 = "0cdfecef430d985f1c2bcbfff3defd1d95dae876fbd0173376012d2d7d24044b" } }] + +[[packages]] +name = "seqeval" +version = "1.2.2" +sdist = { url = "https://files.pythonhosted.org/packages/9d/2d/233c79d5b4e5ab1dbf111242299153f3caddddbb691219f363ad55ce783d/seqeval-1.2.2.tar.gz", upload-time = 2020-10-24T00:24:54Z, size = 43605, hashes = { sha256 = "f28e97c3ab96d6fcd32b648f6438ff2e09cfba87f05939da9b3970713ec56e6f" } } + +[[packages]] +name = "setuptools" +version = "83.0.0" +marker = "python_full_version >= '3.12'" +sdist = { url = "https://files.pythonhosted.org/packages/34/26/f5d29e25ffdb535afef2d35cdb55b325298f96debd670da4c325e08d70f4/setuptools-83.0.0.tar.gz", upload-time = 2026-07-04T15:31:22Z, size = 1154254, hashes = { sha256 = "025bccbbf0fa05b6192bc64ae1e7b16e001fd6d6d4d5de03c97b1c1ade523bef" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5d/40/e1e72872c6354b306daef1703549e8e83b4d43cfea356311bf722a043752/setuptools-83.0.0-py3-none-any.whl", upload-time = 2026-07-04T15:31:20Z, size = 1008090, hashes = { sha256 = "29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3" } }] + +[[packages]] +name = "shapely" +version = "2.1.2" +sdist = { url = "https://files.pythonhosted.org/packages/4d/bc/0989043118a27cccb4e906a46b7565ce36ca7b57f5a18b78f4f1b0f72d9d/shapely-2.1.2.tar.gz", upload-time = 2025-09-24T13:51:41Z, size = 315489, hashes = { sha256 = "2ed4ecb28320a433db18a5bf029986aa8afcfd740745e78847e330d5d94922a9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b9/37/e781683abac55dde9771e086b790e554811a71ed0b2b8a1e789b7430dd44/shapely-2.1.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-09-24T13:50:35Z, size = 3099844, hashes = { sha256 = "1e7d4d7ad262a48bb44277ca12c7c78cb1b0f56b32c10734ec9a1d30c0b0c54b" } }] + +[[packages]] +name = "shellingham" +version = "1.5.4" +sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", upload-time = 2023-10-24T04:13:40Z, size = 10310, hashes = { sha256 = "8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", upload-time = 2023-10-24T04:13:38Z, size = 9755, hashes = { sha256 = "7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686" } }] + +[[packages]] +name = "six" +version = "1.17.0" +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", upload-time = 2024-12-04T17:35:28Z, size = 34031, hashes = { sha256 = "ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", upload-time = 2024-12-04T17:35:26Z, size = 11050, hashes = { sha256 = "4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274" } }] + +[[packages]] +name = "soupsieve" +version = "2.9" +sdist = { url = "https://files.pythonhosted.org/packages/80/f1/93422647dd7e461f23d254e6b2bfa687a85b53aeb4903fcdbb74474d4584/soupsieve-2.9.tar.gz", upload-time = 2026-07-19T01:35:18Z, size = 122122, hashes = { sha256 = "acee8417325c5653e1377dc31eccad59eb82cbc65942afe6174c53b3aaad63fc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7b/d6/3185ab5ad1280319b31986898f3206dd7227cd75e293d4dba2a5e6bf27a0/soupsieve-2.9-py3-none-any.whl", upload-time = 2026-07-19T01:35:17Z, size = 37387, hashes = { sha256 = "a2b2c76d67df2382d245409fd71e321a571717e58463efa32ace87dcadac2c12" } }] + +[[packages]] +name = "sympy" +version = "1.14.0" +sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", upload-time = 2025-04-27T18:05:01Z, size = 7793921, hashes = { sha256 = "d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", upload-time = 2025-04-27T18:04:59Z, size = 6299353, hashes = { sha256 = "e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5" } }] + +[[packages]] +name = "tabulate" +version = "0.10.0" +sdist = { url = "https://files.pythonhosted.org/packages/46/58/8c37dea7bbf769b20d58e7ace7e5edfe65b849442b00ffcdd56be88697c6/tabulate-0.10.0.tar.gz", upload-time = 2026-03-04T18:55:34Z, size = 91754, hashes = { sha256 = "e2cfde8f79420f6deeffdeda9aaec3b6bc5abce947655d17ac662b126e48a60d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/99/55/db07de81b5c630da5cbf5c7df646580ca26dfaefa593667fc6f2fe016d2e/tabulate-0.10.0-py3-none-any.whl", upload-time = 2026-03-04T18:55:31Z, size = 39814, hashes = { sha256 = "f0b0622e567335c8fabaaa659f1b33bcb6ddfe2e496071b743aa113f8774f2d3" } }] + +[[packages]] +name = "threadpoolctl" +version = "3.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/b7/4d/08c89e34946fce2aec4fbb45c9016efd5f4d7f24af8e5d93296e935631d8/threadpoolctl-3.6.0.tar.gz", upload-time = 2025-03-13T13:49:23Z, size = 21274, hashes = { sha256 = "8ab8b4aa3491d812b623328249fab5302a68d2d71745c8a4c719a2fcaba9f44e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", upload-time = 2025-03-13T13:49:21Z, size = 18638, hashes = { sha256 = "43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb" } }] + +[[packages]] +name = "timm" +version = "0.9.16" +sdist = { url = "https://files.pythonhosted.org/packages/c5/ba/3d5f3381dc291d21114e707b39791f483431361f61402483d9839b61350d/timm-0.9.16.tar.gz", upload-time = 2024-02-19T19:33:45Z, size = 2121824, hashes = { sha256 = "891e54f375d55adf31a71ab0c117761f0e472f9f3971858ecdd1e7376b7071e6" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/68/99/2018622d268f6017ddfa5ee71f070bad5d07590374793166baa102849d17/timm-0.9.16-py3-none-any.whl", upload-time = 2024-02-19T19:33:42Z, size = 2249737, hashes = { sha256 = "bf5704014476ab011589d3c14172ee4c901fd18f9110a928019cac5be2945914" } }] + +[[packages]] +name = "tokenizers" +version = "0.22.2" +sdist = { url = "https://files.pythonhosted.org/packages/73/6f/f80cfef4a312e1fb34baf7d85c72d4411afde10978d4657f8cdd811d3ccc/tokenizers-0.22.2.tar.gz", upload-time = 2026-01-05T10:45:15Z, size = 372115, hashes = { sha256 = "473b83b915e547aa366d1eee11806deaf419e17be16310ac0a14077f1e28f917" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2e/76/932be4b50ef6ccedf9d3c6639b056a967a86258c6d9200643f01269211ca/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-01-05T10:40:58Z, size = 3274982, hashes = { sha256 = "369cc9fc8cc10cb24143873a0d95438bb8ee257bb80c71989e3ee290e8d72c67" } }] + +[[packages]] +name = "torch" +version = "2.9.1" +wheels = [{ url = "https://files.pythonhosted.org/packages/19/17/e377a460603132b00760511299fceba4102bd95db1a0ee788da21298ccff/torch-2.9.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2025-11-12T15:22:17Z, size = 899742281, hashes = { sha256 = "27331cd902fb4322252657f3902adf1c4f6acad9dcad81d8df3ae14c7c4f07c4" } }] + +[[packages]] +name = "torchvision" +version = "0.24.1" +wheels = [{ url = "https://files.pythonhosted.org/packages/93/b1/db2941526ecddd84884132e2742a55c9311296a6a38627f9e2627f5ac889/torchvision-0.24.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2025-11-12T15:25:13Z, size = 8049868, hashes = { sha256 = "66a98471fc18cad9064123106d810a75f57f0838eee20edc56233fd8484b0cc7" } }] + +[[packages]] +name = "tqdm" +version = "4.67.3" +sdist = { url = "https://files.pythonhosted.org/packages/09/a9/6ba95a270c6f1fbcd8dac228323f2777d886cb206987444e4bce66338dd4/tqdm-4.67.3.tar.gz", upload-time = 2026-02-03T17:35:53Z, size = 169598, hashes = { sha256 = "7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", upload-time = 2026-02-03T17:35:50Z, size = 78374, hashes = { sha256 = "ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf" } }] + +[[packages]] +name = "transformers" +version = "4.57.6" +sdist = { url = "https://files.pythonhosted.org/packages/c4/35/67252acc1b929dc88b6602e8c4a982e64f31e733b804c14bc24b47da35e6/transformers-4.57.6.tar.gz", upload-time = 2026-01-16T10:38:39Z, size = 10134912, hashes = { sha256 = "55e44126ece9dc0a291521b7e5492b572e6ef2766338a610b9ab5afbb70689d3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/03/b8/e484ef633af3887baeeb4b6ad12743363af7cce68ae51e938e00aaa0529d/transformers-4.57.6-py3-none-any.whl", upload-time = 2026-01-16T10:38:31Z, size = 11993498, hashes = { sha256 = "4c9e9de11333ddfe5114bc872c9f370509198acf0b87a832a0ab9458e2bd0550" } }] + +[[packages]] +name = "trec-car-tools" +version = "2.6" +sdist = { url = "https://files.pythonhosted.org/packages/d4/71/7b62e2e56de6cdf0c648f0033a9faa41b8f712bacd71968af96277185400/trec-car-tools-2.6.tar.gz", upload-time = 2022-02-01T16:37:20Z, size = 7513, hashes = { sha256 = "2fce2de120224fd569b151d5bed358a4ed334e643889b9e3dfe3e5a3d15d21c8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/36/75/661b406371f96622975eb25f9e70945d97fbe6b8e5af40342c59191962a3/trec_car_tools-2.6-py3-none-any.whl", upload-time = 2022-02-01T16:37:22Z, size = 8414, hashes = { sha256 = "e6f0373259e1c234222da7270ab54ca7af7a6f8d0dd32b13e158c1659d3991cf" } }] + +[[packages]] +name = "tree-sitter" +version = "0.25.2" +sdist = { url = "https://files.pythonhosted.org/packages/66/7c/0350cfc47faadc0d3cf7d8237a4e34032b3014ddf4a12ded9933e1648b55/tree-sitter-0.25.2.tar.gz", upload-time = 2025-09-25T17:37:59Z, size = 177961, hashes = { sha256 = "fe43c158555da46723b28b52e058ad444195afd1db3ca7720c59a254544e9c20" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/39/d1/b95f545e9fc5001b8a78636ef942a4e4e536580caa6a99e73dd0a02e87aa/tree_sitter-0.25.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-09-25T17:37:38Z, size = 635418, hashes = { sha256 = "b43a9e4c89d4d0839de27cd4d6902d33396de700e9ff4c5ab7631f277a85ead9" } }] + +[[packages]] +name = "tree-sitter-c" +version = "0.24.2" +sdist = { url = "https://files.pythonhosted.org/packages/a6/c9/3834f3d9278251aea7312274971bc4c45b17aec2490fd4b884d93bd7019a/tree_sitter_c-0.24.2.tar.gz", upload-time = 2026-04-22T08:06:14Z, size = 228397, hashes = { sha256 = "1628584df0299b5a340aa63f8e67b6c97c91517f52fa7e7a4c557e40adb330a9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e9/8c/0dfb88d726f8821d1c4c36042f092be974a800afd734307a595b8604190c/tree_sitter_c-0.24.2-cp310-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2026-04-22T08:06:08Z, size = 94264, hashes = { sha256 = "5041ef67eb68ce6bc8bb0b1f8ef3a5585ce523dae0c7eec109ab0627dd75aede" } }] + +[[packages]] +name = "tree-sitter-javascript" +version = "0.25.0" +sdist = { url = "https://files.pythonhosted.org/packages/59/e0/e63103c72a9d3dfd89a31e02e660263ad84b7438e5f44ee82e443e65bbde/tree_sitter_javascript-0.25.0.tar.gz", upload-time = 2025-09-01T07:13:44Z, size = 132338, hashes = { sha256 = "329b5414874f0588a98f1c291f1b28138286617aa907746ffe55adfdcf963f38" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5f/c4/7da74ecdcd8a398f88bd003a87c65403b5fe0e958cdd43fbd5fd4a398fcf/tree_sitter_javascript-0.25.0-cp310-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2025-09-01T07:13:38Z, size = 99728, hashes = { sha256 = "9dc04ba91fc8583344e57c1f1ed5b2c97ecaaf47480011b92fbeab8dda96db75" } }] + +[[packages]] +name = "tree-sitter-python" +version = "0.25.0" +sdist = { url = "https://files.pythonhosted.org/packages/b8/8b/c992ff0e768cb6768d5c96234579bf8842b3a633db641455d86dd30d5dac/tree_sitter_python-0.25.0.tar.gz", upload-time = 2025-09-11T06:47:58Z, size = 159845, hashes = { sha256 = "b13e090f725f5b9c86aa455a268553c65cadf325471ad5b65cd29cac8a1a68ac" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/aa/cb/d9b0b67d037922d60cbe0359e0c86457c2da721bc714381a63e2c8e35eba/tree_sitter_python-0.25.0-cp310-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2025-09-11T06:47:50Z, size = 108133, hashes = { sha256 = "86f118e5eecad616ecdb81d171a36dde9bef5a0b21ed71ea9c3e390813c3baf5" } }] + +[[packages]] +name = "tree-sitter-typescript" +version = "0.23.2" +sdist = { url = "https://files.pythonhosted.org/packages/1e/fc/bb52958f7e399250aee093751e9373a6311cadbe76b6e0d109b853757f35/tree_sitter_typescript-0.23.2.tar.gz", upload-time = 2024-11-11T02:36:11Z, size = 773053, hashes = { sha256 = "7b167b5827c882261cb7a50dfa0fb567975f9b315e87ed87ad0a0a3aedb3834d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/49/d1/a71c36da6e2b8a4ed5e2970819b86ef13ba77ac40d9e333cb17df6a2c5db/tree_sitter_typescript-0.23.2-cp39-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2024-11-11T02:36:04Z, size = 344960, hashes = { sha256 = "e96d36b85bcacdeb8ff5c2618d75593ef12ebaf1b4eace3477e2bdb2abb1752c" } }] + +[[packages]] +name = "triton" +version = "3.5.1" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/f2/50/9a8358d3ef58162c0a415d173cfb45b67de60176e1024f71fbc4d24c0b6d/triton-3.5.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-11-11T17:41:00Z, size = 170470207, hashes = { sha256 = "d2c6b915a03888ab931a9fd3e55ba36785e1fe70cbea0b40c6ef93b20fc85232" } }] + +[[packages]] +name = "typer" +version = "0.21.2" +sdist = { url = "https://files.pythonhosted.org/packages/f2/1e/a27cc02a0cd715118c71fa2aef2c687fdefc3c28d90fd0dd789c5118154c/typer-0.21.2.tar.gz", upload-time = 2026-02-10T19:33:46Z, size = 120426, hashes = { sha256 = "1abd95a3b675e17ff61b0838ac637fe9478d446d62ad17fa4bb81ea57cc54028" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b8/cc/d59f893fbdfb5f58770c05febfc4086a46875f1084453621c35605cec946/typer-0.21.2-py3-none-any.whl", upload-time = 2026-02-10T19:33:48Z, size = 56728, hashes = { sha256 = "c3d8de54d00347ef90b82131ca946274f017cffb46683ae3883c360fa958f55c" } }] + +[[packages]] +name = "typing-extensions" +version = "4.15.0" +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", upload-time = 2025-08-25T13:49:26Z, size = 109391, hashes = { sha256 = "0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", upload-time = 2025-08-25T13:49:24Z, size = 44614, hashes = { sha256 = "f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548" } }] + +[[packages]] +name = "typing-inspection" +version = "0.4.2" +sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", upload-time = 2025-10-01T02:14:41Z, size = 75949, hashes = { sha256 = "ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", upload-time = 2025-10-01T02:14:40Z, size = 14611, hashes = { sha256 = "4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7" } }] + +[[packages]] +name = "tzdata" +version = "2026.2" +sdist = { url = "https://files.pythonhosted.org/packages/ba/19/1b9b0e29f30c6d35cb345486df41110984ea67ae69dddbc0e8a100999493/tzdata-2026.2.tar.gz", upload-time = 2026-04-24T15:22:08Z, size = 198254, hashes = { sha256 = "9173fde7d80d9018e02a662e168e5a2d04f87c41ea174b139fbef642eda62d10" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ce/e4/dccd7f47c4b64213ac01ef921a1337ee6e30e8c6466046018326977efd95/tzdata-2026.2-py2.py3-none-any.whl", upload-time = 2026-04-24T15:22:05Z, size = 349321, hashes = { sha256 = "bbe9af844f658da81a5f95019480da3a89415801f6cc966806612cc7169bffe7" } }] + +[[packages]] +name = "unlzw3" +version = "0.2.3" +sdist = { url = "https://files.pythonhosted.org/packages/08/f1/72b313366285263aaba21a17714fbef597d7662a8737a928b2b4784eb46e/unlzw3-0.2.3.tar.gz", upload-time = 2024-12-20T16:05:55Z, size = 5426, hashes = { sha256 = "ede5d928c792fff9da406f20334f9739693327f448f383ae1df1774627197bbb" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/4d/fb/617af9b317ac75f5663285d3a3cc38903a76d63c6e7397768307545f4ff4/unlzw3-0.2.3-py3-none-any.whl", upload-time = 2024-12-20T16:05:53Z, size = 6729, hashes = { sha256 = "7760fb4f3afa1225623944c061991d89a061f7fb78665dbc4cddfdb562bb4a8b" } }] + +[[packages]] +name = "urllib3" +version = "2.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", upload-time = 2026-05-07T16:13:18Z, size = 433602, hashes = { sha256 = "231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", upload-time = 2026-05-07T16:13:17Z, size = 131087, hashes = { sha256 = "9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897" } }] + +[[packages]] +name = "warc3-wet" +version = "0.2.5" +sdist = { url = "https://files.pythonhosted.org/packages/21/c6/24c9b4a2b2b1741b57d7f44ff9790eb4ef28de898c17c2b1ca1efabf8c96/warc3_wet-0.2.5.tar.gz", upload-time = 2024-07-17T08:33:51Z, size = 17937, hashes = { sha256 = "15e50402dabaa1e95307f1e2a6169cfd5f137b70761d9f0b16a10aa6de227970" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f4/99/0a5582a106679fd9439af51631b6c6cb627fd96cbc85a02927e6812605b8/warc3_wet-0.2.5-py3-none-any.whl", upload-time = 2024-07-17T08:33:50Z, size = 18657, hashes = { sha256 = "5a9a525383fb1af159734baa75f349a7c4ec7bccd1b938681b5748515d2bf624" } }] + +[[packages]] +name = "warc3-wet-clueweb09" +version = "0.2.5" +sdist = { url = "https://files.pythonhosted.org/packages/9f/c1/dd817bf57e0274dacb10e0ac868cb6cd70876950cf361c41879c030a2b8b/warc3-wet-clueweb09-0.2.5.tar.gz", upload-time = 2020-12-07T23:59:04Z, size = 17853, hashes = { sha256 = "3054bfc07da525d5967df8ca3175f78fa3f78514c82643f8c81fbca96300b836" } } + +[[packages]] +name = "wcwidth" +version = "0.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/35/a2/8e3becb46433538a38726c948d3399905a4c7cabd0df578ede5dc51f0ec2/wcwidth-0.6.0.tar.gz", upload-time = 2026-02-06T19:19:40Z, size = 159684, hashes = { sha256 = "cdc4e4262d6ef9a1a57e018384cbeb1208d8abbc64176027e2c2455c81313159" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/68/5a/199c59e0a824a3db2b89c5d2dade7ab5f9624dbf6448dc291b46d5ec94d3/wcwidth-0.6.0-py3-none-any.whl", upload-time = 2026-02-06T19:19:39Z, size = 94189, hashes = { sha256 = "1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad" } }] + +[[packages]] +name = "websockets" +version = "14.2" +sdist = { url = "https://files.pythonhosted.org/packages/94/54/8359678c726243d19fae38ca14a334e740782336c9f19700858c4eb64a1e/websockets-14.2.tar.gz", upload-time = 2025-01-19T21:00:56Z, size = 164394, hashes = { sha256 = "5059ed9c54945efb321f097084b4c7e52c246f2c869815876a69d1efc4ad6eb5" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/da/72f7caabd94652e6eb7e92ed2d3da818626e70b4f2b15a854ef60bf501ec/websockets-14.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-01-19T20:59:40Z, size = 170178, hashes = { sha256 = "a39d7eceeea35db85b85e1169011bb4321c32e673920ae9c1b6e0978590012a3" } }, + { url = "https://files.pythonhosted.org/packages/7b/c8/d529f8a32ce40d98309f4470780631e971a5a842b60aec864833b3615786/websockets-14.2-py3-none-any.whl", upload-time = 2025-01-19T21:00:54Z, size = 157416, hashes = { sha256 = "7a6ceec4ea84469f15cf15807a747e9efe57e369c384fa86e022b3bea679b79b" } }, +] + +[[packages]] +name = "xlsxwriter" +version = "3.2.9" +sdist = { url = "https://files.pythonhosted.org/packages/46/2c/c06ef49dc36e7954e55b802a8b231770d286a9758b3d936bd1e04ce5ba88/xlsxwriter-3.2.9.tar.gz", upload-time = 2025-09-16T00:16:21Z, size = 215940, hashes = { sha256 = "254b1c37a368c444eac6e2f867405cc9e461b0ed97a3233b2ac1e574efb4140c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3a/0c/3662f4a66880196a590b202f0db82d919dd2f89e99a27fadef91c4a33d41/xlsxwriter-3.2.9-py3-none-any.whl", upload-time = 2025-09-16T00:16:20Z, size = 175315, hashes = { sha256 = "9a5db42bc5dff014806c58a20b9eae7322a134abb6fce3c92c181bfb275ec5b3" } }] + +[[packages]] +name = "xxhash" +version = "3.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/24/2f/e183a1b407002f5af81822bee18b61cdb94b8670208ef34734d8d2b8ebe9/xxhash-3.7.0.tar.gz", upload-time = 2026-04-25T11:10:32Z, size = 82022, hashes = { sha256 = "6cc4eefbb542a5d6ffd6d70ea9c502957c925e800f998c5630ecc809d6702bae" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/40/37/558f5a90c0672fc9b4402dc25d87ac5b7406616e8969430c9ca4e52ee74d/xxhash-3.7.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-25T11:06:31Z, size = 193932, hashes = { sha256 = "13805f0461cba0a857924e70ff91ae6d52d2598f79a884e788db80532614a4a1" } }] + +[[packages]] +name = "yarl" +version = "1.23.0" +sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", upload-time = 2026-03-01T22:07:53Z, size = 194676, hashes = { sha256 = "53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-01T22:05:23Z, size = 100132, hashes = { sha256 = "a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51" } }, + { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", upload-time = 2026-03-01T22:07:51Z, size = 48288, hashes = { sha256 = "a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f" } }, +] + +[[packages]] +name = "zlib-state" +version = "0.1.12" +sdist = { url = "https://files.pythonhosted.org/packages/53/f2/c1b3dfb76ff3eac8eb2a96eb1e8e05c13534c73f0d1d582dfadadb5a863a/zlib_state-0.1.12.tar.gz", upload-time = 2026-04-14T19:08:30Z, size = 9618, hashes = { sha256 = "ccbb06321daf165b022aa4d22d62effb7df76f55035d50bbe8b93696db416cf0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/bb/20/b26f462b948ea8e66f878502c9594a32eda4e8ad96d9943667f4fe0f7a91/zlib_state-0.1.12-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-14T19:09:45Z, size = 22006, hashes = { sha256 = "91a0b6c7007ed4bd3162ac33114ceea62c28b24cd585efe3a10d2626576b445a" } }] diff --git a/packages/sie_server/bundle-locks/cuda12-sglang-amd64/manifest.json b/packages/sie_server/bundle-locks/cuda12-sglang-amd64/manifest.json new file mode 100644 index 000000000..bd86370db --- /dev/null +++ b/packages/sie_server/bundle-locks/cuda12-sglang-amd64/manifest.json @@ -0,0 +1,28 @@ +{ + "completed_artifact_hashes": [], + "exceptions_sha256": "f94e7c7f1d19ac063771a0ddf0e6657d76cf7c0501e0d74656cdc3019f781268", + "exclude_newer": "2026-10-18T00:00:00Z", + "indexes": [ + "--default-index", + "https://pypi.org/simple", + "--index", + "https://docs.sglang.ai/whl/cu129/", + "--index-strategy", + "unsafe-best-match" + ], + "inputs": { + "requirements_sha256": "943a74a3f4565e0b7b3bab2f87080526604d1e3923a39ed287d444630d33b94c", + "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" + }, + "lock_sha256": "9b59da8d8bfaea7599787085f2e16e54082cb9eecf1085fec2178b98eba2439f", + "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "schema_version": 1, + "target": { + "architecture": "amd64", + "bundle": "sglang", + "platform": "cuda12", + "python_platform": "x86_64-manylinux_2_35", + "python_version": "3.12" + }, + "uv_version": "0.9.28" +} diff --git a/packages/sie_server/bundle-locks/cuda12-sglang-amd64/pylock.toml b/packages/sie_server/bundle-locks/cuda12-sglang-amd64/pylock.toml new file mode 100644 index 000000000..7d2897b02 --- /dev/null +++ b/packages/sie_server/bundle-locks/cuda12-sglang-amd64/pylock.toml @@ -0,0 +1,1319 @@ +lock-version = "1.0" +created-by = "uv" +requires-python = ">=3.12" + +[[packages]] +name = "aiohappyeyeballs" +version = "2.6.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", upload-time = 2025-03-12T01:42:48Z, size = 22760, hashes = { sha256 = "c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", upload-time = 2025-03-12T01:42:47Z, size = 15265, hashes = { sha256 = "f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8" } }] + +[[packages]] +name = "aiohttp" +version = "3.14.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/58/d9/22ce5786ac0c1653ae8b6c23bded02c1686d11f0dbb45b31ce128e0df985/aiohttp-3.14.3.tar.gz", upload-time = 2026-07-23T01:57:27Z, size = 7971213, hashes = { sha256 = "9491196535a88924a60afd5b5f434b5b203b6cc616250878dbdb223a8f7844bc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/52/b7/7cd31f29d6055bd711ae6e669367fba6f5ae9de463910a793e30556a8db7/aiohttp-3.14.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-23T01:54:15Z, size = 1792122, hashes = { sha256 = "543906c127fb1d929b95076db19b83fa2d46751006ff1e23b093aa5ac4d8db42" } }] + +[[packages]] +name = "aiosignal" +version = "1.4.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", upload-time = 2025-07-03T22:54:43Z, size = 25007, hashes = { sha256 = "f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", upload-time = 2025-07-03T22:54:42Z, size = 7490, hashes = { sha256 = "053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e" } }] + +[[packages]] +name = "airportsdata" +version = "20260905" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/a5/c2/69ec4b992746c4c7b076a7afffb11fc64267d684ed0cd3db00035f0f682b/airportsdata-20260905.tar.gz", upload-time = 2026-09-05T06:02:21Z, size = 929470, hashes = { sha256 = "a7e17469458ca356a5ca9971f49864b934a559d43e1587e19219cb981d364c45" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/45/f8/65e9d476f84bb60ac7ff1fe525acdd60fe6b4b585ae6f074c947c6ad0fc1/airportsdata-20260905-py3-none-any.whl", upload-time = 2026-09-05T06:02:19Z, size = 931164, hashes = { sha256 = "d7eaa9a57d373b0adaaae0d52da2af0bb0edf73f7baa170f7c415d3342bf4868" } }] + +[[packages]] +name = "annotated-doc" +version = "0.0.4" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", upload-time = 2025-11-10T22:07:42Z, size = 7288, hashes = { sha256 = "fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", upload-time = 2025-11-10T22:07:40Z, size = 5303, hashes = { sha256 = "571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320" } }] + +[[packages]] +name = "annotated-types" +version = "0.7.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", upload-time = 2024-05-20T21:33:25Z, size = 16081, hashes = { sha256 = "aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", upload-time = 2024-05-20T21:33:24Z, size = 13643, hashes = { sha256 = "1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53" } }] + +[[packages]] +name = "anthropic" +version = "1.15.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/10/37/5a2a4316df8babd28f096477a707cd75f240b4264c97fb128c32375105d6/anthropic-1.15.0.tar.gz", upload-time = 2026-10-15T19:45:34Z, size = 1726101, hashes = { sha256 = "90caa9df83e2fc8bddb4ddeb83b7191bce255f635c03eae055deec521741df08" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d1/65/54437e7edea49a3be9ef56f6b5965999bfdc52b9dadc9b448124ca51a594/anthropic-1.15.0-py3-none-any.whl", upload-time = 2026-10-15T19:45:32Z, size = 2047755, hashes = { sha256 = "10189a7993c5c71a0a2d4bb80020ca6a2fd27679f51e627405da37251d15ff49" } }] + +[[packages]] +name = "anyio" +version = "4.14.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/61/cc/a381afa6efea9f496eff839d4a6a1aed3bfafc7b3ab4b0d1b243a12573dd/anyio-4.14.2.tar.gz", upload-time = 2026-07-12T20:29:07Z, size = 260176, hashes = { sha256 = "cfa139f3ed1a23ee8f88a145ddb5ac7605b8bbfd8592baacd7ce3d8bb4313c7f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/da/35/f2287558c17e29fafc8ef3daf819bb9834061cfa43bff8014f7df7f63bdc/anyio-4.14.2-py3-none-any.whl", upload-time = 2026-07-12T20:29:05Z, size = 125813, hashes = { sha256 = "9f505dda5ac9f0c8309b5e8bd445a8c2bf7246f3ce950121e45ea15bc41d1494" } }] + +[[packages]] +name = "apache-tvm-ffi" +version = "0.1.14.post1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ed/50/2b9d308f34843b99e763ac7d510ba6400dbb3e86b3f04fd206be0dc9cd46/apache_tvm_ffi-0.1.14.post1.tar.gz", upload-time = 2026-09-24T07:52:45Z, size = 3232883, hashes = { sha256 = "8ebd92dc97cdcb22ab494aa252c868ddd6a9b6c89be69188562e0f236652429f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e8/db/68786fdc0bfb3a9782df7304c1e577b9c5a7d14c75e98e06571cc1869b3f/apache_tvm_ffi-0.1.14.post1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-09-24T07:52:14Z, size = 3251763, hashes = { sha256 = "eb759c039866b541ec2cb07d498082f8ba6ded74d58d9196180a5932f365c077" } }] + +[[packages]] +name = "asttokens" +version = "3.0.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/be/a5/8e3f9b6771b0b408517c82d97aed8f2036509bc247d46114925e32fe33f0/asttokens-3.0.1.tar.gz", upload-time = 2025-11-15T16:43:48Z, size = 62308, hashes = { sha256 = "71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d2/39/e7eaf1799466a4aef85b6a4fe7bd175ad2b1c6345066aa33f1f58d4b18d0/asttokens-3.0.1-py3-none-any.whl", upload-time = 2025-11-15T16:43:16Z, size = 27047, hashes = { sha256 = "15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a" } }] + +[[packages]] +name = "attrs" +version = "26.1.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", upload-time = 2026-03-19T14:22:25Z, size = 952055, hashes = { sha256 = "d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", upload-time = 2026-03-19T14:22:23Z, size = 67548, hashes = { sha256 = "c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309" } }] + +[[packages]] +name = "blobfile" +version = "3.0.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/9d/a9/a34e8153b0203d9060ff7aa5dfcd175e161117949697a83c4cc003b523ff/blobfile-3.0.0.tar.gz", upload-time = 2024-08-27T00:02:53Z, size = 77863, hashes = { sha256 = "32ec777414de7bb2a76ca812a838f0d33327ca28ae844a253503cde625cdf2f1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ed/4d/1392562369b1139e741b30d624f09fe7091d17dd5579fae5732f044b12bb/blobfile-3.0.0-py3-none-any.whl", upload-time = 2024-08-27T00:02:51Z, size = 75413, hashes = { sha256 = "48ecc3307e622804bd8fe13bf6f40e6463c4439eba7a1f9ad49fd78aa63cc658" } }] + +[[packages]] +name = "build" +version = "1.4.4" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/02/ec/bf5ae0a7e5ab57abe8aabdd0759c971883895d1a20c49ae99f8146840c3c/build-1.4.4.tar.gz", upload-time = 2026-04-22T20:53:44Z, size = 89220, hashes = { sha256 = "f832ae053061f3fb524af812dc94b8b84bac6880cd587630e3b5d91a6a9c1703" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/fa/88/6764e7a109dd84294850741501145da90d13cdeac9d4e614929464a37420/build-1.4.4-py3-none-any.whl", upload-time = 2026-04-22T20:53:43Z, size = 25921, hashes = { sha256 = "8c3f48a6090b39edec1a273d2d57949aaf13723b01e02f9d518396887519f64d" } }] + +[[packages]] +name = "certifi" +version = "2026.4.22" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/25/ee/6caf7a40c36a1220410afe15a1cc64993a1f864871f698c0f93acb72842a/certifi-2026.4.22.tar.gz", upload-time = 2026-04-22T11:26:11Z, size = 137077, hashes = { sha256 = "8d455352a37b71bf76a79caa83a3d6c25afee4a385d632127b6afb3963f1c580" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/22/30/7cd8fdcdfbc5b869528b079bfb76dcdf6056b1a2097a662e5e8c04f42965/certifi-2026.4.22-py3-none-any.whl", upload-time = 2026-04-22T11:26:09Z, size = 135707, hashes = { sha256 = "3cb2210c8f88ba2318d29b0388d1023c8492ff72ecdde4ebdaddbb13a31b1c4a" } }] + +[[packages]] +name = "cffi" +version = "2.0.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", upload-time = 2025-09-08T23:24:04Z, size = 523588, hashes = { sha256 = "44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-09-08T23:22:52Z, size = 219572, hashes = { sha256 = "3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba" } }] + +[[packages]] +name = "charset-normalizer" +version = "3.4.7" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", upload-time = 2026-04-02T09:28:39Z, size = 144271, hashes = { sha256 = "ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4b/f8/d0118a2f5f23b02cd166fa385c60f9b0d4f9194f574e2b31cef350ad7223/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-02T09:26:29Z, size = 216589, hashes = { sha256 = "5649fd1c7bade02f320a462fdefd0b4bd3ce036065836d4f42e0de958038e116" } }, + { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", upload-time = 2026-04-02T09:28:37Z, size = 61958, hashes = { sha256 = "3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d" } }, +] + +[[packages]] +name = "click" +version = "8.1.8" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", upload-time = 2024-12-21T18:38:44Z, size = 226593, hashes = { sha256 = "ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", upload-time = 2024-12-21T18:38:41Z, size = 98188, hashes = { sha256 = "63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2" } }] + +[[packages]] +name = "cloudpickle" +version = "3.1.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/27/fb/576f067976d320f5f0114a8d9fa1215425441bb35627b1993e5afd8111e5/cloudpickle-3.1.2.tar.gz", upload-time = 2025-11-03T09:25:26Z, size = 22330, hashes = { sha256 = "7fda9eb655c9c230dab534f1983763de5835249750e85fbcef43aaa30a9a2414" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl", upload-time = 2025-11-03T09:25:25Z, size = 22228, hashes = { sha256 = "9acb47f6afd73f60dc1df93bb801b472f05ff42fa6c84167d25cb206be1fbf4a" } }] + +[[packages]] +name = "compressed-tensors" +version = "0.15.0.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/41/1b/c3c4a98ec5f2727656336f07a0c35862195c310d8eb0b2fa5b4be6848680/compressed_tensors-0.15.0.1.tar.gz", upload-time = 2026-04-10T14:23:54Z, size = 229412, hashes = { sha256 = "a8e93054e8a5ec49c980b09ed36c4c1249b4a8ee167920a8e461c4da26e78d99" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a8/52/93833dc1610e017ac5b7dcd59b8304d8ef67d1114c2d124e728a2cbbea12/compressed_tensors-0.15.0.1-py3-none-any.whl", upload-time = 2026-04-10T14:23:53Z, size = 194260, hashes = { sha256 = "e1b1f322e82e475715e242bad46925a304ea8e5c98b5055a15b8eb22fb6bfea9" } }] + +[[packages]] +name = "cryptography" +version = "50.0.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/de/41/6cbdcf9142d00fe82836fbb51e503e58088575cf7a0fe1dbff6695bf0840/cryptography-50.0.0.tar.gz", upload-time = 2026-07-31T14:25:10Z, size = 880201, hashes = { sha256 = "eeac2acb5a20ed25e0ad6d1df9891a520b78b404266b6d11778f25d5d691a6c9" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/41/029086c34d91052fc3b88bcc8056f709a7c915c7a23b235a54eb800b1c97/cryptography-50.0.0-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-07-31T14:23:37Z, size = 4702130, hashes = { sha256 = "06a32a980526a6ab9a4b9bf8f7385800791e2bb960903cb6b530e4817509a3b7" } }, + { url = "https://files.pythonhosted.org/packages/6b/72/a1116d683a6d7ece94590013882515de087edf9ef0e6292aae615a44df73/cryptography-50.0.0-cp311-abi3-manylinux_2_28_x86_64.whl", upload-time = 2026-07-31T14:23:43Z, size = 4734609, hashes = { sha256 = "b42a28c1844fd9de8f3f7d540e36b66f3a9c83fceac7170ebc7a6a19edd9dcae" } }, + { url = "https://files.pythonhosted.org/packages/da/3a/f05e32c99d440c9bb891ea0e36c9091891e36be5a9a87ab2ee6ea20729f6/cryptography-50.0.0-cp311-abi3-manylinux_2_34_x86_64.whl", upload-time = 2026-07-31T14:23:50Z, size = 4734462, hashes = { sha256 = "82148ec5bddac30b51a5b3c1945075f896fa022cb93f8e4a01e9f6ee95292c5f" } }, + { url = "https://files.pythonhosted.org/packages/85/4f/0fa8c2f4428198f15d9ff8d63400e27afbf94ce833f6108da1eb3753f945/cryptography-50.0.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-07-31T14:24:27Z, size = 4728939, hashes = { sha256 = "a91296cb61e8df6f86d0c19cc4068228da256bf59bf86049fbd821084565327f" } }, + { url = "https://files.pythonhosted.org/packages/46/c9/f60aed34c013f317f92817b6c171c2d22a78270fa41109bd4b08af26b194/cryptography-50.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", upload-time = 2026-07-31T14:24:34Z, size = 4762647, hashes = { sha256 = "105110f43a471dbd0060b9c9516cb8a6a79233631a04cc2ba16f28323ac6e025" } }, + { url = "https://files.pythonhosted.org/packages/9c/f8/d97f9603efda3888187bfdb893f26c41be4735c10631d05d284ee6b047c4/cryptography-50.0.0-cp39-abi3-manylinux_2_34_x86_64.whl", upload-time = 2026-07-31T14:24:43Z, size = 4762400, hashes = { sha256 = "37fdb0d0111f1e2ff07139dfb79f1b49531f8e213c46f1163dd7642979b58c47" } }, +] + +[[packages]] +name = "cuda-bindings" +version = "12.9.10" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/7b/6e/0e07e8b3578547e1083a7ee105c5736033ecb189466f40e45283b46bc7c6/cuda_bindings-12.9.10-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-10-15T14:12:03Z, size = 7627380, hashes = { sha256 = "420e44cfcd939cd69d6cfe8efc5f08b44850994cae399a49b9299a464324ce97" } }] + +[[packages]] +name = "cuda-pathfinder" +version = "1.8.3" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/b9/fb/f8e1890428f9f590b4beebd63b068aac1ce32a3331510c847b9f9a78f261/cuda_pathfinder-1.8.3-py3-none-any.whl", upload-time = 2026-10-02T03:20:23Z, size = 62561, hashes = { sha256 = "e29e59829c297a7a5233bd9cc71094fc5bddbd076951482670178f9eade39b1f" } }] + +[[packages]] +name = "cuda-python" +version = "12.9.0" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/24/3c/4475aebeaab9651f2e61000fbe76f91a476d371dbfbf0a1cf46e689af253/cuda_python-12.9.0-py3-none-any.whl", upload-time = 2025-05-06T19:14:07Z, size = 7532, hashes = { sha256 = "926acba49b2c0a0374c61b7c98f337c085199cf51cdfe4d6423c4129c20547a7" } }] + +[[packages]] +name = "cuda-tile" +version = "1.6.0" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/40/21/3dfeafbd3512e94a277a25ce022c10e7bdff5d43e364afffcc0928f7fcaf/cuda_tile-1.6.0-cp312-cp312-manylinux2014_x86_64.whl", upload-time = 2026-09-10T00:06:48Z, size = 382170, hashes = { sha256 = "7e38f97bfedff359c926710387a40fbfc8f36efb7fe9ad2cb759d5a098eedde3" } }] + +[[packages]] +name = "datasets" +version = "3.6.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/1a/89/d3d6fef58a488f8569c82fd293ab7cbd4250244d67f425dcae64c63800ea/datasets-3.6.0.tar.gz", upload-time = 2025-05-07T15:15:02Z, size = 569336, hashes = { sha256 = "1b2bf43b19776e2787e181cfd329cb0ca1a358ea014780c3581e0f276375e041" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/20/34/a08b0ee99715eaba118cbe19a71f7b5e2425c2718ef96007c325944a1152/datasets-3.6.0-py3-none-any.whl", upload-time = 2025-05-07T15:14:59Z, size = 491546, hashes = { sha256 = "25000c4a2c0873a710df127d08a202a06eab7bf42441a6bc278b499c2f72cd1b" } }] + +[[packages]] +name = "decorator" +version = "5.2.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", upload-time = 2025-02-24T04:41:34Z, size = 56711, hashes = { sha256 = "65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", upload-time = 2025-02-24T04:41:32Z, size = 9190, hashes = { sha256 = "d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a" } }] + +[[packages]] +name = "dill" +version = "0.3.8" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/17/4d/ac7ffa80c69ea1df30a8aa11b3578692a5118e7cd1aa157e3ef73b092d15/dill-0.3.8.tar.gz", upload-time = 2024-01-27T23:42:16Z, size = 184847, hashes = { sha256 = "3ebe3c479ad625c4553aca177444d89b486b1d84982eeacded644afc0cf797ca" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c9/7a/cef76fd8438a42f96db64ddaa85280485a9c395e7df3db8158cfec1eee34/dill-0.3.8-py3-none-any.whl", upload-time = 2024-01-27T23:42:14Z, size = 116252, hashes = { sha256 = "c36ca9ffb54365bdd2f8eb3eff7d2a21237f8452b57ace88b1ac615b7e815bd7" } }] + +[[packages]] +name = "diskcache" +version = "5.6.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/3f/21/1c1ffc1a039ddcc459db43cc108658f32c57d271d7289a2794e401d0fdb6/diskcache-5.6.3.tar.gz", upload-time = 2023-08-31T06:12:00Z, size = 67916, hashes = { sha256 = "2c3a3fa2743d8535d832ec61c2054a1641f41775aa7c556758a109941e33e4fc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3f/27/4570e78fc0bf5ea0ca45eb1de3818a23787af9b390c0b0a0033a1b8236f9/diskcache-5.6.3-py3-none-any.whl", upload-time = 2023-08-31T06:11:58Z, size = 45550, hashes = { sha256 = "5e31b2d5fbad117cc363ebaf6b689474db18a1f6438bc82358b024abd4c2ca19" } }] + +[[packages]] +name = "distro" +version = "1.9.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", upload-time = 2023-12-24T09:54:32Z, size = 60722, hashes = { sha256 = "2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", upload-time = 2023-12-24T09:54:30Z, size = 20277, hashes = { sha256 = "7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2" } }] + +[[packages]] +name = "docstring-parser" +version = "0.18.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/e0/4d/f332313098c1de1b2d2ff91cf2674415cc7cddab2ca1b01ae29774bd5fdf/docstring_parser-0.18.0.tar.gz", upload-time = 2026-04-14T04:09:19Z, size = 29341, hashes = { sha256 = "292510982205c12b1248696f44959db3cdd1740237a968ea1e2e7a900eeb2015" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a7/5f/ed01f9a3cdffbd5a008556fc7b2a08ddb1cc6ace7effa7340604b1d16699/docstring_parser-0.18.0-py3-none-any.whl", upload-time = 2026-04-14T04:09:18Z, size = 22484, hashes = { sha256 = "b3fcbed555c47d8479be0796ef7e19c2670d428d72e96da63f3a40122860374b" } }] + +[[packages]] +name = "einops" +version = "0.8.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/2c/77/850bef8d72ffb9219f0b1aac23fbc1bf7d038ee6ea666f331fa273031aa2/einops-0.8.2.tar.gz", upload-time = 2026-01-26T04:13:17Z, size = 56261, hashes = { sha256 = "609da665570e5e265e27283aab09e7f279ade90c4f01bcfca111f3d3e13f2827" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/09/f8d8f8f31e4483c10a906437b4ce31bdf3d6d417b73fe33f1a8b59e34228/einops-0.8.2-py3-none-any.whl", upload-time = 2026-01-26T04:13:18Z, size = 65638, hashes = { sha256 = "54058201ac7087911181bfec4af6091bb59380360f069276601256a76af08193" } }] + +[[packages]] +name = "executing" +version = "2.2.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", upload-time = 2025-09-01T09:48:10Z, size = 1129488, hashes = { sha256 = "3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", upload-time = 2025-09-01T09:48:08Z, size = 28317, hashes = { sha256 = "760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017" } }] + +[[packages]] +name = "fastapi" +version = "0.136.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/5d/45/c130091c2dfa061bbfe3150f2a5091ef1adf149f2a8d2ae769ecaf6e99a2/fastapi-0.136.1.tar.gz", upload-time = 2026-04-23T16:49:44Z, size = 397448, hashes = { sha256 = "7af665ad7acfa0a3baf8983d393b6b471b9da10ede59c60045f49fbc89a0fa7f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5a/ff/2e4eca3ade2c22fe1dea7043b8ee9dabe47753349eb1b56a202de8af6349/fastapi-0.136.1-py3-none-any.whl", upload-time = 2026-04-23T16:49:42Z, size = 117683, hashes = { sha256 = "a6e9d7eeada96c93a4d69cb03836b44fa34e2854accb7244a1ece36cd4781c3f" } }] + +[[packages]] +name = "filelock" +version = "3.29.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/b5/fe/997687a931ab51049acce6fa1f23e8f01216374ea81374ddee763c493db5/filelock-3.29.0.tar.gz", upload-time = 2026-04-19T15:39:10Z, size = 57571, hashes = { sha256 = "69974355e960702e789734cb4871f884ea6fe50bd8404051a3530bc07809cf90" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/81/47/dd9a212ef6e343a6857485ffe25bba537304f1913bdbed446a23f7f592e1/filelock-3.29.0-py3-none-any.whl", upload-time = 2026-04-19T15:39:08Z, size = 39812, hashes = { sha256 = "96f5f6344709aa1572bbf631c640e4ebeeb519e08da902c39a001882f30ac258" } }] + +[[packages]] +name = "flash-attn-4" +version = "4.0.0b19" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/93/63/6a00e1cd55765f5cf7d7a0100d1a5831824227ae3306275f3e6db420a76e/flash_attn_4-4.0.0b19.tar.gz", upload-time = 2026-06-24T09:15:14Z, size = 353141, hashes = { sha256 = "c904c9da0387c2ac0420cffdf61d6201d94cfeb354b6768fde794b04e9fc4e89" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e4/0e/5298d57e3efd5b7a07755fa9009fc1f6efc0f2d422915113eb7288a6552b/flash_attn_4-4.0.0b19-py3-none-any.whl", upload-time = 2026-06-24T09:15:13Z, size = 377662, hashes = { sha256 = "bc3856e018fa32e2b833726566641e51d02d45f2d444849937276a46c01653a2" } }] + +[[packages]] +name = "flashinfer-cubin" +version = "0.6.7.post3" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/91/64/f516081e983a35e3f52b7e525e2e62f1d6148c175eb24df32c8786776ba5/flashinfer_cubin-0.6.7.post3-py3-none-any.whl", upload-time = 2026-04-06T01:43:16Z, size = 294635743, hashes = { sha256 = "724cbce52f917dd06ebcb61fff2146c30b69cfdb341891d7c293249e414d6e35" } }] + +[[packages]] +name = "flashinfer-python" +version = "0.6.7.post3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/12/b5/466778818d195b96a062467ee389d0fcfa51fdfecad4a831922916d4c48a/flashinfer_python-0.6.7.post3.tar.gz", upload-time = 2026-04-06T01:43:00Z, size = 6508243, hashes = { sha256 = "defad86864e087f754ed0a632c2d15aa389a1dc8e3198fb6b7d7af4b36e3eaa5" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/01/6b/4117cd7cbeff07818ae7c6b8bf5a6d1ee3eed29356672b731b55af3d4453/flashinfer_python-0.6.7.post3-py3-none-any.whl", upload-time = 2026-04-06T01:42:58Z, size = 9187533, hashes = { sha256 = "9d3f1aa0313cf9e5cf99f7560b8e003c57876088c8abfe7a3d330cccd4873052" } }] + +[[packages]] +name = "frozenlist" +version = "1.8.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", upload-time = 2025-10-06T05:38:17Z, size = 45875, hashes = { sha256 = "3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2025-10-06T05:36:09Z, size = 242411, hashes = { sha256 = "494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383" } }, + { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", upload-time = 2025-10-06T05:38:16Z, size = 13409, hashes = { sha256 = "0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d" } }, +] + +[[packages]] +name = "fsspec" +version = "2025.3.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/34/f4/5721faf47b8c499e776bc34c6a8fc17efdf7fdef0b00f398128bc5dcb4ac/fsspec-2025.3.0.tar.gz", upload-time = 2025-03-07T21:47:56Z, size = 298491, hashes = { sha256 = "a935fd1ea872591f2b5148907d103488fc523295e6c64b835cfad8c3eca44972" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/56/53/eb690efa8513166adef3e0669afd31e95ffde69fb3c52ec2ac7223ed6018/fsspec-2025.3.0-py3-none-any.whl", upload-time = 2025-03-07T21:47:54Z, size = 193615, hashes = { sha256 = "efb87af3efa9103f94ca91a7f8cb7a4df91af9f74fc106c9c7ea0efd7277c1b3" } }] + +[[packages]] +name = "gguf" +version = "0.19.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/48/ae/17f1308ae45cd7b08ebb521747d5b23f4efc4d172038a4e228dd5106c3ff/gguf-0.19.0.tar.gz", upload-time = 2026-05-06T13:04:03Z, size = 111220, hashes = { sha256 = "dbadcd6cc7ccd44256f2229fe7c2dff5e8aa5cf0612ab987fd2b1a57e428923f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b3/bb/d71d6da82763528c2c2ed6b59a9d6142c6595545a4c448e2085d155e88c2/gguf-0.19.0-py3-none-any.whl", upload-time = 2026-05-06T13:04:02Z, size = 118475, hashes = { sha256 = "70bcd10edfe697fb2dad6e40af2234b9d8ece9a41a99761405121ebda1c3c1cd" } }] + +[[packages]] +name = "grpcio" +version = "1.78.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/06/8a/3d098f35c143a89520e568e6539cc098fcd294495910e359889ce8741c84/grpcio-1.78.0.tar.gz", upload-time = 2026-02-06T09:57:18Z, size = 12852416, hashes = { sha256 = "7382b95189546f375c174f53a5fa873cef91c4b8005faa05cc5b3beea9c4f1c5" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/54/bf/f4a3b9693e35d25b24b0b39fa46d7d8a3c439e0a3036c3451764678fec20/grpcio-1.78.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-02-06T09:55:36Z, size = 6690766, hashes = { sha256 = "12a771591ae40bc65ba67048fa52ef4f0e6db8279e595fd349f9dfddeef571f9" } }] + +[[packages]] +name = "grpcio-health-checking" +version = "1.78.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/8e/ac/8eb871f4e47b11abfe45497e6187a582ec680ccd7232706d228474a8c7a5/grpcio_health_checking-1.78.0.tar.gz", upload-time = 2026-02-06T10:01:47Z, size = 17008, hashes = { sha256 = "78526d5c60b9b99fd18954b89f86d70033c702e96ad6ccc9749baf16136979b3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8e/30/dbaf47e2210697e2923b49eb62a6a2c07d5ee55bb40cff1e6cc0c5bb22e1/grpcio_health_checking-1.78.0-py3-none-any.whl", upload-time = 2026-02-06T10:01:37Z, size = 19010, hashes = { sha256 = "309798c098c5de72a9bff7172d788fdf309d246d231db9955b32e7c1c773fbeb" } }] + +[[packages]] +name = "grpcio-reflection" +version = "1.78.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/31/06/337546aae558675f79cae2a8c1ce0c9b1952cbc5c28b01878f68d040f5bb/grpcio_reflection-1.78.0.tar.gz", upload-time = 2026-02-06T10:01:52Z, size = 19098, hashes = { sha256 = "e6e60c0b85dbcdf963b4d4d150c0f1d238ba891d805b575c52c0365d07fc0c40" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/df/6d/4d095d27ccd049865ecdafc467754e9e47ad0f677a30dda969c3590f6582/grpcio_reflection-1.78.0-py3-none-any.whl", upload-time = 2026-02-06T10:01:33Z, size = 22800, hashes = { sha256 = "06fcfde9e6888cdd12e9dd1cf6dc7c440c2e9acf420f696ccbe008672ed05b60" } }] + +[[packages]] +name = "h11" +version = "0.16.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", upload-time = 2025-04-24T03:35:25Z, size = 101250, hashes = { sha256 = "4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", upload-time = 2025-04-24T03:35:24Z, size = 37515, hashes = { sha256 = "63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86" } }] + +[[packages]] +name = "hf-xet" +version = "1.4.3" +marker = "(platform_machine == 'AMD64' and sys_platform == 'linux') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'amd64' and sys_platform == 'linux') or (platform_machine == 'arm64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" +sdist = { url = "https://files.pythonhosted.org/packages/53/92/ec9ad04d0b5728dca387a45af7bc98fbb0d73b2118759f5f6038b61a57e8/hf_xet-1.4.3.tar.gz", upload-time = 2026-03-31T22:40:07Z, size = 670477, hashes = { sha256 = "8ddedb73c8c08928c793df2f3401ec26f95be7f7e516a7bee2fbb546f6676113" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/df/9a/a24b26dc8a65f0ecc0fe5be981a19e61e7ca963b85e062c083f3a9100529/hf_xet-1.4.3-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-03-31T22:39:42Z, size = 4212320, hashes = { sha256 = "fc360b70c815bf340ed56c7b8c63aacf11762a4b099b2fe2c9bd6d6068668c08" } }] + +[[packages]] +name = "httpcore" +version = "1.0.9" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", upload-time = 2025-04-24T22:06:22Z, size = 85484, hashes = { sha256 = "6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", upload-time = 2025-04-24T22:06:20Z, size = 78784, hashes = { sha256 = "2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55" } }] + +[[packages]] +name = "httpcore2" +version = "2.3.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/e6/34/18f1c596e677962f040284246f393b10a1f8ce440b3a7e69c637d0f1c7ad/httpcore2-2.3.0.tar.gz", upload-time = 2026-06-01T13:15:02Z, size = 64300, hashes = { sha256 = "07327e251560960eea8e969d92d4c6a325feb13cca39e25340731336c3baf924" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c2/dd/3357218c69360d1cecc196c230c9a1d5c9afd5dba362056e23e60a5e64e5/httpcore2-2.3.0-py3-none-any.whl", upload-time = 2026-06-01T13:15:00Z, size = 80024, hashes = { sha256 = "477e9e334f74e5240dcac002e890580f36a57d40ff0fb14cc9655731d23b8415" } }] + +[[packages]] +name = "httpx" +version = "0.28.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", upload-time = 2024-12-06T15:37:23Z, size = 141406, hashes = { sha256 = "75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", upload-time = 2024-12-06T15:37:21Z, size = 73517, hashes = { sha256 = "d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad" } }] + +[[packages]] +name = "httpx2" +version = "2.3.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/9f/9a/cca0b9145f13d8ae34b885ae28d403a1469a433abc78e0f94f4ce94e650b/httpx2-2.3.0.tar.gz", upload-time = 2026-06-01T13:15:04Z, size = 81115, hashes = { sha256 = "227e7c41d95a76d4077a52640564132777215fc3394e07b66a3116c33d668fa9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/87/ce/ae2911859847f9ba1d6b23027e53481cbeb50b93234f355a968d300ca2cb/httpx2-2.3.0-py3-none-any.whl", upload-time = 2026-06-01T13:15:01Z, size = 74538, hashes = { sha256 = "6f393663bdf6dbe7fe90118e3eb5b2bd024a675cae0390ac08cec9198812d8b7" } }] + +[[packages]] +name = "huggingface-hub" +version = "1.16.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/48/0f/ed994dbade67a54407c28cab96ef845e0e6d25500be56aca6394f8bfc9dd/huggingface_hub-1.16.1.tar.gz", upload-time = 2026-05-21T18:40:00Z, size = 792534, hashes = { sha256 = "7f1dc4c5ec21aed69be630ad0c3378616be16f3de1a47b141c0e812965d9c832" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/49/79/621a7dbb80c70974f73a597275351ebe03ce5bc65cb5f8f4acb5859252bc/huggingface_hub-1.16.1-py3-none-any.whl", upload-time = 2026-05-21T18:39:58Z, size = 668176, hashes = { sha256 = "64340de934b9ce37857ef85a82de72f5629e8a270f9119eabb12bf495eb53c22" } }] + +[[packages]] +name = "idna" +version = "3.17" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/b9/28/99c51f664567218d824af024c0251650fb27e4ca066df188dab0769c5b91/idna-3.17.tar.gz", upload-time = 2026-05-28T14:32:38Z, size = 196048, hashes = { sha256 = "5eb0cb53bc467c12eadcf6de83163ad8527cec9416f44b9b61b19caedad2b87f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/de/a7/f76514cc40ad6234098ecdebda08732d75964776c51a42845b7da10649e2/idna-3.17-py3-none-any.whl", upload-time = 2026-05-28T14:32:37Z, size = 65316, hashes = { sha256 = "466e48829084efe2548012b855df21540b96f2e20e51bd124c851536556a592c" } }] + +[[packages]] +name = "importlib-metadata" +version = "8.5.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/cd/12/33e59336dca5be0c398a7482335911a33aa0e20776128f038019f1a95f1b/importlib_metadata-8.5.0.tar.gz", upload-time = 2024-09-11T14:56:08Z, size = 55304, hashes = { sha256 = "71522656f0abace1d072b9e5481a48f07c138e00f079c38c8f883823f9c26bd7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a0/d9/a1e041c5e7caa9a05c925f4bdbdfb7f006d1f74996af53467bc394c97be7/importlib_metadata-8.5.0-py3-none-any.whl", upload-time = 2024-09-11T14:56:07Z, size = 26514, hashes = { sha256 = "45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b" } }] + +[[packages]] +name = "interegular" +version = "0.3.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/dc/9d/8b6dde58a028a3962ce17e84d5fe73758df61378e00ef8ac3d85da34b0ff/interegular-0.3.3.tar.gz", upload-time = 2024-01-06T23:01:22Z, size = 24705, hashes = { sha256 = "d9b697b21b34884711399ba0f0376914b81899ce670032486d0d048344a76600" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c4/01/72d6472f80651673716d1deda2a5bbb633e563ecf94f4479da5519d69d25/interegular-0.3.3-py37-none-any.whl", upload-time = 2024-01-06T23:01:20Z, size = 23635, hashes = { sha256 = "b0c07007d48c89d6d19f7204972d369b2a77222722e126b6aa63aa721dc3b19c" } }] + +[[packages]] +name = "ipython" +version = "9.13.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/cd/c4/87cda5842cf5c31837c06ddb588e11c3c35d8ece89b7a0108c06b8c9b00a/ipython-9.13.0.tar.gz", upload-time = 2026-04-24T12:24:55Z, size = 4430549, hashes = { sha256 = "7e834b6afc99f020e3f05966ced34792f40267d64cb1ea9043886dab0dde5967" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b9/86/3060e8029b7cc505cce9a0137431dda81d0a3fde93a8f0f50ee0bf37a795/ipython-9.13.0-py3-none-any.whl", upload-time = 2026-04-24T12:24:53Z, size = 627274, hashes = { sha256 = "57f9d4639e20818d328d287c7b549af3d05f12486ea8f2e7f73e52a36ec4d201" } }] + +[[packages]] +name = "ipython-pygments-lexers" +version = "1.1.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", upload-time = 2025-01-17T11:24:34Z, size = 8393, hashes = { sha256 = "09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", upload-time = 2025-01-17T11:24:33Z, size = 8074, hashes = { sha256 = "a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c" } }] + +[[packages]] +name = "jedi" +version = "0.19.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", upload-time = 2024-11-11T01:41:42Z, size = 1231287, hashes = { sha256 = "4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", upload-time = 2024-11-11T01:41:40Z, size = 1572278, hashes = { sha256 = "a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9" } }] + +[[packages]] +name = "jinja2" +version = "3.1.6" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", upload-time = 2025-03-05T20:05:02Z, size = 245115, hashes = { sha256 = "0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", upload-time = 2025-03-05T20:05:00Z, size = 134899, hashes = { sha256 = "85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67" } }] + +[[packages]] +name = "jiter" +version = "0.13.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/0d/5e/4ec91646aee381d01cdb9974e30882c9cd3b8c5d1079d6b5ff4af522439a/jiter-0.13.0.tar.gz", upload-time = 2026-02-02T12:37:56Z, size = 164847, hashes = { sha256 = "f2839f9c2c7e2dffc1bc5929a510e14ce0a946be9365fd1219e7ef342dae14f4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f8/4c/09b93e30e984a187bc8aaa3510e1ec8dcbdcd71ca05d2f56aac0492453aa/jiter-0.13.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-02-02T12:36:06Z, size = 360735, hashes = { sha256 = "bdaba7d87e66f26a2c45d8cbadcbfc4bf7884182317907baf39cfe9775bb4d93" } }] + +[[packages]] +name = "jsonschema" +version = "4.23.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/38/2e/03362ee4034a4c917f697890ccd4aec0800ccf9ded7f511971c75451deec/jsonschema-4.23.0.tar.gz", upload-time = 2024-07-08T18:40:05Z, size = 325778, hashes = { sha256 = "d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/69/4a/4f9dbeb84e8850557c02365a0eee0649abe5eb1d84af92a25731c6c0f922/jsonschema-4.23.0-py3-none-any.whl", upload-time = 2024-07-08T18:40:00Z, size = 88462, hashes = { sha256 = "fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566" } }] + +[[packages]] +name = "jsonschema-specifications" +version = "2025.9.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", upload-time = 2025-09-08T01:34:59Z, size = 32855, hashes = { sha256 = "b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", upload-time = 2025-09-08T01:34:57Z, size = 18437, hashes = { sha256 = "98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe" } }] + +[[packages]] +name = "lark" +version = "1.3.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/da/34/28fff3ab31ccff1fd4f6c7c7b0ceb2b6968d8ea4950663eadcb5720591a0/lark-1.3.1.tar.gz", upload-time = 2025-10-27T18:25:56Z, size = 382732, hashes = { sha256 = "b426a7a6d6d53189d318f2b6236ab5d6429eaf09259f1ca33eb716eed10d2905" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl", upload-time = 2025-10-27T18:25:54Z, size = 113151, hashes = { sha256 = "c629b661023a014c37da873b4ff58a817398d12635d3bbb2c5a03be7fe5d1e12" } }] + +[[packages]] +name = "llguidance" +version = "0.7.30" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/bf/38/d1ef3ae08d8d857e5e0690c5b1e07bf7eb4a1cae5881d87215826dc6cadb/llguidance-0.7.30.tar.gz", upload-time = 2025-06-23T00:23:49Z, size = 1055528, hashes = { sha256 = "e93bf75f2b6e48afb86a5cee23038746975e1654672bf5ba0ae75f7d4d4a2248" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/af/80/5a40b9689f17612434b820854cba9b8cabd5142072c491b5280fe5f7a35e/llguidance-0.7.30-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-06-23T00:23:43Z, size = 15004926, hashes = { sha256 = "9edc409b9decd6cffba5f5bf3b4fbd7541f95daa8cbc9510cbf96c6ab1ffc153" } }] + +[[packages]] +name = "loguru" +version = "0.7.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/3a/05/a1dae3dffd1116099471c643b8924f5aa6524411dc6c63fdae648c4f1aca/loguru-0.7.3.tar.gz", upload-time = 2024-12-06T11:20:56Z, size = 63559, hashes = { sha256 = "19480589e77d47b8d85b2c827ad95d49bf31b0dcde16593892eb51dd18706eb6" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl", upload-time = 2024-12-06T11:20:54Z, size = 61595, hashes = { sha256 = "31a33c10c8e1e10422bfd431aeb5d351c7cf7fa671e3c4df004162264b28220c" } }] + +[[packages]] +name = "lxml" +version = "6.1.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/28/30/9abc9e34c657c33834eaf6cd02124c61bdf5944d802aa48e69be8da3585d/lxml-6.1.0.tar.gz", upload-time = 2026-04-18T04:32:51Z, size = 4197006, hashes = { sha256 = "bfd57d8008c4965709a919c3e9a98f76c2c7cb319086b3d26858250620023b13" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/7c/e08a970727d556caa040a44773c7b7e3ad0f0d73dedc863543e9a8b931f2/lxml-6.1.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-04-18T04:32:58Z, size = 5093820, hashes = { sha256 = "9147d8e386ec3b82c3b15d88927f734f565b0aaadef7def562b853adca45784a" } }, + { url = "https://files.pythonhosted.org/packages/31/ba/3c13d3fc24b7cacf675f808a3a1baabf43a30d0cd24c98f94548e9aa58eb/lxml-6.1.0-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-18T04:33:06Z, size = 5240445, hashes = { sha256 = "bc783ee3147e60a25aa0445ea82b3e8aabb83b240f2b95d32cb75587ff781814" } }, +] + +[[packages]] +name = "markdown-it-py" +version = "4.0.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", upload-time = 2025-08-11T12:57:52Z, size = 73070, hashes = { sha256 = "cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", upload-time = 2025-08-11T12:57:51Z, size = 87321, hashes = { sha256 = "87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147" } }] + +[[packages]] +name = "markupsafe" +version = "3.0.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", upload-time = 2025-09-27T18:37:40Z, size = 80313, hashes = { sha256 = "722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-09-27T18:36:33Z, size = 22947, hashes = { sha256 = "d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d" } }] + +[[packages]] +name = "matplotlib-inline" +version = "0.2.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/c7/74/97e72a36efd4ae2bccb3463284300f8953f199b5ffbc04cbbb0ec78f74b1/matplotlib_inline-0.2.1.tar.gz", upload-time = 2025-10-23T09:00:22Z, size = 8110, hashes = { sha256 = "e1ee949c340d771fc39e241ea75683deb94762c8fa5f2927ec57c83c4dffa9fe" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/af/33/ee4519fa02ed11a94aef9559552f3b17bb863f2ecfe1a35dc7f548cde231/matplotlib_inline-0.2.1-py3-none-any.whl", upload-time = 2025-10-23T09:00:20Z, size = 9516, hashes = { sha256 = "d56ce5156ba6085e00a9d54fead6ed29a9c47e215cd1bba2e976ef39f5710a76" } }] + +[[packages]] +name = "mdurl" +version = "0.1.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", upload-time = 2022-08-14T12:40:10Z, size = 8729, hashes = { sha256 = "bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", upload-time = 2022-08-14T12:40:09Z, size = 9979, hashes = { sha256 = "84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8" } }] + +[[packages]] +name = "mistral-common" +version = "1.9.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/db/ce/685b8127a326478e05501cb4c9ca23d1cd9f37e16c465a1e832c75aea709/mistral_common-1.9.1.tar.gz", upload-time = 2026-02-12T10:53:41Z, size = 6338922, hashes = { sha256 = "550583d70a395c3586cfb748ffab53bd1d7c3409507f0efc0118bff30ffb26e9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ac/72/a38bb1fd9fd4d4ef990341c9dd1a7c8061f1951e10efa6d50c0a3f04eced/mistral_common-1.9.1-py3-none-any.whl", upload-time = 2026-02-12T10:53:39Z, size = 6518623, hashes = { sha256 = "9e2b2520b6f67bac2e2bb06fcf985b7a1277b01938da2b7cda8cf0fdbfa92e91" } }] + +[[packages]] +name = "modelscope" +version = "1.40.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/d7/af/f92c9824db46757dd1b0b5cbf3778daf54e7e44f0e1e6934d0b1bedfb286/modelscope-1.40.2.tar.gz", upload-time = 2026-10-09T09:09:10Z, size = 4566951, hashes = { sha256 = "7a642cef8c144c28c4ddcc37db5fd803f5481f0d78a7f26c2b9e0e2a225b528c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b9/8a/e85b79ee1c541f7bbf208fd7a6185c9b11e50c192b1071b0750db26b09e9/modelscope-1.40.2-py3-none-any.whl", upload-time = 2026-10-09T09:09:07Z, size = 6062299, hashes = { sha256 = "ea03e0ec4a73398a488d3d240cda4f0c5b62390377a134756d4074a3036cb909" } }] + +[[packages]] +name = "modelscope-hub" +version = "0.4.6" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/08/d9/ac46c39b957ff44b55c550c641ad5c625ffe3eb5c0b6f20a849b591e9d14/modelscope_hub-0.4.6.tar.gz", upload-time = 2026-10-09T08:08:21Z, size = 298574, hashes = { sha256 = "c54de09be2ccb27b9214f7c3ebe5751121f335f5016643f789589d0547e78c52" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/4d/74/8872ae511d8a336ca918a8d0234cfbccfff0e2304de672882b2768ff628f/modelscope_hub-0.4.6-py3-none-any.whl", upload-time = 2026-10-09T08:08:19Z, size = 237177, hashes = { sha256 = "361bcec229bfbed645a9291ec5b167d76cd94b795207dc2eceba628108f4023a" } }] + +[[packages]] +name = "mpmath" +version = "1.3.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", upload-time = 2023-03-07T16:47:11Z, size = 508106, hashes = { sha256 = "7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", upload-time = 2023-03-07T16:47:09Z, size = 536198, hashes = { sha256 = "a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c" } }] + +[[packages]] +name = "msgspec" +version = "0.21.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/e3/60/f79b9b013a16fa3a58350c9295ddc6789f2e335f36ea61ed10a21b215364/msgspec-0.21.1.tar.gz", upload-time = 2026-04-12T21:44:50Z, size = 319193, hashes = { sha256 = "2313508e394b0d208f8f56892ca9b2799e2561329de9763b19619595a6c0f72c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b5/d1/d4cd9fe89c7d400d7a18f86ccc94daa3f0927f53558846fcb60791dce5d6/msgspec-0.21.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-12T21:44:11Z, size = 225025, hashes = { sha256 = "21995e74b5c598c2e004110ad66ec7f1b8c20bf2bcf3b2de8fd9a3094422d3ff" } }] + +[[packages]] +name = "multidict" +version = "6.7.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", upload-time = 2026-01-26T02:46:45Z, size = 102010, hashes = { sha256 = "ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-01-26T02:44:03Z, size = 256322, hashes = { sha256 = "bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961" } }, + { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", upload-time = 2026-01-26T02:46:44Z, size = 12319, hashes = { sha256 = "55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56" } }, +] + +[[packages]] +name = "multiprocess" +version = "0.70.16" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/b5/ae/04f39c5d0d0def03247c2893d6f2b83c136bf3320a2154d7b8858f2ba72d/multiprocess-0.70.16.tar.gz", upload-time = 2024-01-28T18:52:34Z, size = 1772603, hashes = { sha256 = "161af703d4652a0e1410be6abccecde4a7ddffd19341be0a7011b94aeb171ac1" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bc/f7/7ec7fddc92e50714ea3745631f79bd9c96424cb2702632521028e57d3a36/multiprocess-0.70.16-py310-none-any.whl", upload-time = 2024-01-28T18:52:26Z, size = 134824, hashes = { sha256 = "c4a9944c67bd49f823687463660a2d6daae94c289adff97e0f9d696ba6371d02" } }, + { url = "https://files.pythonhosted.org/packages/50/15/b56e50e8debaf439f44befec5b2af11db85f6e0f344c3113ae0be0593a91/multiprocess-0.70.16-py311-none-any.whl", upload-time = 2024-01-28T18:52:28Z, size = 143519, hashes = { sha256 = "af4cabb0dac72abfb1e794fa7855c325fd2b55a10a44628a3c1ad3311c04127a" } }, + { url = "https://files.pythonhosted.org/packages/0a/7d/a988f258104dcd2ccf1ed40fdc97e26c4ac351eeaf81d76e266c52d84e2f/multiprocess-0.70.16-py312-none-any.whl", upload-time = 2024-01-28T18:52:29Z, size = 146741, hashes = { sha256 = "fc0544c531920dde3b00c29863377f87e1632601092ea2daca74e4beb40faa2e" } }, + { url = "https://files.pythonhosted.org/packages/ea/89/38df130f2c799090c978b366cfdf5b96d08de5b29a4a293df7f7429fa50b/multiprocess-0.70.16-py38-none-any.whl", upload-time = 2024-01-28T18:52:30Z, size = 132628, hashes = { sha256 = "a71d82033454891091a226dfc319d0cfa8019a4e888ef9ca910372a446de4435" } }, + { url = "https://files.pythonhosted.org/packages/da/d9/f7f9379981e39b8c2511c9e0326d212accacb82f12fbfdc1aa2ce2a7b2b6/multiprocess-0.70.16-py39-none-any.whl", upload-time = 2024-01-28T18:52:31Z, size = 133351, hashes = { sha256 = "a0bafd3ae1b732eac64be2e72038231c1ba97724b60b09400d68f229fcc2fbf3" } }, +] + +[[packages]] +name = "nest-asyncio" +version = "1.6.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", upload-time = 2024-01-21T14:25:19Z, size = 7418, hashes = { sha256 = "6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", upload-time = 2024-01-21T14:25:17Z, size = 5195, hashes = { sha256 = "87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c" } }] + +[[packages]] +name = "networkx" +version = "3.6.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", upload-time = 2025-12-08T17:02:39Z, size = 2517025, hashes = { sha256 = "26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", upload-time = 2025-12-08T17:02:38Z, size = 2068504, hashes = { sha256 = "d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762" } }] + +[[packages]] +name = "ninja" +version = "1.13.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ac/92/410b7917d16ab54c04b05cc32b9284803671d91cf79d33be6009c28d4ea8/ninja-1.13.2.tar.gz", upload-time = 2026-08-30T15:49:51Z, size = 243739, hashes = { sha256 = "525bfa3fc88aa30a4467df270fd5be6f9fcae8061d54d4df74ea1dc5abd5a975" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/6e/53/ebfed7b689c338dd8ebeec9c0730c8d56821292f14e2536e5f3ef1a05744/ninja-1.13.2-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-08-30T15:49:34Z, size = 183365, hashes = { sha256 = "65a24341b5ac09fcadcc37082660be40a94174e51a937fabf6e2cae26225fa2c" } }] + +[[packages]] +name = "numpy" +version = "2.4.4" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/d7/9f/b8cef5bffa569759033adda9481211426f12f53299629b410340795c2514/numpy-2.4.4.tar.gz", upload-time = 2026-03-29T13:22:01Z, size = 20731587, hashes = { sha256 = "2d390634c5182175533585cc89f3608a4682ccb173cc9bb940b2881c8d6f8fa0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0a/0d/0e3ecece05b7a7e87ab9fb587855548da437a061326fff64a223b6dcb78a/numpy-2.4.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-29T13:19:03Z, size = 16645480, hashes = { sha256 = "81f4a14bee47aec54f883e0cad2d73986640c1590eb9bfaaba7ad17394481e6e" } }] + +[[packages]] +name = "nvidia-cublas-cu12" +version = "12.8.4.1" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/dc/61/e24b560ab2e2eaeb3c839129175fb330dfcfc29e5203196e5541a4c44682/nvidia_cublas_cu12-12.8.4.1-py3-none-manylinux_2_27_x86_64.whl", upload-time = 2025-03-07T01:44:31Z, size = 594346921, hashes = { sha256 = "8ac4e771d5a348c551b2a426eda6193c19aa630236b418086020df5ba9667142" } }] + +[[packages]] +name = "nvidia-cuda-cupti-cu12" +version = "12.8.90" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/f8/02/2adcaa145158bf1a8295d83591d22e4103dbfd821bcaf6f3f53151ca4ffa/nvidia_cuda_cupti_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-03-07T01:40:21Z, size = 10248621, hashes = { sha256 = "ea0cb07ebda26bb9b29ba82cda34849e73c166c18162d3913575b0c9db9a6182" } }] + +[[packages]] +name = "nvidia-cuda-nvrtc-cu12" +version = "12.8.93" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/05/6b/32f747947df2da6994e999492ab306a903659555dddc0fbdeb9d71f75e52/nvidia_cuda_nvrtc_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", upload-time = 2025-03-07T01:42:13Z, size = 88040029, hashes = { sha256 = "a7756528852ef889772a84c6cd89d41dfa74667e24cca16bb31f8f061e3e9994" } }] + +[[packages]] +name = "nvidia-cuda-runtime-cu12" +version = "12.8.90" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/0d/9b/a997b638fcd068ad6e4d53b8551a7d30fe8b404d6f1804abf1df69838932/nvidia_cuda_runtime_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-03-07T01:40:01Z, size = 954765, hashes = { sha256 = "adade8dcbd0edf427b7204d480d6066d33902cab2a4707dcfc48a2d0fd44ab90" } }] + +[[packages]] +name = "nvidia-cudnn-cu12" +version = "9.10.2.21" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/ba/51/e123d997aa098c61d029f76663dedbfb9bc8dcf8c60cbd6adbe42f76d049/nvidia_cudnn_cu12-9.10.2.21-py3-none-manylinux_2_27_x86_64.whl", upload-time = 2025-06-06T21:54:08Z, size = 706758467, hashes = { sha256 = "949452be657fa16687d0930933f032835951ef0892b37d2d53824d1a84dc97a8" } }] + +[[packages]] +name = "nvidia-cudnn-frontend" +version = "1.31.0" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/cb/24/8ec9de1fd9ea95e1c1cb9e6e2d3a5547aa9c5ece1136d650ffce1bb5d8c5/nvidia_cudnn_frontend-1.31.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-10-08T18:06:15Z, size = 10159344, hashes = { sha256 = "3171f102254136418f24b4470dfa5419f34b03d9d792a4b773cf65c7a37e6bf8" } }] + +[[packages]] +name = "nvidia-cufft-cu12" +version = "11.3.3.83" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/1f/13/ee4e00f30e676b66ae65b4f08cb5bcbb8392c03f54f2d5413ea99a5d1c80/nvidia_cufft_cu12-11.3.3.83-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-03-07T01:45:27Z, size = 193118695, hashes = { sha256 = "4d2dd21ec0b88cf61b62e6b43564355e5222e4a3fb394cac0db101f2dd0d4f74" } }] + +[[packages]] +name = "nvidia-cufile-cu12" +version = "1.13.1.3" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/bb/fe/1bcba1dfbfb8d01be8d93f07bfc502c93fa23afa6fd5ab3fc7c1df71038a/nvidia_cufile_cu12-1.13.1.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-03-07T01:45:50Z, size = 1197834, hashes = { sha256 = "1d069003be650e131b21c932ec3d8969c1715379251f8d23a1860554b1cb24fc" } }] + +[[packages]] +name = "nvidia-curand-cu12" +version = "10.3.9.90" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/fb/aa/6584b56dc84ebe9cf93226a5cde4d99080c8e90ab40f0c27bda7a0f29aa1/nvidia_curand_cu12-10.3.9.90-py3-none-manylinux_2_27_x86_64.whl", upload-time = 2025-03-07T01:46:23Z, size = 63619976, hashes = { sha256 = "b32331d4f4df5d6eefa0554c565b626c7216f87a06a4f56fab27c3b68a830ec9" } }] + +[[packages]] +name = "nvidia-cusolver-cu12" +version = "11.7.3.90" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/85/48/9a13d2975803e8cf2777d5ed57b87a0b6ca2cc795f9a4f59796a910bfb80/nvidia_cusolver_cu12-11.7.3.90-py3-none-manylinux_2_27_x86_64.whl", upload-time = 2025-03-07T01:47:16Z, size = 267506905, hashes = { sha256 = "4376c11ad263152bd50ea295c05370360776f8c3427b30991df774f9fb26c450" } }] + +[[packages]] +name = "nvidia-cusparse-cu12" +version = "12.5.8.93" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/c2/f5/e1854cb2f2bcd4280c44736c93550cc300ff4b8c95ebe370d0aa7d2b473d/nvidia_cusparse_cu12-12.5.8.93-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-03-07T01:48:13Z, size = 288216466, hashes = { sha256 = "1ec05d76bbbd8b61b06a80e1eaf8cf4959c3d4ce8e711b65ebd0443bb0ebb13b" } }] + +[[packages]] +name = "nvidia-cusparselt-cu12" +version = "0.7.1" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/56/79/12978b96bd44274fe38b5dde5cfb660b1d114f70a65ef962bcbbed99b549/nvidia_cusparselt_cu12-0.7.1-py3-none-manylinux2014_x86_64.whl", upload-time = 2025-02-26T00:15:44Z, size = 287193691, hashes = { sha256 = "f1bb701d6b930d5a7cea44c19ceb973311500847f81b634d802b7b539dc55623" } }] + +[[packages]] +name = "nvidia-cutlass-dsl" +version = "4.8.1" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/bd/ce/a590b929285faf0aa285c5ccee2b88e0b5259fb39a6326206e0f140ea3fc/nvidia_cutlass_dsl-4.8.1-py3-none-any.whl", upload-time = 2026-10-16T10:54:15Z, size = 10510, hashes = { sha256 = "43ed46b21d151aa643c6765457c7310827b938c1cf45d5109a0152de4ef06227" } }] + +[[packages]] +name = "nvidia-cutlass-dsl-libs-base" +version = "4.8.1" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/28/97/d8212f685544dc7208d78186128dc8a454158b1817a76b34d25392b9f910/nvidia_cutlass_dsl_libs_base-4.8.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-10-16T08:39:52Z, size = 3050567, hashes = { sha256 = "ac2fd8c7fa3d6ded00917fa7cba8686061005da8c4703c6a29e03c1504543909" } }] + +[[packages]] +name = "nvidia-cutlass-dsl-libs-core" +version = "4.8.1" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/6c/03/1c59e3caf7c8b5cae3ae4d1753201c7e64d36cdf182fb882e070b0f14a55/nvidia_cutlass_dsl_libs_core-4.8.1-py3-none-any.whl", upload-time = 2026-10-16T08:35:00Z, size = 1635096, hashes = { sha256 = "bacc6760e3286db447d45720d32ae58ac2e6cecade1152345ef784b2d5e44431" } }] + +[[packages]] +name = "nvidia-cutlass-dsl-libs-cu12" +version = "4.8.1" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/11/f4/a4f35a52b8a495b5dd3ad7b466567b3dbec656442811085ca1cb7d4a1d97/nvidia_cutlass_dsl_libs_cu12-4.8.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-10-16T10:41:51Z, size = 91697915, hashes = { sha256 = "440b88739120c65d96c5f15bbe496a3bd7c26392874d5af6061d38497f84c70c" } }] + +[[packages]] +name = "nvidia-cutlass-dsl-libs-cu13" +version = "4.8.1" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/a1/f2/0497bd834c92c8f30d6927388a91903e8e995ab7d1b5cbead87f0fd7187f/nvidia_cutlass_dsl_libs_cu13-4.8.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-10-16T10:48:43Z, size = 91954433, hashes = { sha256 = "50191a381d8cc1393373ae0bc879b0aefa9a256c23c22d4fa1c2fe3dfe57bc90" } }] + +[[packages]] +name = "nvidia-ml-py" +version = "13.595.45" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ce/49/c29f6e30d8662d2e94fef17739ea7309cc76aba269922ae999e4cc07f268/nvidia_ml_py-13.595.45.tar.gz", upload-time = 2026-03-19T16:59:44Z, size = 50780, hashes = { sha256 = "c9f34897fe0441ff35bc8f35baf80f830a20b0f4e6ce71e0a325bc0e66acf079" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8a/24/fc256107d23597fa33d319505ce77160fa1a2349c096d01901ffc7cb7fc4/nvidia_ml_py-13.595.45-py3-none-any.whl", upload-time = 2026-03-19T16:59:43Z, size = 51776, hashes = { sha256 = "b65a7977f503d56154b14d683710125ef93594adb63fbf7e559336e3318f1376" } }] + +[[packages]] +name = "nvidia-nccl-cu12" +version = "2.27.5" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/6e/89/f7a07dc961b60645dbbf42e80f2bc85ade7feb9a491b11a1e973aa00071f/nvidia_nccl_cu12-2.27.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-06-26T04:11:28Z, size = 322348229, hashes = { sha256 = "ad730cf15cb5d25fe849c6e6ca9eb5b76db16a80f13f425ac68d8e2e55624457" } }] + +[[packages]] +name = "nvidia-nvjitlink-cu12" +version = "12.8.93" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/f6/74/86a07f1d0f42998ca31312f998bd3b9a7eff7f52378f4f270c8679c77fb9/nvidia_nvjitlink_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", upload-time = 2025-03-07T01:49:55Z, size = 39254836, hashes = { sha256 = "81ff63371a7ebd6e6451970684f916be2eab07321b73c9d244dc2b4da7f73b88" } }] + +[[packages]] +name = "nvidia-nvshmem-cu12" +version = "3.3.20" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/3b/6c/99acb2f9eb85c29fc6f3a7ac4dccfd992e22666dd08a642b303311326a97/nvidia_nvshmem_cu12-3.3.20-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-08-04T20:25:19Z, size = 124657145, hashes = { sha256 = "d00f26d3f9b2e3c3065be895e3059d6479ea5c638a3f38c9fec49b1b9dd7c1e5" } }] + +[[packages]] +name = "nvidia-nvtx-cu12" +version = "12.8.90" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/a2/eb/86626c1bbc2edb86323022371c39aa48df6fd8b0a1647bc274577f72e90b/nvidia_nvtx_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-03-07T01:42:44Z, size = 89954, hashes = { sha256 = "5b17e2001cc0d751a5bc2c6ec6d26ad95913324a4adb86788c944f8ce9ba441f" } }] + +[[packages]] +name = "openai" +version = "2.6.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/c4/44/303deb97be7c1c9b53118b52825cbd1557aeeff510f3a52566b1fa66f6a2/openai-2.6.1.tar.gz", upload-time = 2025-10-24T13:29:52Z, size = 593043, hashes = { sha256 = "27ae704d190615fca0c0fc2b796a38f8b5879645a3a52c9c453b23f97141bb49" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/15/0e/331df43df633e6105ff9cf45e0ce57762bd126a45ac16b25a43f6738d8a2/openai-2.6.1-py3-none-any.whl", upload-time = 2025-10-24T13:29:50Z, size = 1005551, hashes = { sha256 = "904e4b5254a8416746a2f05649594fa41b19d799843cd134dac86167e094edef" } }] + +[[packages]] +name = "openai-harmony" +version = "0.0.4" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/92/94/01509d510bebf6606614e51113e5a415ced15b8f34aa98a8bf2539314650/openai_harmony-0.0.4.tar.gz", upload-time = 2025-08-09T01:43:24Z, size = 279848, hashes = { sha256 = "5c67ac6df349236fb7b64f57c3dbb0273efcdca24314daa108f2a482c427106c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1f/ec/dcdcace0ffcf3a532cca910e0c351b62d3a7decf0b091ea8cf856d2a67a6/openai_harmony-0.0.4-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-08-09T01:43:11Z, size = 3049306, hashes = { sha256 = "31e9bcac0902a309e2fc688e52f247eec7fffcd00d17e958b9a83a8fea6519c2" } }] + +[[packages]] +name = "opentelemetry-api" +version = "1.41.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/fa/fc/b7564cbef36601aef0d6c9bc01f7badb64be8e862c2e1c3c5c3b43b53e4f/opentelemetry_api-1.41.1.tar.gz", upload-time = 2026-04-24T13:15:38Z, size = 71416, hashes = { sha256 = "0ad1814d73b875f84494387dae86ce0b12c68556331ce6ce8fe789197c949621" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/29/59/3e7118ed140f76b0982ba4321bdaed1997a0473f9720de2d10788a577033/opentelemetry_api-1.41.1-py3-none-any.whl", upload-time = 2026-04-24T13:15:15Z, size = 69007, hashes = { sha256 = "a22df900e75c76dc08440710e51f52f1aa6b451b429298896023e60db5b3139f" } }] + +[[packages]] +name = "orjson" +version = "3.11.8" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/9d/1b/2024d06792d0779f9dbc51531b61c24f76c75b9f4ce05e6f3377a1814cea/orjson-3.11.8.tar.gz", upload-time = 2026-03-31T16:16:27Z, size = 5603832, hashes = { sha256 = "96163d9cdc5a202703e9ad1b9ae757d5f0ca62f4fa0cc93d1f27b0e180cc404e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/37/87/5ddeb7fc1fbd9004aeccab08426f34c81a5b4c25c7061281862b015fce2b/orjson-3.11.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-03-31T16:15:22Z, size = 133624, hashes = { sha256 = "53a0f57e59a530d18a142f4d4ba6dfc708dc5fdedce45e98ff06b44930a2a48f" } }] + +[[packages]] +name = "outlines" +version = "0.1.11" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ac/d0/d59ae830bf7026425942899e3d48e77b58a713cff946a695e5405808da1b/outlines-0.1.11.tar.gz", upload-time = 2024-12-13T07:24:08Z, size = 2488858, hashes = { sha256 = "0997bd9da1cc050e430bd08995dc7d4bd855918bafa4531e49d3f37110a23aba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/13/b4/99ea4a122bef60e3fd6402d19665aff1f928e0daf8fac3044d0b73f72003/outlines-0.1.11-py3-none-any.whl", upload-time = 2024-12-13T07:24:05Z, size = 87623, hashes = { sha256 = "f5a5f2242ed9802d3aab7a92789bf4008d734c576be9258cc0a297f690124727" } }] + +[[packages]] +name = "outlines-core" +version = "0.1.26" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/d3/f3/274d07f4702728b43581235a77e545ec602b25f9b0098b288a0f3052521d/outlines_core-0.1.26.tar.gz", upload-time = 2024-12-12T23:38:50Z, size = 75139, hashes = { sha256 = "481c4301341e77cc8f1832d616784adb4d461b4fec65878e7c0d2cba7163a189" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e2/1d/a36292b6198986bd9c3ff8c24355deb82ed5475403379ee40b5b5473e2e3/outlines_core-0.1.26-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2024-12-12T23:38:34Z, size = 343201, hashes = { sha256 = "e86a1bb46adc5cbf6dfd7a7fe4105e0e2a4c6e041732a053126b41c521a1f223" } }] + +[[packages]] +name = "packaging" +version = "24.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", upload-time = 2024-11-08T09:47:47Z, size = 163950, hashes = { sha256 = "c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", upload-time = 2024-11-08T09:47:44Z, size = 65451, hashes = { sha256 = "09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759" } }] + +[[packages]] +name = "pandas" +version = "2.3.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", upload-time = 2025-09-29T23:34:51Z, size = 4495223, hashes = { sha256 = "e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e5/63/cd7d615331b328e287d8233ba9fdf191a9c2d11b6af0c7a59cfcec23de68/pandas-2.3.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-09-29T23:20:14Z, size = 12362693, hashes = { sha256 = "b3d11d2fda7eb164ef27ffc14b4fcab16a80e1ce67e9f57e19ec0afaf715ba89" } }] + +[[packages]] +name = "parso" +version = "0.8.6" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/81/76/a1e769043c0c0c9fe391b702539d594731a4362334cdf4dc25d0c09761e7/parso-0.8.6.tar.gz", upload-time = 2026-02-09T15:45:24Z, size = 401621, hashes = { sha256 = "2b9a0332696df97d454fa67b81618fd69c35a7b90327cbe6ba5c92d2c68a7bfd" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b6/61/fae042894f4296ec49e3f193aff5d7c18440da9e48102c3315e1bc4519a7/parso-0.8.6-py2.py3-none-any.whl", upload-time = 2026-02-09T15:45:21Z, size = 106894, hashes = { sha256 = "2c549f800b70a5c4952197248825584cb00f033b29c692671d3bf08bf380baff" } }] + +[[packages]] +name = "partial-json-parser" +version = "0.2.1.1.post7" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/6a/6d/eed37d7ebc1e0bcd27b831c0cf1fe94881934316187c4b30d23f29ea0bd4/partial_json_parser-0.2.1.1.post7.tar.gz", upload-time = 2025-11-17T07:27:41Z, size = 10296, hashes = { sha256 = "86590e1ba6bcb6739a2dfc17d2323f028cb5884f4c6ce23db376999132c9a922" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/42/32/658973117bf0fd82a24abbfb94fe73a5e86216e49342985e10acce54775a/partial_json_parser-0.2.1.1.post7-py3-none-any.whl", upload-time = 2025-11-17T07:27:40Z, size = 10877, hashes = { sha256 = "145119e5eabcf80cbb13844a6b50a85c68bf99d376f8ed771e2a3c3b03e653ae" } }] + +[[packages]] +name = "pexpect" +version = "4.9.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", upload-time = 2023-11-25T09:07:26Z, size = 166450, hashes = { sha256 = "ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", upload-time = 2023-11-25T06:56:14Z, size = 63772, hashes = { sha256 = "7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523" } }] + +[[packages]] +name = "pillow" +version = "12.3.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/1c/3d/bb7fca845737cf9d7dbde16ed1843984665ff2e0a518f5db43e77ec540b9/pillow-12.3.0.tar.gz", upload-time = 2026-07-01T11:56:38Z, size = 47025035, hashes = { sha256 = "3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/84/21/a35af28dcc61f37ed850a2d64c65c701321dfbf25085e469d5559360cbbf/pillow-12.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-01T11:54:13Z, size = 6940830, hashes = { sha256 = "78cb2c6865a35ab8ff8b75fd122f6033b92a62c82801110e48ddd6c936a45d91" } }] + +[[packages]] +name = "prometheus-client" +version = "0.26.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/52/73/f1334c29c2af4cd9dba6c7817e61b611bd0215e2eb5565c6064a4de18802/prometheus_client-0.26.0.tar.gz", upload-time = 2026-07-24T19:36:41Z, size = 92910, hashes = { sha256 = "04a91bcf94e2cf74a44a1a874d651a2e853ed354b6e822f3b7487751465d5c2b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/eb/a3/b69efbf4143b5b9859b977770bbbabcc2796b702fa69dc40271e45cd5a56/prometheus_client-0.26.0-py3-none-any.whl", upload-time = 2026-07-24T19:36:40Z, size = 64494, hashes = { sha256 = "fa93d06737aa02bacd05794768508bb97d2fbee28cb3bca04eaae92f0ca953d6" } }] + +[[packages]] +name = "prompt-toolkit" +version = "3.0.52" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", upload-time = 2025-08-27T15:24:02Z, size = 434198, hashes = { sha256 = "28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", upload-time = 2025-08-27T15:23:59Z, size = 391431, hashes = { sha256 = "9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955" } }] + +[[packages]] +name = "propcache" +version = "0.4.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", upload-time = 2025-10-08T19:49:02Z, size = 46442, hashes = { sha256 = "f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/46/4b/3aae6835b8e5f44ea6a68348ad90f78134047b503765087be2f9912140ea/propcache-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-10-08T19:46:54Z, size = 221575, hashes = { sha256 = "15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf" } }, + { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", upload-time = 2025-10-08T19:49:00Z, size = 13305, hashes = { sha256 = "af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237" } }, +] + +[[packages]] +name = "protobuf" +version = "6.33.6" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/66/70/e908e9c5e52ef7c3a6c7902c9dfbb34c7e29c25d2f81ade3856445fd5c94/protobuf-6.33.6.tar.gz", upload-time = 2026-03-18T19:05:00Z, size = 444531, hashes = { sha256 = "a6768d25248312c297558af96a9f9c929e8c4cee0659cb07e780731095f38135" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/16/92/d1e32e3e0d894fe00b15ce28ad4944ab692713f2e7f0a99787405e43533a/protobuf-6.33.6-cp39-abi3-manylinux2014_x86_64.whl", upload-time = 2026-03-18T19:04:55Z, size = 323436, hashes = { sha256 = "e9db7e292e0ab79dd108d7f1a94fe31601ce1ee3f7b79e0692043423020b0593" } }, + { url = "https://files.pythonhosted.org/packages/c4/72/02445137af02769918a93807b2b7890047c32bfb9f90371cbc12688819eb/protobuf-6.33.6-py3-none-any.whl", upload-time = 2026-03-18T19:04:59Z, size = 170656, hashes = { sha256 = "77179e006c476e69bf8e8ce866640091ec42e1beb80b213c3900006ecfba6901" } }, +] + +[[packages]] +name = "psutil" +version = "7.2.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", upload-time = 2026-01-28T18:14:54Z, size = 493740, hashes = { sha256 = "0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-01-28T18:15:25Z, size = 155560, hashes = { sha256 = "076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9" } }] + +[[packages]] +name = "ptyprocess" +version = "0.7.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", upload-time = 2020-12-28T15:15:30Z, size = 70762, hashes = { sha256 = "5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", upload-time = 2020-12-28T15:15:28Z, size = 13993, hashes = { sha256 = "4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35" } }] + +[[packages]] +name = "pure-eval" +version = "0.2.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", upload-time = 2024-07-21T12:58:21Z, size = 19752, hashes = { sha256 = "5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", upload-time = 2024-07-21T12:58:20Z, size = 11842, hashes = { sha256 = "1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0" } }] + +[[packages]] +name = "py-spy" +version = "0.4.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/93/d8/5b71371f50cf153b1307e5a11ac8a4ce4d85651dae946bd7e9a064146545/py_spy-0.4.2.tar.gz", upload-time = 2026-04-24T22:08:54Z, size = 286374, hashes = { sha256 = "90e600b27bb6bb40479637baca5a5b4bc2ba3395c93d889e672315d93042c4ae" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f9/34/dd7d3c763a00b7b965e25a5eab0acd1a345dbaf0f45fffe595278873a1c0/py_spy-0.4.2-py2.py3-none-manylinux_2_5_x86_64.manylinux1_x86_64.whl", upload-time = 2026-04-24T22:08:52Z, size = 2936518, hashes = { sha256 = "aeb0323409199c785f730645e9f4bb7a7b9ca2c481f2c331a55642b5d13fa52f" } }] + +[[packages]] +name = "pyarrow" +version = "23.0.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/88/22/134986a4cc224d593c1afde5494d18ff629393d74cc2eddb176669f234a4/pyarrow-23.0.1.tar.gz", upload-time = 2026-02-16T10:14:12Z, size = 1167336, hashes = { sha256 = "b8c5873e33440b2bc2f4a79d2b47017a89c5a24116c055625e6f2ee50523f019" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2c/a5/da83046273d990f256cb79796a190bbf7ec999269705ddc609403f8c6b06/pyarrow-23.0.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-02-16T10:10:17Z, size = 47586063, hashes = { sha256 = "813d99f31275919c383aab17f0f455a04f5a429c261cc411b1e9a8f5e4aaaa05" } }] + +[[packages]] +name = "pybase64" +version = "1.4.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/aa/b8/4ed5c7ad5ec15b08d35cc79ace6145d5c1ae426e46435f4987379439dfea/pybase64-1.4.3.tar.gz", upload-time = 2025-12-06T13:27:04Z, size = 137272, hashes = { sha256 = "c2ed274c9e0ba9c8f9c4083cfe265e66dd679126cd9c2027965d807352f3f053" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/62/f7/965b79ff391ad208b50e412b5d3205ccce372a2d27b7218ae86d5295b105/pybase64-1.4.3-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2025-12-06T13:23:20Z, size = 71599, hashes = { sha256 = "bb632edfd132b3eaf90c39c89aa314beec4e946e210099b57d40311f704e11d4" } }] + +[[packages]] +name = "pycountry" +version = "26.2.16" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/de/1d/061b9e7a48b85cfd69f33c33d2ef784a531c359399ad764243399673c8f5/pycountry-26.2.16.tar.gz", upload-time = 2026-02-17T03:42:52Z, size = 7711342, hashes = { sha256 = "5b6027d453fcd6060112b951dd010f01f168b51b4bf8a1f1fc8c95c8d94a0801" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9c/42/7703bd45b62fecd44cd7d3495423097e2f7d28bc2e99e7c1af68892ab157/pycountry-26.2.16-py3-none-any.whl", upload-time = 2026-02-17T03:42:49Z, size = 8044600, hashes = { sha256 = "115c4baf7cceaa30f59a4694d79483c9167dbce7a9de4d3d571c5f3ea77c305a" } }] + +[[packages]] +name = "pycparser" +version = "3.0" +marker = "implementation_name != 'PyPy' and sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", upload-time = 2026-01-21T14:26:51Z, size = 103492, hashes = { sha256 = "600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", upload-time = 2026-01-21T14:26:50Z, size = 48172, hashes = { sha256 = "b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992" } }] + +[[packages]] +name = "pycryptodomex" +version = "3.24.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/f4/e7/50e72301e32acb73a314e663c2014e1ddefc019d5f434ff14ec89861d664/pycryptodomex-3.24.1.tar.gz", upload-time = 2026-10-11T19:26:49Z, size = 4934627, hashes = { sha256 = "09081666ffc599976c0b8b29caf2cf82212c0f05bed233c8f8ed53e4f6e1d356" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/cf/93/a954b7a8746980e31648943e29772aca0311d0d8a407a3adf5788083b693/pycryptodomex-3.24.1-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-10-11T19:26:17Z, size = 2280275, hashes = { sha256 = "9b94a8c647c1f80b4c82c7ac9642dda94a71abbb4efa29ad652c410ad7a39879" } }] + +[[packages]] +name = "pydantic" +version = "2.12.5" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", upload-time = 2025-11-26T15:11:46Z, size = 821591, hashes = { sha256 = "4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", upload-time = 2025-11-26T15:11:44Z, size = 463580, hashes = { sha256 = "e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d" } }] + +[[packages]] +name = "pydantic-core" +version = "2.41.5" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", upload-time = 2025-11-04T13:43:49Z, size = 460952, hashes = { sha256 = "08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-04T13:40:09Z, size = 2075366, hashes = { sha256 = "eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c" } }] + +[[packages]] +name = "pydantic-extra-types" +version = "2.11.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/66/71/dba38ee2651f84f7842206adbd2233d8bbdb59fb85e9fa14232486a8c471/pydantic_extra_types-2.11.1.tar.gz", upload-time = 2026-03-16T08:08:03Z, size = 172002, hashes = { sha256 = "46792d2307383859e923d8fcefa82108b1a141f8a9c0198982b3832ab5ef1049" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/17/c1/3226e6d7f5a4f736f38ac11a6fbb262d701889802595cdb0f53a885ac2e0/pydantic_extra_types-2.11.1-py3-none-any.whl", upload-time = 2026-03-16T08:08:02Z, size = 79526, hashes = { sha256 = "1722ea2bddae5628ace25f2aa685b69978ef533123e5638cfbddb999e0100ec1" } }] + +[[packages]] +name = "pygments" +version = "2.20.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", upload-time = 2026-03-29T13:29:33Z, size = 4955991, hashes = { sha256 = "6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", upload-time = 2026-03-29T13:29:30Z, size = 1231151, hashes = { sha256 = "81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176" } }] + +[[packages]] +name = "pyproject-hooks" +version = "1.2.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/e7/82/28175b2414effca1cdac8dc99f76d660e7a4fb0ceefa4b4ab8f5f6742925/pyproject_hooks-1.2.0.tar.gz", upload-time = 2024-09-29T09:24:13Z, size = 19228, hashes = { sha256 = "1e859bd5c40fae9448642dd871adf459e5e2084186e8d2c2a79a824c970da1f8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/bd/24/12818598c362d7f300f18e74db45963dbcb85150324092410c8b49405e42/pyproject_hooks-1.2.0-py3-none-any.whl", upload-time = 2024-09-29T09:24:11Z, size = 10216, hashes = { sha256 = "9e5c6bfa8dcc30091c74b0cf803c81fdd29d94f01992a7707bc97babb1141913" } }] + +[[packages]] +name = "python-dateutil" +version = "2.9.0.post0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", upload-time = 2024-03-01T18:36:20Z, size = 342432, hashes = { sha256 = "37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", upload-time = 2024-03-01T18:36:18Z, size = 229892, hashes = { sha256 = "a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427" } }] + +[[packages]] +name = "python-multipart" +version = "0.0.32" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/5b/42/55c32bb9b12693c092ad250a0e82edb5b31ddeda6eb772de5f308b3804ad/python_multipart-0.0.32.tar.gz", upload-time = 2026-06-04T16:18:58Z, size = 46881, hashes = { sha256 = "be54b7f3fa167bb83e4fcd936b887b708f4e57fe75911c02aebf53efaf8d938e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e1/04/e8135ebd1ad02c56ec633277529b2602ff99ff634be76cdba5744cf554fd/python_multipart-0.0.32-py3-none-any.whl", upload-time = 2026-06-04T16:18:57Z, size = 30042, hashes = { sha256 = "ff6d3f776f16878c894e52e107296ffc890e913c611b1a4ec6c44e2821fe2e23" } }] + +[[packages]] +name = "pytz" +version = "2026.1.post1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/56/db/b8721d71d945e6a8ac63c0fc900b2067181dbb50805958d4d4661cf7d277/pytz-2026.1.post1.tar.gz", upload-time = 2026-03-03T07:47:50Z, size = 321088, hashes = { sha256 = "3378dde6a0c3d26719182142c56e60c7f9af7e968076f31aae569d72a0358ee1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/10/99/781fe0c827be2742bcc775efefccb3b048a3a9c6ce9aec0cbf4a101677e5/pytz-2026.1.post1-py2.py3-none-any.whl", upload-time = 2026-03-03T07:47:49Z, size = 510489, hashes = { sha256 = "f2fd16142fda348286a75e1a524be810bb05d444e5a081f37f7affc635035f7a" } }] + +[[packages]] +name = "pyyaml" +version = "6.0.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", upload-time = 2025-09-25T21:33:16Z, size = 130960, hashes = { sha256 = "d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-09-25T21:32:16Z, size = 807870, hashes = { sha256 = "ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc" } }] + +[[packages]] +name = "pyzmq" +version = "27.2.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/e7/8d/5b3d5631c2f4b4b8862f64cd0c9eb777b5710eeb5125b4be8dd0a200a4c0/pyzmq-27.2.0.tar.gz", upload-time = 2026-08-20T19:08:21Z, size = 292316, hashes = { sha256 = "54d4259d1bfae24ecdb5ca79f7acc2eac6c286a02d6a0ae617797cb45f0726d3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/62/2c/d5828306f795e8d34676d266823b74e2101e0ad3760d12083de3e02abbb2/pyzmq-27.2.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-08-20T19:06:44Z, size = 872258, hashes = { sha256 = "dea74fd65f1fc5f7fe167916a473ebe6ed6174e5e5d9de11ea6583661be6cf43" } }] + +[[packages]] +name = "quack-kernels" +version = "0.6.5" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/5f/18/6c2a20d00dff254f154fb3b951f4e5a0377a60122c17385e5f08d5f5b5e1/quack_kernels-0.6.5.tar.gz", upload-time = 2026-09-11T05:08:20Z, size = 846876, hashes = { sha256 = "dd9405a4a6fa35fc3a5a18fe35b46a14b0bf7e3ad9fe2451903e355047ac471d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/73/d8/f5e56c38b286308d115a171e3c5c44f24e9d03980c3cfd22588df40261fa/quack_kernels-0.6.5-py3-none-any.whl", upload-time = 2026-09-11T05:08:19Z, size = 729615, hashes = { sha256 = "df1ddd31366c82eb9692fe087c671209189dcbde53c909c81a865d4ee66b158d" } }] + +[[packages]] +name = "referencing" +version = "0.37.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", upload-time = 2025-10-13T15:30:48Z, size = 78036, hashes = { sha256 = "44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", upload-time = 2025-10-13T15:30:47Z, size = 26766, hashes = { sha256 = "381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231" } }] + +[[packages]] +name = "regex" +version = "2026.4.4" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/cb/0e/3a246dbf05666918bd3664d9d787f84a9108f6f43cc953a077e4a7dfdb7e/regex-2026.4.4.tar.gz", upload-time = 2026-04-03T20:56:28Z, size = 416000, hashes = { sha256 = "e08270659717f6973523ce3afbafa53515c4dc5dcad637dc215b6fd50f689423" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/11/0e/a9f6f81013e0deaf559b25711623864970fe6a098314e374ccb1540a4152/regex-2026.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-03T20:53:51Z, size = 801126, hashes = { sha256 = "993f657a7c1c6ec51b5e0ba97c9817d06b84ea5fa8d82e43b9405de0defdc2b9" } }] + +[[packages]] +name = "requests" +version = "2.33.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/5f/a4/98b9c7c6428a668bf7e42ebb7c79d576a1c3c1e3ae2d47e674b468388871/requests-2.33.1.tar.gz", upload-time = 2026-03-30T16:09:15Z, size = 134120, hashes = { sha256 = "18817f8c57c6263968bc123d237e3b8b08ac046f5456bd1e307ee8f4250d3517" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", upload-time = 2026-03-30T16:09:13Z, size = 64947, hashes = { sha256 = "4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a" } }] + +[[packages]] +name = "rich" +version = "13.9.4" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", upload-time = 2024-11-01T16:43:57Z, size = 223149, hashes = { sha256 = "439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", upload-time = 2024-11-01T16:43:55Z, size = 242424, hashes = { sha256 = "6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90" } }] + +[[packages]] +name = "rpds-py" +version = "0.30.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", upload-time = 2025-11-30T20:24:38Z, size = 69469, hashes = { sha256 = "dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/60/1b/6f8f29f3f995c7ffdde46a626ddccd7c63aefc0efae881dc13b6e5d5bb16/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-30T20:22:27Z, size = 394080, hashes = { sha256 = "47f236970bccb2233267d89173d3ad2703cd36a0e2a6e92d0560d333871a3d23" } }] + +[[packages]] +name = "safetensors" +version = "0.7.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/29/9c/6e74567782559a63bd040a236edca26fd71bc7ba88de2ef35d75df3bca5e/safetensors-0.7.0.tar.gz", upload-time = 2025-11-19T15:18:43Z, size = 200878, hashes = { sha256 = "07663963b67e8bd9f0b8ad15bb9163606cd27cc5a1b96235a50d8369803b96b0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a0/60/429e9b1cb3fc651937727befe258ea24122d9663e4d5709a48c9cbfceecb/safetensors-0.7.0-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-19T15:18:33Z, size = 507152, hashes = { sha256 = "dac7252938f0696ddea46f5e855dd3138444e82236e3be475f54929f0c510d48" } }] + +[[packages]] +name = "scipy" +version = "1.17.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", upload-time = 2026-02-23T00:26:24Z, size = 30573822, hashes = { sha256 = "95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/01/8e/1e35281b8ab6d5d72ebe9911edcdffa3f36b04ed9d51dec6dd140396e220/scipy-1.17.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-02-23T00:18:49Z, size = 35235890, hashes = { sha256 = "02ae3b274fde71c5e92ac4d54bc06c42d80e399fec704383dcd99b301df37458" } }] + +[[packages]] +name = "sentencepiece" +version = "0.2.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/15/15/2e7a025fc62d764b151ae6d0f2a92f8081755ebe8d4a64099accc6f77ba6/sentencepiece-0.2.1.tar.gz", upload-time = 2025-08-12T07:00:51Z, size = 3228515, hashes = { sha256 = "8138cec27c2f2282f4a34d9a016e3374cd40e5c6e9cb335063db66a0a3b71fad" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/04/88/14f2f4a2b922d8b39be45bf63d79e6cd3a9b2f248b2fcb98a69b12af12f5/sentencepiece-0.2.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-08-12T06:59:46Z, size = 1387881, hashes = { sha256 = "0cdfecef430d985f1c2bcbfff3defd1d95dae876fbd0173376012d2d7d24044b" } }] + +[[packages]] +name = "setproctitle" +version = "1.3.8" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/49/b0/6b8a516c5a9e9630bd5293db78314ac012f690305fe93beadea388626efb/setproctitle-1.3.8.tar.gz", upload-time = 2026-10-01T21:09:27Z, size = 27214, hashes = { sha256 = "cafe209d064a6efb88cb45a03e97981ff8832802b2b5d009dde0197a3b7b41c8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/cb/21/4df9fbc0c72b9bca39b5d53eff6813dc1738a1562983e0c614054e9dbb8d/setproctitle-1.3.8-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2026-10-01T20:59:09Z, size = 32929, hashes = { sha256 = "4a765e0c80a2453480be27c4fc22ba1c0771867040c5f91e4221940d78a4abfb" } }] + +[[packages]] +name = "setuptools" +version = "83.0.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/34/26/f5d29e25ffdb535afef2d35cdb55b325298f96debd670da4c325e08d70f4/setuptools-83.0.0.tar.gz", upload-time = 2026-07-04T15:31:22Z, size = 1154254, hashes = { sha256 = "025bccbbf0fa05b6192bc64ae1e7b16e001fd6d6d4d5de03c97b1c1ade523bef" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5d/40/e1e72872c6354b306daef1703549e8e83b4d43cfea356311bf722a043752/setuptools-83.0.0-py3-none-any.whl", upload-time = 2026-07-04T15:31:20Z, size = 1008090, hashes = { sha256 = "29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3" } }] + +[[packages]] +name = "sglang" +version = "0.5.10.post1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/42/38/feb04f6478b90315606fcd62b798917e7fcee9f1d7d84b01cf477398045e/sglang-0.5.10.post1.tar.gz", upload-time = 2026-04-08T22:20:07Z, size = 4701855, hashes = { sha256 = "01f7adfe7cde85b238fb0e1bae4b31d494e19d1471cf35ff3c5489a02f9d2263" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/15/26/f6b6fc49166a716cf79787555118dfe6254786fa1d9c01be0fea17b4f578/sglang-0.5.10.post1-py3-none-any.whl", upload-time = 2026-04-08T22:20:05Z, size = 6064493, hashes = { sha256 = "a854a68b11caf6b4b55c241a44378a7cdede7ede325db85c955f131506703bc6" } }] + +[[packages]] +name = "sglang-kernel" +version = "0.4.1" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/97/26/d4a84be6587b57d20214cc2ee1e7f41b7e3336df357c45a833f25b1f1abf/sglang_kernel-0.4.1-cp310-abi3-manylinux2014_x86_64.whl", upload-time = 2026-04-03T09:28:02Z, size = 352149358, hashes = { sha256 = "64ab5df34264cdffc36e25fee429dcafe2e204cae73cc1f9736a4e5ab97aa206" } }] + +[[packages]] +name = "shellingham" +version = "1.5.4" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", upload-time = 2023-10-24T04:13:40Z, size = 10310, hashes = { sha256 = "8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", upload-time = 2023-10-24T04:13:38Z, size = 9755, hashes = { sha256 = "7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686" } }] + +[[packages]] +name = "six" +version = "1.17.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", upload-time = 2024-12-04T17:35:28Z, size = 34031, hashes = { sha256 = "ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", upload-time = 2024-12-04T17:35:26Z, size = 11050, hashes = { sha256 = "4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274" } }] + +[[packages]] +name = "smg-grpc-proto" +version = "0.4.10" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/70/c4/e7fd91bf161fcaeb9c19e5fba73e54f7501bd310078d644700e627c4d7f9/smg_grpc_proto-0.4.10.tar.gz", upload-time = 2026-06-11T16:10:05Z, size = 19304, hashes = { sha256 = "5415618d252e5a2b43d1dbbd2c1eae305760070dd24735308140aed06a7486be" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/67/0d/d2f57ac38d2ecc9593ade6ee99953c2b2ea27e10e9532f69e3c47d2528dc/smg_grpc_proto-0.4.10-py3-none-any.whl", upload-time = 2026-06-11T16:10:04Z, size = 81122, hashes = { sha256 = "cf62b930b541ea117696d0decc2f3bd9f1f8811d066a37340e53adce3a535ccc" } }] + +[[packages]] +name = "smg-grpc-servicer" +version = "0.5.6" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/38/fa/fde2418c3e651bb20feba30ee13718cb4ac786a23c34969c5c7a9b0959ec/smg_grpc_servicer-0.5.6.tar.gz", upload-time = 2026-06-17T15:27:30Z, size = 88730, hashes = { sha256 = "b8e5f06a57537689888f67ea7a7d5b1f080038a3c8aada129098529245d185c0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/15/36/2b08a588c2b869ad072882883be4f31349beac6468b93db03f1608505796/smg_grpc_servicer-0.5.6-py3-none-any.whl", upload-time = 2026-06-17T15:27:29Z, size = 91597, hashes = { sha256 = "d583be1c1b6f5fa790b735feca21c870120d37d8b4d79b4641a4bf9c34203d97" } }] + +[[packages]] +name = "sniffio" +version = "1.3.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", upload-time = 2024-02-25T23:20:04Z, size = 20372, hashes = { sha256 = "f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", upload-time = 2024-02-25T23:20:01Z, size = 10235, hashes = { sha256 = "2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2" } }] + +[[packages]] +name = "soundfile" +version = "0.13.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/e1/41/9b873a8c055582859b239be17902a85339bec6a30ad162f98c9b0288a2cc/soundfile-0.13.1.tar.gz", upload-time = 2025-01-25T09:17:04Z, size = 46156, hashes = { sha256 = "b2c68dab1e30297317080a5b43df57e302584c49e2942defdde0acccc53f0e5b" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/28/e2a36573ccbcf3d57c00626a21fe51989380636e821b341d36ccca0c1c3a/soundfile-0.13.1-py2.py3-none-any.whl", upload-time = 2025-01-25T09:16:44Z, size = 25751, hashes = { sha256 = "a23c717560da2cf4c7b5ae1142514e0fd82d6bbd9dfc93a50423447142f2c445" } }, + { url = "https://files.pythonhosted.org/packages/57/5e/70bdd9579b35003a489fc850b5047beeda26328053ebadc1fb60f320f7db/soundfile-0.13.1-py2.py3-none-manylinux_2_28_x86_64.whl", upload-time = 2025-01-25T09:16:54Z, size = 1313646, hashes = { sha256 = "03267c4e493315294834a0870f31dbb3b28a95561b80b134f0bd3cf2d5f0e618" } }, +] + +[[packages]] +name = "stack-data" +version = "0.6.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", upload-time = 2023-09-30T13:58:05Z, size = 44707, hashes = { sha256 = "836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", upload-time = 2023-09-30T13:58:03Z, size = 24521, hashes = { sha256 = "d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695" } }] + +[[packages]] +name = "starlette" +version = "1.3.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/eb/e3/7c1dc7381d9f8ab7d854328ebfa884e62cb3f3d8549ddfd37c7814f42afa/starlette-1.3.1.tar.gz", upload-time = 2026-06-12T09:23:11Z, size = 2703240, hashes = { sha256 = "05d0213193f2fbaae60e2ecb593b4add4262ad4e46536b54abe36f11a71724e0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ec/bb/2799cc2ede3ed41131f8975621e7213dfc7ef4acbbaadfa440f32500c370/starlette-1.3.1-py3-none-any.whl", upload-time = 2026-06-12T09:23:10Z, size = 73632, hashes = { sha256 = "c7372aae11c3c3f26a42df7bd626cec2f47d03483d261d369516a615a53714c6" } }] + +[[packages]] +name = "sympy" +version = "1.14.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", upload-time = 2025-04-27T18:05:01Z, size = 7793921, hashes = { sha256 = "d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", upload-time = 2025-04-27T18:04:59Z, size = 6299353, hashes = { sha256 = "e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5" } }] + +[[packages]] +name = "tabulate" +version = "0.10.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/46/58/8c37dea7bbf769b20d58e7ace7e5edfe65b849442b00ffcdd56be88697c6/tabulate-0.10.0.tar.gz", upload-time = 2026-03-04T18:55:34Z, size = 91754, hashes = { sha256 = "e2cfde8f79420f6deeffdeda9aaec3b6bc5abce947655d17ac662b126e48a60d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/99/55/db07de81b5c630da5cbf5c7df646580ca26dfaefa593667fc6f2fe016d2e/tabulate-0.10.0-py3-none-any.whl", upload-time = 2026-03-04T18:55:31Z, size = 39814, hashes = { sha256 = "f0b0622e567335c8fabaaa659f1b33bcb6ddfe2e496071b743aa113f8774f2d3" } }] + +[[packages]] +name = "tiktoken" +version = "0.12.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/7d/ab/4d017d0f76ec3171d469d80fc03dfbb4e48a4bcaddaa831b31d526f05edc/tiktoken-0.12.0.tar.gz", upload-time = 2025-10-06T20:22:45Z, size = 37806, hashes = { sha256 = "b18ba7ee2b093863978fcb14f74b3707cdc8d4d4d3836853ce7ec60772139931" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f4/90/3dae6cc5436137ebd38944d396b5849e167896fc2073da643a49f372dc4f/tiktoken-0.12.0-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2025-10-06T20:21:56Z, size = 1152665, hashes = { sha256 = "edde1ec917dfd21c1f2f8046b86348b0f54a2c0547f68149d8600859598769ad" } }] + +[[packages]] +name = "timm" +version = "1.0.16" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/94/f6/4d7a8c261341fa6ad281920618739f2a650f41043afcedb570f24e99a776/timm-1.0.16.tar.gz", upload-time = 2025-06-26T17:09:44Z, size = 2339999, hashes = { sha256 = "a3b8130dd2cb8dc3b9f5e3d09ab6d677a6315a8695fd5264eb6d52a4a46c1044" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3b/14/10d0ea58a7580b8bd7c8d69420b3dc3a1deb890d4ff297deca9717689598/timm-1.0.16-py3-none-any.whl", upload-time = 2025-06-26T17:09:42Z, size = 2485733, hashes = { sha256 = "a640e58f4ae41e0445517d1133b34be75bb2bd49cdb830d739925ce1fb7d2526" } }] + +[[packages]] +name = "tokenizers" +version = "0.22.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/73/6f/f80cfef4a312e1fb34baf7d85c72d4411afde10978d4657f8cdd811d3ccc/tokenizers-0.22.2.tar.gz", upload-time = 2026-01-05T10:45:15Z, size = 372115, hashes = { sha256 = "473b83b915e547aa366d1eee11806deaf419e17be16310ac0a14077f1e28f917" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2e/76/932be4b50ef6ccedf9d3c6639b056a967a86258c6d9200643f01269211ca/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-01-05T10:40:58Z, size = 3274982, hashes = { sha256 = "369cc9fc8cc10cb24143873a0d95438bb8ee257bb80c71989e3ee290e8d72c67" } }] + +[[packages]] +name = "torch" +version = "2.9.1" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/19/17/e377a460603132b00760511299fceba4102bd95db1a0ee788da21298ccff/torch-2.9.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2025-11-12T15:22:17Z, size = 899742281, hashes = { sha256 = "27331cd902fb4322252657f3902adf1c4f6acad9dcad81d8df3ae14c7c4f07c4" } }] + +[[packages]] +name = "torch-c-dlpack-ext" +version = "0.1.5" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/37/de/921b6491efce5c389a5ef9bbed3d2d6660005840dae488124173180859ab/torch_c_dlpack_ext-0.1.5.tar.gz", upload-time = 2026-01-12T11:25:08Z, size = 12913, hashes = { sha256 = "d06f0357d575d22a168cc77acb9020fc4bae30968ceb6718a055dcbe92bacabe" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e2/79/a914539b4785f3e44f891aa012a886edb8bc10fe081c440981c57543ce21/torch_c_dlpack_ext-0.1.5-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-01-12T11:24:48Z, size = 897846, hashes = { sha256 = "e6f9da4bb9af70e27facc777458be62e10dbbbddda7672d16138db0553c5a524" } }] + +[[packages]] +name = "torch-memory-saver" +version = "0.0.9" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/28/6c/21dfda5d31afb71f52cedff52370acbb8290485b3f0fee6816a15a3d08f1/torch_memory_saver-0.0.9.tar.gz", upload-time = 2025-10-18T02:10:18Z, size = 14220, hashes = { sha256 = "3bbf76391fb16870b1b0df279fc281c8a05ef8f8809400b309b0a8240e8ee5ba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3a/35/b22df9e730d8444d62445a594421992781c7fad271325d41656d8a32d103/torch_memory_saver-0.0.9-cp39-abi3-manylinux2014_x86_64.whl", upload-time = 2025-10-18T02:10:16Z, size = 488722, hashes = { sha256 = "0cf26332993649f8ea1b95d7307dfba3a95ee6cee53de84a3e561fb21752b584" } }] + +[[packages]] +name = "torchao" +version = "0.9.0" +marker = "sys_platform == 'linux'" +wheels = [ + { url = "https://files.pythonhosted.org/packages/7d/fe/a24225d30775192a4c5d9cea3ecb95e6adc69d0a8b5ed98eb8e58d362344/torchao-0.9.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-02-28T13:54:15Z, size = 5652091, hashes = { sha256 = "bc708910301a9f98344d43f3fe2aa6d5e1fab706d772b6df47ff05087d664145" } }, + { url = "https://files.pythonhosted.org/packages/db/72/01f755514fb61eadc80b974eb4bd4f22f3009b35457773523e3bd497c511/torchao-0.9.0-py3-none-any.whl", upload-time = 2025-02-28T13:54:13Z, size = 712541, hashes = { sha256 = "ea5603c32762f1a9ade1a4dc7b00f5246623b24a28e49e666f614c79a408712a" } }, +] + +[[packages]] +name = "torchaudio" +version = "2.9.1" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/fe/0d/b5af1d55ede1ca07769a2cf71256073d8958e2a5521fc734fc19f5343283/torchaudio-2.9.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2025-11-12T15:26:19Z, size = 2059899, hashes = { sha256 = "4533fdafba73d7bcfcb5f1225b2cc8974a290ed0fe54c44638d6f440e91b8999" } }] + +[[packages]] +name = "torchcodec" +version = "0.9.1" +marker = "platform_machine != 'aarch64' and platform_machine != 'arm64' and platform_machine != 'armv7l' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/17/c8/bfb74babec98aff11ab4f239b0901f39e1a93338b3438e842d864dc46935/torchcodec-0.9.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2025-12-10T15:55:33Z, size = 2061978, hashes = { sha256 = "a50568ce73b70395d113833fb07394c223f5546ef5d4fafe0fdcd91627fca270" } }] + +[[packages]] +name = "torchvision" +version = "0.24.1" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/93/b1/db2941526ecddd84884132e2742a55c9311296a6a38627f9e2627f5ac889/torchvision-0.24.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2025-11-12T15:25:13Z, size = 8049868, hashes = { sha256 = "66a98471fc18cad9064123106d810a75f57f0838eee20edc56233fd8484b0cc7" } }] + +[[packages]] +name = "tqdm" +version = "4.67.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/09/a9/6ba95a270c6f1fbcd8dac228323f2777d886cb206987444e4bce66338dd4/tqdm-4.67.3.tar.gz", upload-time = 2026-02-03T17:35:53Z, size = 169598, hashes = { sha256 = "7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", upload-time = 2026-02-03T17:35:50Z, size = 78374, hashes = { sha256 = "ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf" } }] + +[[packages]] +name = "traitlets" +version = "5.14.3" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", upload-time = 2024-04-19T11:11:49Z, size = 161621, hashes = { sha256 = "9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", upload-time = 2024-04-19T11:11:46Z, size = 85359, hashes = { sha256 = "b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f" } }] + +[[packages]] +name = "transformers" +version = "5.3.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/fc/1a/70e830d53ecc96ce69cfa8de38f163712d2b43ac52fbd743f39f56025c31/transformers-5.3.0.tar.gz", upload-time = 2026-03-04T17:41:46Z, size = 8830831, hashes = { sha256 = "009555b364029da9e2946d41f1c5de9f15e6b1df46b189b7293f33a161b9c557" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b8/88/ae8320064e32679a5429a2c9ebbc05c2bf32cefb6e076f9b07f6d685a9b4/transformers-5.3.0-py3-none-any.whl", upload-time = 2026-03-04T17:41:42Z, size = 10661827, hashes = { sha256 = "50ac8c89c3c7033444fb3f9f53138096b997ebb70d4b5e50a2e810bf12d3d29a" } }] + +[[packages]] +name = "triton" +version = "3.5.1" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/f2/50/9a8358d3ef58162c0a415d173cfb45b67de60176e1024f71fbc4d24c0b6d/triton-3.5.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-11-11T17:41:00Z, size = 170470207, hashes = { sha256 = "d2c6b915a03888ab931a9fd3e55ba36785e1fe70cbea0b40c6ef93b20fc85232" } }] + +[[packages]] +name = "truststore" +version = "0.10.5" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ee/9f/c5201d42a484c061e528825fc8e2d565f5abd50a4ced6fb7d29c4ec99b2b/truststore-0.10.5.tar.gz", upload-time = 2026-10-12T22:27:31Z, size = 28091, hashes = { sha256 = "30d36967ccaded5cbb38d602c433f53600036c79d502f4533a49b60a03bbefcd" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/51/e9/3a7820be2bb0fe53b6bc9c3be26d3d1158004e4c3ab953aa6840b955b1e9/truststore-0.10.5-py3-none-any.whl", upload-time = 2026-10-12T22:27:30Z, size = 19017, hashes = { sha256 = "9aaaedaefaf06d8b206278cf8b5012bc897f485a874503501e12d776df78951c" } }] + +[[packages]] +name = "typer" +version = "0.21.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/f2/1e/a27cc02a0cd715118c71fa2aef2c687fdefc3c28d90fd0dd789c5118154c/typer-0.21.2.tar.gz", upload-time = 2026-02-10T19:33:46Z, size = 120426, hashes = { sha256 = "1abd95a3b675e17ff61b0838ac637fe9478d446d62ad17fa4bb81ea57cc54028" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b8/cc/d59f893fbdfb5f58770c05febfc4086a46875f1084453621c35605cec946/typer-0.21.2-py3-none-any.whl", upload-time = 2026-02-10T19:33:48Z, size = 56728, hashes = { sha256 = "c3d8de54d00347ef90b82131ca946274f017cffb46683ae3883c360fa958f55c" } }] + +[[packages]] +name = "typing-extensions" +version = "4.15.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", upload-time = 2025-08-25T13:49:26Z, size = 109391, hashes = { sha256 = "0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", upload-time = 2025-08-25T13:49:24Z, size = 44614, hashes = { sha256 = "f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548" } }] + +[[packages]] +name = "typing-inspection" +version = "0.4.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", upload-time = 2025-10-01T02:14:41Z, size = 75949, hashes = { sha256 = "ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", upload-time = 2025-10-01T02:14:40Z, size = 14611, hashes = { sha256 = "4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7" } }] + +[[packages]] +name = "tzdata" +version = "2026.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/ba/19/1b9b0e29f30c6d35cb345486df41110984ea67ae69dddbc0e8a100999493/tzdata-2026.2.tar.gz", upload-time = 2026-04-24T15:22:08Z, size = 198254, hashes = { sha256 = "9173fde7d80d9018e02a662e168e5a2d04f87c41ea174b139fbef642eda62d10" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ce/e4/dccd7f47c4b64213ac01ef921a1337ee6e30e8c6466046018326977efd95/tzdata-2026.2-py2.py3-none-any.whl", upload-time = 2026-04-24T15:22:05Z, size = 349321, hashes = { sha256 = "bbe9af844f658da81a5f95019480da3a89415801f6cc966806612cc7169bffe7" } }] + +[[packages]] +name = "urllib3" +version = "2.7.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", upload-time = 2026-05-07T16:13:18Z, size = 433602, hashes = { sha256 = "231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", upload-time = 2026-05-07T16:13:17Z, size = 131087, hashes = { sha256 = "9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897" } }] + +[[packages]] +name = "uvicorn" +version = "0.46.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/1f/93/041fca8274050e40e6791f267d82e0e2e27dd165627bd640d3e0e378d877/uvicorn-0.46.0.tar.gz", upload-time = 2026-04-23T07:16:00Z, size = 88758, hashes = { sha256 = "fb9da0926999cc6cb22dc7cd71a94a632f078e6ae47ff683c5c420750fb7413d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/31/a3/5b1562db76a5a488274b2332a97199b32d0442aca0ed193697fd47786316/uvicorn-0.46.0-py3-none-any.whl", upload-time = 2026-04-23T07:15:58Z, size = 70926, hashes = { sha256 = "bbebbcbed972d162afca128605223022bedd345b7bc7855ce66deb31487a9048" } }] + +[[packages]] +name = "uvloop" +version = "0.22.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", upload-time = 2025-10-16T22:17:19Z, size = 2443250, hashes = { sha256 = "6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-10-16T22:16:32Z, size = 4426307, hashes = { sha256 = "7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4" } }] + +[[packages]] +name = "watchfiles" +version = "1.1.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8869df9b2a2d6c59d79220a4db37679e74f807c559ffe5265e08b227a210/watchfiles-1.1.1.tar.gz", upload-time = 2025-10-14T15:06:21Z, size = 94440, hashes = { sha256 = "a173cb5c16c4f40ab19cecf48a534c409f7ea983ab8fed0741304a1c0a31b3f2" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/cf/68/5707da262a119fb06fbe214d82dd1fe4a6f4af32d2d14de368d0349eb52a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-10-14T15:04:55Z, size = 456812, hashes = { sha256 = "1db5d7ae38ff20153d542460752ff397fcf5c96090c1230803713cf3147a6803" } }] + +[[packages]] +name = "wcwidth" +version = "0.6.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/35/a2/8e3becb46433538a38726c948d3399905a4c7cabd0df578ede5dc51f0ec2/wcwidth-0.6.0.tar.gz", upload-time = 2026-02-06T19:19:40Z, size = 159684, hashes = { sha256 = "cdc4e4262d6ef9a1a57e018384cbeb1208d8abbc64176027e2c2455c81313159" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/68/5a/199c59e0a824a3db2b89c5d2dade7ab5f9624dbf6448dc291b46d5ec94d3/wcwidth-0.6.0-py3-none-any.whl", upload-time = 2026-02-06T19:19:39Z, size = 94189, hashes = { sha256 = "1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad" } }] + +[[packages]] +name = "xgrammar" +version = "0.1.32" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/99/6a/d51b44fc0b43e2d4adae42b6a17fe9ee49e177d6d768be739ed7dec7b57e/xgrammar-0.1.32.tar.gz", upload-time = 2026-03-04T12:01:52Z, size = 2365047, hashes = { sha256 = "5d424d52779ca2d3ccaf72f2289d6519efe308e933d0d3fc3c292c780825bb12" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/69/62/65e664d861cdadf2d788c03dd8fe67f1faaa7bd4bd2317a2ab850aebee20/xgrammar-0.1.32-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-04T12:00:50Z, size = 37711100, hashes = { sha256 = "f96c7a4fcbd68e18b13cb3b6ed5d24b5326b256933f476bdaf2cc8e609c228db" } }] + +[[packages]] +name = "xxhash" +version = "3.7.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/24/2f/e183a1b407002f5af81822bee18b61cdb94b8670208ef34734d8d2b8ebe9/xxhash-3.7.0.tar.gz", upload-time = 2026-04-25T11:10:32Z, size = 82022, hashes = { sha256 = "6cc4eefbb542a5d6ffd6d70ea9c502957c925e800f998c5630ecc809d6702bae" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/40/37/558f5a90c0672fc9b4402dc25d87ac5b7406616e8969430c9ca4e52ee74d/xxhash-3.7.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-25T11:06:31Z, size = 193932, hashes = { sha256 = "13805f0461cba0a857924e70ff91ae6d52d2598f79a884e788db80532614a4a1" } }] + +[[packages]] +name = "yarl" +version = "1.23.0" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", upload-time = 2026-03-01T22:07:53Z, size = 194676, hashes = { sha256 = "53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-01T22:05:23Z, size = 100132, hashes = { sha256 = "a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51" } }, + { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", upload-time = 2026-03-01T22:07:51Z, size = 48288, hashes = { sha256 = "a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f" } }, +] + +[[packages]] +name = "zipp" +version = "3.23.1" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/30/21/093488dfc7cc8964ded15ab726fad40f25fd3d788fd741cc1c5a17d78ee8/zipp-3.23.1.tar.gz", upload-time = 2026-04-13T23:21:46Z, size = 25965, hashes = { sha256 = "32120e378d32cd9714ad503c1d024619063ec28aad2248dc6672ad13edfa5110" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/08/8a/0861bec20485572fbddf3dfba2910e38fe249796cb73ecdeb74e07eeb8d3/zipp-3.23.1-py3-none-any.whl", upload-time = 2026-04-13T23:21:45Z, size = 10378, hashes = { sha256 = "0b3596c50a5c700c9cb40ba8d86d9f2cc4807e9bedb06bcdf7fac85633e444dc" } }] diff --git a/packages/sie_server/bundle-locks/cuda12-sglang-vision-extract-amd64/manifest.json b/packages/sie_server/bundle-locks/cuda12-sglang-vision-extract-amd64/manifest.json new file mode 100644 index 000000000..8c09a966c --- /dev/null +++ b/packages/sie_server/bundle-locks/cuda12-sglang-vision-extract-amd64/manifest.json @@ -0,0 +1,28 @@ +{ + "completed_artifact_hashes": [], + "exceptions_sha256": "f94e7c7f1d19ac063771a0ddf0e6657d76cf7c0501e0d74656cdc3019f781268", + "exclude_newer": "2026-10-18T00:00:00Z", + "indexes": [ + "--default-index", + "https://pypi.org/simple", + "--index", + "https://docs.sglang.ai/whl/cu129/", + "--index-strategy", + "unsafe-best-match" + ], + "inputs": { + "requirements_sha256": "378dabe9b77bc2c593a05e1113534e8f50093ca205d3344a7ba2e20fe660e38a", + "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" + }, + "lock_sha256": "a74358f2ff818ad75d589987a4dd34ca9340a9a6739c8bc041671f658330bea8", + "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "schema_version": 1, + "target": { + "architecture": "amd64", + "bundle": "sglang-vision-extract", + "platform": "cuda12", + "python_platform": "x86_64-manylinux_2_35", + "python_version": "3.12" + }, + "uv_version": "0.9.28" +} diff --git a/packages/sie_server/bundle-locks/cuda12-sglang-vision-extract-amd64/pylock.toml b/packages/sie_server/bundle-locks/cuda12-sglang-vision-extract-amd64/pylock.toml new file mode 100644 index 000000000..8b554111e --- /dev/null +++ b/packages/sie_server/bundle-locks/cuda12-sglang-vision-extract-amd64/pylock.toml @@ -0,0 +1,1153 @@ +lock-version = "1.0" +created-by = "uv" +requires-python = ">=3.12" + +[[packages]] +name = "aiohappyeyeballs" +version = "2.6.1" +sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", upload-time = 2025-03-12T01:42:48Z, size = 22760, hashes = { sha256 = "c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", upload-time = 2025-03-12T01:42:47Z, size = 15265, hashes = { sha256 = "f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8" } }] + +[[packages]] +name = "aiohttp" +version = "3.14.3" +sdist = { url = "https://files.pythonhosted.org/packages/58/d9/22ce5786ac0c1653ae8b6c23bded02c1686d11f0dbb45b31ce128e0df985/aiohttp-3.14.3.tar.gz", upload-time = 2026-07-23T01:57:27Z, size = 7971213, hashes = { sha256 = "9491196535a88924a60afd5b5f434b5b203b6cc616250878dbdb223a8f7844bc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/52/b7/7cd31f29d6055bd711ae6e669367fba6f5ae9de463910a793e30556a8db7/aiohttp-3.14.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-23T01:54:15Z, size = 1792122, hashes = { sha256 = "543906c127fb1d929b95076db19b83fa2d46751006ff1e23b093aa5ac4d8db42" } }] + +[[packages]] +name = "aiosignal" +version = "1.4.0" +sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", upload-time = 2025-07-03T22:54:43Z, size = 25007, hashes = { sha256 = "f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", upload-time = 2025-07-03T22:54:42Z, size = 7490, hashes = { sha256 = "053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e" } }] + +[[packages]] +name = "airportsdata" +version = "20260905" +sdist = { url = "https://files.pythonhosted.org/packages/a5/c2/69ec4b992746c4c7b076a7afffb11fc64267d684ed0cd3db00035f0f682b/airportsdata-20260905.tar.gz", upload-time = 2026-09-05T06:02:21Z, size = 929470, hashes = { sha256 = "a7e17469458ca356a5ca9971f49864b934a559d43e1587e19219cb981d364c45" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/45/f8/65e9d476f84bb60ac7ff1fe525acdd60fe6b4b585ae6f074c947c6ad0fc1/airportsdata-20260905-py3-none-any.whl", upload-time = 2026-09-05T06:02:19Z, size = 931164, hashes = { sha256 = "d7eaa9a57d373b0adaaae0d52da2af0bb0edf73f7baa170f7c415d3342bf4868" } }] + +[[packages]] +name = "annotated-doc" +version = "0.0.4" +sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", upload-time = 2025-11-10T22:07:42Z, size = 7288, hashes = { sha256 = "fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", upload-time = 2025-11-10T22:07:40Z, size = 5303, hashes = { sha256 = "571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320" } }] + +[[packages]] +name = "annotated-types" +version = "0.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", upload-time = 2024-05-20T21:33:25Z, size = 16081, hashes = { sha256 = "aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", upload-time = 2024-05-20T21:33:24Z, size = 13643, hashes = { sha256 = "1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53" } }] + +[[packages]] +name = "anthropic" +version = "1.15.0" +sdist = { url = "https://files.pythonhosted.org/packages/10/37/5a2a4316df8babd28f096477a707cd75f240b4264c97fb128c32375105d6/anthropic-1.15.0.tar.gz", upload-time = 2026-10-15T19:45:34Z, size = 1726101, hashes = { sha256 = "90caa9df83e2fc8bddb4ddeb83b7191bce255f635c03eae055deec521741df08" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d1/65/54437e7edea49a3be9ef56f6b5965999bfdc52b9dadc9b448124ca51a594/anthropic-1.15.0-py3-none-any.whl", upload-time = 2026-10-15T19:45:32Z, size = 2047755, hashes = { sha256 = "10189a7993c5c71a0a2d4bb80020ca6a2fd27679f51e627405da37251d15ff49" } }] + +[[packages]] +name = "anyio" +version = "4.14.2" +sdist = { url = "https://files.pythonhosted.org/packages/61/cc/a381afa6efea9f496eff839d4a6a1aed3bfafc7b3ab4b0d1b243a12573dd/anyio-4.14.2.tar.gz", upload-time = 2026-07-12T20:29:07Z, size = 260176, hashes = { sha256 = "cfa139f3ed1a23ee8f88a145ddb5ac7605b8bbfd8592baacd7ce3d8bb4313c7f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/da/35/f2287558c17e29fafc8ef3daf819bb9834061cfa43bff8014f7df7f63bdc/anyio-4.14.2-py3-none-any.whl", upload-time = 2026-07-12T20:29:05Z, size = 125813, hashes = { sha256 = "9f505dda5ac9f0c8309b5e8bd445a8c2bf7246f3ce950121e45ea15bc41d1494" } }] + +[[packages]] +name = "apache-tvm-ffi" +version = "0.1.14.post1" +sdist = { url = "https://files.pythonhosted.org/packages/ed/50/2b9d308f34843b99e763ac7d510ba6400dbb3e86b3f04fd206be0dc9cd46/apache_tvm_ffi-0.1.14.post1.tar.gz", upload-time = 2026-09-24T07:52:45Z, size = 3232883, hashes = { sha256 = "8ebd92dc97cdcb22ab494aa252c868ddd6a9b6c89be69188562e0f236652429f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e8/db/68786fdc0bfb3a9782df7304c1e577b9c5a7d14c75e98e06571cc1869b3f/apache_tvm_ffi-0.1.14.post1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-09-24T07:52:14Z, size = 3251763, hashes = { sha256 = "eb759c039866b541ec2cb07d498082f8ba6ded74d58d9196180a5932f365c077" } }] + +[[packages]] +name = "asttokens" +version = "3.0.1" +sdist = { url = "https://files.pythonhosted.org/packages/be/a5/8e3f9b6771b0b408517c82d97aed8f2036509bc247d46114925e32fe33f0/asttokens-3.0.1.tar.gz", upload-time = 2025-11-15T16:43:48Z, size = 62308, hashes = { sha256 = "71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d2/39/e7eaf1799466a4aef85b6a4fe7bd175ad2b1c6345066aa33f1f58d4b18d0/asttokens-3.0.1-py3-none-any.whl", upload-time = 2025-11-15T16:43:16Z, size = 27047, hashes = { sha256 = "15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a" } }] + +[[packages]] +name = "attrs" +version = "26.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", upload-time = 2026-03-19T14:22:25Z, size = 952055, hashes = { sha256 = "d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", upload-time = 2026-03-19T14:22:23Z, size = 67548, hashes = { sha256 = "c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309" } }] + +[[packages]] +name = "blobfile" +version = "3.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/9d/a9/a34e8153b0203d9060ff7aa5dfcd175e161117949697a83c4cc003b523ff/blobfile-3.0.0.tar.gz", upload-time = 2024-08-27T00:02:53Z, size = 77863, hashes = { sha256 = "32ec777414de7bb2a76ca812a838f0d33327ca28ae844a253503cde625cdf2f1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ed/4d/1392562369b1139e741b30d624f09fe7091d17dd5579fae5732f044b12bb/blobfile-3.0.0-py3-none-any.whl", upload-time = 2024-08-27T00:02:51Z, size = 75413, hashes = { sha256 = "48ecc3307e622804bd8fe13bf6f40e6463c4439eba7a1f9ad49fd78aa63cc658" } }] + +[[packages]] +name = "build" +version = "1.4.4" +sdist = { url = "https://files.pythonhosted.org/packages/02/ec/bf5ae0a7e5ab57abe8aabdd0759c971883895d1a20c49ae99f8146840c3c/build-1.4.4.tar.gz", upload-time = 2026-04-22T20:53:44Z, size = 89220, hashes = { sha256 = "f832ae053061f3fb524af812dc94b8b84bac6880cd587630e3b5d91a6a9c1703" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/fa/88/6764e7a109dd84294850741501145da90d13cdeac9d4e614929464a37420/build-1.4.4-py3-none-any.whl", upload-time = 2026-04-22T20:53:43Z, size = 25921, hashes = { sha256 = "8c3f48a6090b39edec1a273d2d57949aaf13723b01e02f9d518396887519f64d" } }] + +[[packages]] +name = "certifi" +version = "2026.4.22" +sdist = { url = "https://files.pythonhosted.org/packages/25/ee/6caf7a40c36a1220410afe15a1cc64993a1f864871f698c0f93acb72842a/certifi-2026.4.22.tar.gz", upload-time = 2026-04-22T11:26:11Z, size = 137077, hashes = { sha256 = "8d455352a37b71bf76a79caa83a3d6c25afee4a385d632127b6afb3963f1c580" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/22/30/7cd8fdcdfbc5b869528b079bfb76dcdf6056b1a2097a662e5e8c04f42965/certifi-2026.4.22-py3-none-any.whl", upload-time = 2026-04-22T11:26:09Z, size = 135707, hashes = { sha256 = "3cb2210c8f88ba2318d29b0388d1023c8492ff72ecdde4ebdaddbb13a31b1c4a" } }] + +[[packages]] +name = "cffi" +version = "2.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", upload-time = 2025-09-08T23:24:04Z, size = 523588, hashes = { sha256 = "44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-09-08T23:22:52Z, size = 219572, hashes = { sha256 = "3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba" } }] + +[[packages]] +name = "charset-normalizer" +version = "3.4.7" +sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", upload-time = 2026-04-02T09:28:39Z, size = 144271, hashes = { sha256 = "ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4b/f8/d0118a2f5f23b02cd166fa385c60f9b0d4f9194f574e2b31cef350ad7223/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-02T09:26:29Z, size = 216589, hashes = { sha256 = "5649fd1c7bade02f320a462fdefd0b4bd3ce036065836d4f42e0de958038e116" } }, + { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", upload-time = 2026-04-02T09:28:37Z, size = 61958, hashes = { sha256 = "3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d" } }, +] + +[[packages]] +name = "click" +version = "8.1.8" +sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", upload-time = 2024-12-21T18:38:44Z, size = 226593, hashes = { sha256 = "ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", upload-time = 2024-12-21T18:38:41Z, size = 98188, hashes = { sha256 = "63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2" } }] + +[[packages]] +name = "cloudpickle" +version = "3.1.2" +sdist = { url = "https://files.pythonhosted.org/packages/27/fb/576f067976d320f5f0114a8d9fa1215425441bb35627b1993e5afd8111e5/cloudpickle-3.1.2.tar.gz", upload-time = 2025-11-03T09:25:26Z, size = 22330, hashes = { sha256 = "7fda9eb655c9c230dab534f1983763de5835249750e85fbcef43aaa30a9a2414" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl", upload-time = 2025-11-03T09:25:25Z, size = 22228, hashes = { sha256 = "9acb47f6afd73f60dc1df93bb801b472f05ff42fa6c84167d25cb206be1fbf4a" } }] + +[[packages]] +name = "compressed-tensors" +version = "0.15.0.1" +sdist = { url = "https://files.pythonhosted.org/packages/41/1b/c3c4a98ec5f2727656336f07a0c35862195c310d8eb0b2fa5b4be6848680/compressed_tensors-0.15.0.1.tar.gz", upload-time = 2026-04-10T14:23:54Z, size = 229412, hashes = { sha256 = "a8e93054e8a5ec49c980b09ed36c4c1249b4a8ee167920a8e461c4da26e78d99" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a8/52/93833dc1610e017ac5b7dcd59b8304d8ef67d1114c2d124e728a2cbbea12/compressed_tensors-0.15.0.1-py3-none-any.whl", upload-time = 2026-04-10T14:23:53Z, size = 194260, hashes = { sha256 = "e1b1f322e82e475715e242bad46925a304ea8e5c98b5055a15b8eb22fb6bfea9" } }] + +[[packages]] +name = "cryptography" +version = "50.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/de/41/6cbdcf9142d00fe82836fbb51e503e58088575cf7a0fe1dbff6695bf0840/cryptography-50.0.0.tar.gz", upload-time = 2026-07-31T14:25:10Z, size = 880201, hashes = { sha256 = "eeac2acb5a20ed25e0ad6d1df9891a520b78b404266b6d11778f25d5d691a6c9" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/41/029086c34d91052fc3b88bcc8056f709a7c915c7a23b235a54eb800b1c97/cryptography-50.0.0-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-07-31T14:23:37Z, size = 4702130, hashes = { sha256 = "06a32a980526a6ab9a4b9bf8f7385800791e2bb960903cb6b530e4817509a3b7" } }, + { url = "https://files.pythonhosted.org/packages/6b/72/a1116d683a6d7ece94590013882515de087edf9ef0e6292aae615a44df73/cryptography-50.0.0-cp311-abi3-manylinux_2_28_x86_64.whl", upload-time = 2026-07-31T14:23:43Z, size = 4734609, hashes = { sha256 = "b42a28c1844fd9de8f3f7d540e36b66f3a9c83fceac7170ebc7a6a19edd9dcae" } }, + { url = "https://files.pythonhosted.org/packages/da/3a/f05e32c99d440c9bb891ea0e36c9091891e36be5a9a87ab2ee6ea20729f6/cryptography-50.0.0-cp311-abi3-manylinux_2_34_x86_64.whl", upload-time = 2026-07-31T14:23:50Z, size = 4734462, hashes = { sha256 = "82148ec5bddac30b51a5b3c1945075f896fa022cb93f8e4a01e9f6ee95292c5f" } }, + { url = "https://files.pythonhosted.org/packages/85/4f/0fa8c2f4428198f15d9ff8d63400e27afbf94ce833f6108da1eb3753f945/cryptography-50.0.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-07-31T14:24:27Z, size = 4728939, hashes = { sha256 = "a91296cb61e8df6f86d0c19cc4068228da256bf59bf86049fbd821084565327f" } }, + { url = "https://files.pythonhosted.org/packages/46/c9/f60aed34c013f317f92817b6c171c2d22a78270fa41109bd4b08af26b194/cryptography-50.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", upload-time = 2026-07-31T14:24:34Z, size = 4762647, hashes = { sha256 = "105110f43a471dbd0060b9c9516cb8a6a79233631a04cc2ba16f28323ac6e025" } }, + { url = "https://files.pythonhosted.org/packages/9c/f8/d97f9603efda3888187bfdb893f26c41be4735c10631d05d284ee6b047c4/cryptography-50.0.0-cp39-abi3-manylinux_2_34_x86_64.whl", upload-time = 2026-07-31T14:24:43Z, size = 4762400, hashes = { sha256 = "37fdb0d0111f1e2ff07139dfb79f1b49531f8e213c46f1163dd7642979b58c47" } }, +] + +[[packages]] +name = "cuda-bindings" +version = "12.9.10" +wheels = [{ url = "https://files.pythonhosted.org/packages/7b/6e/0e07e8b3578547e1083a7ee105c5736033ecb189466f40e45283b46bc7c6/cuda_bindings-12.9.10-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-10-15T14:12:03Z, size = 7627380, hashes = { sha256 = "420e44cfcd939cd69d6cfe8efc5f08b44850994cae399a49b9299a464324ce97" } }] + +[[packages]] +name = "cuda-pathfinder" +version = "1.8.3" +wheels = [{ url = "https://files.pythonhosted.org/packages/b9/fb/f8e1890428f9f590b4beebd63b068aac1ce32a3331510c847b9f9a78f261/cuda_pathfinder-1.8.3-py3-none-any.whl", upload-time = 2026-10-02T03:20:23Z, size = 62561, hashes = { sha256 = "e29e59829c297a7a5233bd9cc71094fc5bddbd076951482670178f9eade39b1f" } }] + +[[packages]] +name = "cuda-python" +version = "12.9.0" +wheels = [{ url = "https://files.pythonhosted.org/packages/24/3c/4475aebeaab9651f2e61000fbe76f91a476d371dbfbf0a1cf46e689af253/cuda_python-12.9.0-py3-none-any.whl", upload-time = 2025-05-06T19:14:07Z, size = 7532, hashes = { sha256 = "926acba49b2c0a0374c61b7c98f337c085199cf51cdfe4d6423c4129c20547a7" } }] + +[[packages]] +name = "cuda-tile" +version = "1.6.0" +wheels = [{ url = "https://files.pythonhosted.org/packages/40/21/3dfeafbd3512e94a277a25ce022c10e7bdff5d43e364afffcc0928f7fcaf/cuda_tile-1.6.0-cp312-cp312-manylinux2014_x86_64.whl", upload-time = 2026-09-10T00:06:48Z, size = 382170, hashes = { sha256 = "7e38f97bfedff359c926710387a40fbfc8f36efb7fe9ad2cb759d5a098eedde3" } }] + +[[packages]] +name = "datasets" +version = "3.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/1a/89/d3d6fef58a488f8569c82fd293ab7cbd4250244d67f425dcae64c63800ea/datasets-3.6.0.tar.gz", upload-time = 2025-05-07T15:15:02Z, size = 569336, hashes = { sha256 = "1b2bf43b19776e2787e181cfd329cb0ca1a358ea014780c3581e0f276375e041" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/20/34/a08b0ee99715eaba118cbe19a71f7b5e2425c2718ef96007c325944a1152/datasets-3.6.0-py3-none-any.whl", upload-time = 2025-05-07T15:14:59Z, size = 491546, hashes = { sha256 = "25000c4a2c0873a710df127d08a202a06eab7bf42441a6bc278b499c2f72cd1b" } }] + +[[packages]] +name = "decorator" +version = "5.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", upload-time = 2025-02-24T04:41:34Z, size = 56711, hashes = { sha256 = "65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", upload-time = 2025-02-24T04:41:32Z, size = 9190, hashes = { sha256 = "d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a" } }] + +[[packages]] +name = "dill" +version = "0.3.8" +sdist = { url = "https://files.pythonhosted.org/packages/17/4d/ac7ffa80c69ea1df30a8aa11b3578692a5118e7cd1aa157e3ef73b092d15/dill-0.3.8.tar.gz", upload-time = 2024-01-27T23:42:16Z, size = 184847, hashes = { sha256 = "3ebe3c479ad625c4553aca177444d89b486b1d84982eeacded644afc0cf797ca" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c9/7a/cef76fd8438a42f96db64ddaa85280485a9c395e7df3db8158cfec1eee34/dill-0.3.8-py3-none-any.whl", upload-time = 2024-01-27T23:42:14Z, size = 116252, hashes = { sha256 = "c36ca9ffb54365bdd2f8eb3eff7d2a21237f8452b57ace88b1ac615b7e815bd7" } }] + +[[packages]] +name = "diskcache" +version = "5.6.3" +sdist = { url = "https://files.pythonhosted.org/packages/3f/21/1c1ffc1a039ddcc459db43cc108658f32c57d271d7289a2794e401d0fdb6/diskcache-5.6.3.tar.gz", upload-time = 2023-08-31T06:12:00Z, size = 67916, hashes = { sha256 = "2c3a3fa2743d8535d832ec61c2054a1641f41775aa7c556758a109941e33e4fc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3f/27/4570e78fc0bf5ea0ca45eb1de3818a23787af9b390c0b0a0033a1b8236f9/diskcache-5.6.3-py3-none-any.whl", upload-time = 2023-08-31T06:11:58Z, size = 45550, hashes = { sha256 = "5e31b2d5fbad117cc363ebaf6b689474db18a1f6438bc82358b024abd4c2ca19" } }] + +[[packages]] +name = "distro" +version = "1.9.0" +sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", upload-time = 2023-12-24T09:54:32Z, size = 60722, hashes = { sha256 = "2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", upload-time = 2023-12-24T09:54:30Z, size = 20277, hashes = { sha256 = "7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2" } }] + +[[packages]] +name = "docstring-parser" +version = "0.18.0" +sdist = { url = "https://files.pythonhosted.org/packages/e0/4d/f332313098c1de1b2d2ff91cf2674415cc7cddab2ca1b01ae29774bd5fdf/docstring_parser-0.18.0.tar.gz", upload-time = 2026-04-14T04:09:19Z, size = 29341, hashes = { sha256 = "292510982205c12b1248696f44959db3cdd1740237a968ea1e2e7a900eeb2015" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a7/5f/ed01f9a3cdffbd5a008556fc7b2a08ddb1cc6ace7effa7340604b1d16699/docstring_parser-0.18.0-py3-none-any.whl", upload-time = 2026-04-14T04:09:18Z, size = 22484, hashes = { sha256 = "b3fcbed555c47d8479be0796ef7e19c2670d428d72e96da63f3a40122860374b" } }] + +[[packages]] +name = "einops" +version = "0.8.2" +sdist = { url = "https://files.pythonhosted.org/packages/2c/77/850bef8d72ffb9219f0b1aac23fbc1bf7d038ee6ea666f331fa273031aa2/einops-0.8.2.tar.gz", upload-time = 2026-01-26T04:13:17Z, size = 56261, hashes = { sha256 = "609da665570e5e265e27283aab09e7f279ade90c4f01bcfca111f3d3e13f2827" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/09/f8d8f8f31e4483c10a906437b4ce31bdf3d6d417b73fe33f1a8b59e34228/einops-0.8.2-py3-none-any.whl", upload-time = 2026-01-26T04:13:18Z, size = 65638, hashes = { sha256 = "54058201ac7087911181bfec4af6091bb59380360f069276601256a76af08193" } }] + +[[packages]] +name = "executing" +version = "2.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", upload-time = 2025-09-01T09:48:10Z, size = 1129488, hashes = { sha256 = "3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", upload-time = 2025-09-01T09:48:08Z, size = 28317, hashes = { sha256 = "760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017" } }] + +[[packages]] +name = "fastapi" +version = "0.136.1" +sdist = { url = "https://files.pythonhosted.org/packages/5d/45/c130091c2dfa061bbfe3150f2a5091ef1adf149f2a8d2ae769ecaf6e99a2/fastapi-0.136.1.tar.gz", upload-time = 2026-04-23T16:49:44Z, size = 397448, hashes = { sha256 = "7af665ad7acfa0a3baf8983d393b6b471b9da10ede59c60045f49fbc89a0fa7f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5a/ff/2e4eca3ade2c22fe1dea7043b8ee9dabe47753349eb1b56a202de8af6349/fastapi-0.136.1-py3-none-any.whl", upload-time = 2026-04-23T16:49:42Z, size = 117683, hashes = { sha256 = "a6e9d7eeada96c93a4d69cb03836b44fa34e2854accb7244a1ece36cd4781c3f" } }] + +[[packages]] +name = "filelock" +version = "3.29.0" +sdist = { url = "https://files.pythonhosted.org/packages/b5/fe/997687a931ab51049acce6fa1f23e8f01216374ea81374ddee763c493db5/filelock-3.29.0.tar.gz", upload-time = 2026-04-19T15:39:10Z, size = 57571, hashes = { sha256 = "69974355e960702e789734cb4871f884ea6fe50bd8404051a3530bc07809cf90" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/81/47/dd9a212ef6e343a6857485ffe25bba537304f1913bdbed446a23f7f592e1/filelock-3.29.0-py3-none-any.whl", upload-time = 2026-04-19T15:39:08Z, size = 39812, hashes = { sha256 = "96f5f6344709aa1572bbf631c640e4ebeeb519e08da902c39a001882f30ac258" } }] + +[[packages]] +name = "flash-attn-4" +version = "4.0.0b19" +sdist = { url = "https://files.pythonhosted.org/packages/93/63/6a00e1cd55765f5cf7d7a0100d1a5831824227ae3306275f3e6db420a76e/flash_attn_4-4.0.0b19.tar.gz", upload-time = 2026-06-24T09:15:14Z, size = 353141, hashes = { sha256 = "c904c9da0387c2ac0420cffdf61d6201d94cfeb354b6768fde794b04e9fc4e89" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e4/0e/5298d57e3efd5b7a07755fa9009fc1f6efc0f2d422915113eb7288a6552b/flash_attn_4-4.0.0b19-py3-none-any.whl", upload-time = 2026-06-24T09:15:13Z, size = 377662, hashes = { sha256 = "bc3856e018fa32e2b833726566641e51d02d45f2d444849937276a46c01653a2" } }] + +[[packages]] +name = "flashinfer-cubin" +version = "0.6.7.post3" +wheels = [{ url = "https://files.pythonhosted.org/packages/91/64/f516081e983a35e3f52b7e525e2e62f1d6148c175eb24df32c8786776ba5/flashinfer_cubin-0.6.7.post3-py3-none-any.whl", upload-time = 2026-04-06T01:43:16Z, size = 294635743, hashes = { sha256 = "724cbce52f917dd06ebcb61fff2146c30b69cfdb341891d7c293249e414d6e35" } }] + +[[packages]] +name = "flashinfer-python" +version = "0.6.7.post3" +sdist = { url = "https://files.pythonhosted.org/packages/12/b5/466778818d195b96a062467ee389d0fcfa51fdfecad4a831922916d4c48a/flashinfer_python-0.6.7.post3.tar.gz", upload-time = 2026-04-06T01:43:00Z, size = 6508243, hashes = { sha256 = "defad86864e087f754ed0a632c2d15aa389a1dc8e3198fb6b7d7af4b36e3eaa5" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/01/6b/4117cd7cbeff07818ae7c6b8bf5a6d1ee3eed29356672b731b55af3d4453/flashinfer_python-0.6.7.post3-py3-none-any.whl", upload-time = 2026-04-06T01:42:58Z, size = 9187533, hashes = { sha256 = "9d3f1aa0313cf9e5cf99f7560b8e003c57876088c8abfe7a3d330cccd4873052" } }] + +[[packages]] +name = "frozenlist" +version = "1.8.0" +sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", upload-time = 2025-10-06T05:38:17Z, size = 45875, hashes = { sha256 = "3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2025-10-06T05:36:09Z, size = 242411, hashes = { sha256 = "494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383" } }, + { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", upload-time = 2025-10-06T05:38:16Z, size = 13409, hashes = { sha256 = "0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d" } }, +] + +[[packages]] +name = "fsspec" +version = "2025.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/34/f4/5721faf47b8c499e776bc34c6a8fc17efdf7fdef0b00f398128bc5dcb4ac/fsspec-2025.3.0.tar.gz", upload-time = 2025-03-07T21:47:56Z, size = 298491, hashes = { sha256 = "a935fd1ea872591f2b5148907d103488fc523295e6c64b835cfad8c3eca44972" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/56/53/eb690efa8513166adef3e0669afd31e95ffde69fb3c52ec2ac7223ed6018/fsspec-2025.3.0-py3-none-any.whl", upload-time = 2025-03-07T21:47:54Z, size = 193615, hashes = { sha256 = "efb87af3efa9103f94ca91a7f8cb7a4df91af9f74fc106c9c7ea0efd7277c1b3" } }] + +[[packages]] +name = "gguf" +version = "0.19.0" +sdist = { url = "https://files.pythonhosted.org/packages/48/ae/17f1308ae45cd7b08ebb521747d5b23f4efc4d172038a4e228dd5106c3ff/gguf-0.19.0.tar.gz", upload-time = 2026-05-06T13:04:03Z, size = 111220, hashes = { sha256 = "dbadcd6cc7ccd44256f2229fe7c2dff5e8aa5cf0612ab987fd2b1a57e428923f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b3/bb/d71d6da82763528c2c2ed6b59a9d6142c6595545a4c448e2085d155e88c2/gguf-0.19.0-py3-none-any.whl", upload-time = 2026-05-06T13:04:02Z, size = 118475, hashes = { sha256 = "70bcd10edfe697fb2dad6e40af2234b9d8ece9a41a99761405121ebda1c3c1cd" } }] + +[[packages]] +name = "grpcio" +version = "1.78.0" +sdist = { url = "https://files.pythonhosted.org/packages/06/8a/3d098f35c143a89520e568e6539cc098fcd294495910e359889ce8741c84/grpcio-1.78.0.tar.gz", upload-time = 2026-02-06T09:57:18Z, size = 12852416, hashes = { sha256 = "7382b95189546f375c174f53a5fa873cef91c4b8005faa05cc5b3beea9c4f1c5" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/54/bf/f4a3b9693e35d25b24b0b39fa46d7d8a3c439e0a3036c3451764678fec20/grpcio-1.78.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-02-06T09:55:36Z, size = 6690766, hashes = { sha256 = "12a771591ae40bc65ba67048fa52ef4f0e6db8279e595fd349f9dfddeef571f9" } }] + +[[packages]] +name = "grpcio-health-checking" +version = "1.78.0" +sdist = { url = "https://files.pythonhosted.org/packages/8e/ac/8eb871f4e47b11abfe45497e6187a582ec680ccd7232706d228474a8c7a5/grpcio_health_checking-1.78.0.tar.gz", upload-time = 2026-02-06T10:01:47Z, size = 17008, hashes = { sha256 = "78526d5c60b9b99fd18954b89f86d70033c702e96ad6ccc9749baf16136979b3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8e/30/dbaf47e2210697e2923b49eb62a6a2c07d5ee55bb40cff1e6cc0c5bb22e1/grpcio_health_checking-1.78.0-py3-none-any.whl", upload-time = 2026-02-06T10:01:37Z, size = 19010, hashes = { sha256 = "309798c098c5de72a9bff7172d788fdf309d246d231db9955b32e7c1c773fbeb" } }] + +[[packages]] +name = "grpcio-reflection" +version = "1.78.0" +sdist = { url = "https://files.pythonhosted.org/packages/31/06/337546aae558675f79cae2a8c1ce0c9b1952cbc5c28b01878f68d040f5bb/grpcio_reflection-1.78.0.tar.gz", upload-time = 2026-02-06T10:01:52Z, size = 19098, hashes = { sha256 = "e6e60c0b85dbcdf963b4d4d150c0f1d238ba891d805b575c52c0365d07fc0c40" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/df/6d/4d095d27ccd049865ecdafc467754e9e47ad0f677a30dda969c3590f6582/grpcio_reflection-1.78.0-py3-none-any.whl", upload-time = 2026-02-06T10:01:33Z, size = 22800, hashes = { sha256 = "06fcfde9e6888cdd12e9dd1cf6dc7c440c2e9acf420f696ccbe008672ed05b60" } }] + +[[packages]] +name = "h11" +version = "0.16.0" +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", upload-time = 2025-04-24T03:35:25Z, size = 101250, hashes = { sha256 = "4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", upload-time = 2025-04-24T03:35:24Z, size = 37515, hashes = { sha256 = "63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86" } }] + +[[packages]] +name = "hf-xet" +version = "1.4.3" +marker = "platform_machine == 'AMD64' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" +sdist = { url = "https://files.pythonhosted.org/packages/53/92/ec9ad04d0b5728dca387a45af7bc98fbb0d73b2118759f5f6038b61a57e8/hf_xet-1.4.3.tar.gz", upload-time = 2026-03-31T22:40:07Z, size = 670477, hashes = { sha256 = "8ddedb73c8c08928c793df2f3401ec26f95be7f7e516a7bee2fbb546f6676113" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/df/9a/a24b26dc8a65f0ecc0fe5be981a19e61e7ca963b85e062c083f3a9100529/hf_xet-1.4.3-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-03-31T22:39:42Z, size = 4212320, hashes = { sha256 = "fc360b70c815bf340ed56c7b8c63aacf11762a4b099b2fe2c9bd6d6068668c08" } }] + +[[packages]] +name = "httpcore" +version = "1.0.9" +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", upload-time = 2025-04-24T22:06:22Z, size = 85484, hashes = { sha256 = "6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", upload-time = 2025-04-24T22:06:20Z, size = 78784, hashes = { sha256 = "2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55" } }] + +[[packages]] +name = "httpcore2" +version = "2.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/e6/34/18f1c596e677962f040284246f393b10a1f8ce440b3a7e69c637d0f1c7ad/httpcore2-2.3.0.tar.gz", upload-time = 2026-06-01T13:15:02Z, size = 64300, hashes = { sha256 = "07327e251560960eea8e969d92d4c6a325feb13cca39e25340731336c3baf924" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c2/dd/3357218c69360d1cecc196c230c9a1d5c9afd5dba362056e23e60a5e64e5/httpcore2-2.3.0-py3-none-any.whl", upload-time = 2026-06-01T13:15:00Z, size = 80024, hashes = { sha256 = "477e9e334f74e5240dcac002e890580f36a57d40ff0fb14cc9655731d23b8415" } }] + +[[packages]] +name = "httpx" +version = "0.28.1" +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", upload-time = 2024-12-06T15:37:23Z, size = 141406, hashes = { sha256 = "75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", upload-time = 2024-12-06T15:37:21Z, size = 73517, hashes = { sha256 = "d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad" } }] + +[[packages]] +name = "httpx2" +version = "2.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/9f/9a/cca0b9145f13d8ae34b885ae28d403a1469a433abc78e0f94f4ce94e650b/httpx2-2.3.0.tar.gz", upload-time = 2026-06-01T13:15:04Z, size = 81115, hashes = { sha256 = "227e7c41d95a76d4077a52640564132777215fc3394e07b66a3116c33d668fa9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/87/ce/ae2911859847f9ba1d6b23027e53481cbeb50b93234f355a968d300ca2cb/httpx2-2.3.0-py3-none-any.whl", upload-time = 2026-06-01T13:15:01Z, size = 74538, hashes = { sha256 = "6f393663bdf6dbe7fe90118e3eb5b2bd024a675cae0390ac08cec9198812d8b7" } }] + +[[packages]] +name = "huggingface-hub" +version = "1.16.1" +sdist = { url = "https://files.pythonhosted.org/packages/48/0f/ed994dbade67a54407c28cab96ef845e0e6d25500be56aca6394f8bfc9dd/huggingface_hub-1.16.1.tar.gz", upload-time = 2026-05-21T18:40:00Z, size = 792534, hashes = { sha256 = "7f1dc4c5ec21aed69be630ad0c3378616be16f3de1a47b141c0e812965d9c832" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/49/79/621a7dbb80c70974f73a597275351ebe03ce5bc65cb5f8f4acb5859252bc/huggingface_hub-1.16.1-py3-none-any.whl", upload-time = 2026-05-21T18:39:58Z, size = 668176, hashes = { sha256 = "64340de934b9ce37857ef85a82de72f5629e8a270f9119eabb12bf495eb53c22" } }] + +[[packages]] +name = "idna" +version = "3.17" +sdist = { url = "https://files.pythonhosted.org/packages/b9/28/99c51f664567218d824af024c0251650fb27e4ca066df188dab0769c5b91/idna-3.17.tar.gz", upload-time = 2026-05-28T14:32:38Z, size = 196048, hashes = { sha256 = "5eb0cb53bc467c12eadcf6de83163ad8527cec9416f44b9b61b19caedad2b87f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/de/a7/f76514cc40ad6234098ecdebda08732d75964776c51a42845b7da10649e2/idna-3.17-py3-none-any.whl", upload-time = 2026-05-28T14:32:37Z, size = 65316, hashes = { sha256 = "466e48829084efe2548012b855df21540b96f2e20e51bd124c851536556a592c" } }] + +[[packages]] +name = "importlib-metadata" +version = "8.5.0" +sdist = { url = "https://files.pythonhosted.org/packages/cd/12/33e59336dca5be0c398a7482335911a33aa0e20776128f038019f1a95f1b/importlib_metadata-8.5.0.tar.gz", upload-time = 2024-09-11T14:56:08Z, size = 55304, hashes = { sha256 = "71522656f0abace1d072b9e5481a48f07c138e00f079c38c8f883823f9c26bd7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a0/d9/a1e041c5e7caa9a05c925f4bdbdfb7f006d1f74996af53467bc394c97be7/importlib_metadata-8.5.0-py3-none-any.whl", upload-time = 2024-09-11T14:56:07Z, size = 26514, hashes = { sha256 = "45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b" } }] + +[[packages]] +name = "interegular" +version = "0.3.3" +sdist = { url = "https://files.pythonhosted.org/packages/dc/9d/8b6dde58a028a3962ce17e84d5fe73758df61378e00ef8ac3d85da34b0ff/interegular-0.3.3.tar.gz", upload-time = 2024-01-06T23:01:22Z, size = 24705, hashes = { sha256 = "d9b697b21b34884711399ba0f0376914b81899ce670032486d0d048344a76600" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c4/01/72d6472f80651673716d1deda2a5bbb633e563ecf94f4479da5519d69d25/interegular-0.3.3-py37-none-any.whl", upload-time = 2024-01-06T23:01:20Z, size = 23635, hashes = { sha256 = "b0c07007d48c89d6d19f7204972d369b2a77222722e126b6aa63aa721dc3b19c" } }] + +[[packages]] +name = "ipython" +version = "9.13.0" +sdist = { url = "https://files.pythonhosted.org/packages/cd/c4/87cda5842cf5c31837c06ddb588e11c3c35d8ece89b7a0108c06b8c9b00a/ipython-9.13.0.tar.gz", upload-time = 2026-04-24T12:24:55Z, size = 4430549, hashes = { sha256 = "7e834b6afc99f020e3f05966ced34792f40267d64cb1ea9043886dab0dde5967" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b9/86/3060e8029b7cc505cce9a0137431dda81d0a3fde93a8f0f50ee0bf37a795/ipython-9.13.0-py3-none-any.whl", upload-time = 2026-04-24T12:24:53Z, size = 627274, hashes = { sha256 = "57f9d4639e20818d328d287c7b549af3d05f12486ea8f2e7f73e52a36ec4d201" } }] + +[[packages]] +name = "ipython-pygments-lexers" +version = "1.1.1" +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", upload-time = 2025-01-17T11:24:34Z, size = 8393, hashes = { sha256 = "09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", upload-time = 2025-01-17T11:24:33Z, size = 8074, hashes = { sha256 = "a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c" } }] + +[[packages]] +name = "jedi" +version = "0.19.2" +sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", upload-time = 2024-11-11T01:41:42Z, size = 1231287, hashes = { sha256 = "4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", upload-time = 2024-11-11T01:41:40Z, size = 1572278, hashes = { sha256 = "a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9" } }] + +[[packages]] +name = "jinja2" +version = "3.1.6" +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", upload-time = 2025-03-05T20:05:02Z, size = 245115, hashes = { sha256 = "0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", upload-time = 2025-03-05T20:05:00Z, size = 134899, hashes = { sha256 = "85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67" } }] + +[[packages]] +name = "jiter" +version = "0.13.0" +sdist = { url = "https://files.pythonhosted.org/packages/0d/5e/4ec91646aee381d01cdb9974e30882c9cd3b8c5d1079d6b5ff4af522439a/jiter-0.13.0.tar.gz", upload-time = 2026-02-02T12:37:56Z, size = 164847, hashes = { sha256 = "f2839f9c2c7e2dffc1bc5929a510e14ce0a946be9365fd1219e7ef342dae14f4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f8/4c/09b93e30e984a187bc8aaa3510e1ec8dcbdcd71ca05d2f56aac0492453aa/jiter-0.13.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-02-02T12:36:06Z, size = 360735, hashes = { sha256 = "bdaba7d87e66f26a2c45d8cbadcbfc4bf7884182317907baf39cfe9775bb4d93" } }] + +[[packages]] +name = "jsonschema" +version = "4.23.0" +sdist = { url = "https://files.pythonhosted.org/packages/38/2e/03362ee4034a4c917f697890ccd4aec0800ccf9ded7f511971c75451deec/jsonschema-4.23.0.tar.gz", upload-time = 2024-07-08T18:40:05Z, size = 325778, hashes = { sha256 = "d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/69/4a/4f9dbeb84e8850557c02365a0eee0649abe5eb1d84af92a25731c6c0f922/jsonschema-4.23.0-py3-none-any.whl", upload-time = 2024-07-08T18:40:00Z, size = 88462, hashes = { sha256 = "fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566" } }] + +[[packages]] +name = "jsonschema-specifications" +version = "2025.9.1" +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", upload-time = 2025-09-08T01:34:59Z, size = 32855, hashes = { sha256 = "b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", upload-time = 2025-09-08T01:34:57Z, size = 18437, hashes = { sha256 = "98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe" } }] + +[[packages]] +name = "lark" +version = "1.3.1" +sdist = { url = "https://files.pythonhosted.org/packages/da/34/28fff3ab31ccff1fd4f6c7c7b0ceb2b6968d8ea4950663eadcb5720591a0/lark-1.3.1.tar.gz", upload-time = 2025-10-27T18:25:56Z, size = 382732, hashes = { sha256 = "b426a7a6d6d53189d318f2b6236ab5d6429eaf09259f1ca33eb716eed10d2905" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl", upload-time = 2025-10-27T18:25:54Z, size = 113151, hashes = { sha256 = "c629b661023a014c37da873b4ff58a817398d12635d3bbb2c5a03be7fe5d1e12" } }] + +[[packages]] +name = "llguidance" +version = "0.7.30" +sdist = { url = "https://files.pythonhosted.org/packages/bf/38/d1ef3ae08d8d857e5e0690c5b1e07bf7eb4a1cae5881d87215826dc6cadb/llguidance-0.7.30.tar.gz", upload-time = 2025-06-23T00:23:49Z, size = 1055528, hashes = { sha256 = "e93bf75f2b6e48afb86a5cee23038746975e1654672bf5ba0ae75f7d4d4a2248" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/af/80/5a40b9689f17612434b820854cba9b8cabd5142072c491b5280fe5f7a35e/llguidance-0.7.30-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-06-23T00:23:43Z, size = 15004926, hashes = { sha256 = "9edc409b9decd6cffba5f5bf3b4fbd7541f95daa8cbc9510cbf96c6ab1ffc153" } }] + +[[packages]] +name = "loguru" +version = "0.7.3" +sdist = { url = "https://files.pythonhosted.org/packages/3a/05/a1dae3dffd1116099471c643b8924f5aa6524411dc6c63fdae648c4f1aca/loguru-0.7.3.tar.gz", upload-time = 2024-12-06T11:20:56Z, size = 63559, hashes = { sha256 = "19480589e77d47b8d85b2c827ad95d49bf31b0dcde16593892eb51dd18706eb6" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl", upload-time = 2024-12-06T11:20:54Z, size = 61595, hashes = { sha256 = "31a33c10c8e1e10422bfd431aeb5d351c7cf7fa671e3c4df004162264b28220c" } }] + +[[packages]] +name = "lxml" +version = "6.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/28/30/9abc9e34c657c33834eaf6cd02124c61bdf5944d802aa48e69be8da3585d/lxml-6.1.0.tar.gz", upload-time = 2026-04-18T04:32:51Z, size = 4197006, hashes = { sha256 = "bfd57d8008c4965709a919c3e9a98f76c2c7cb319086b3d26858250620023b13" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/7c/e08a970727d556caa040a44773c7b7e3ad0f0d73dedc863543e9a8b931f2/lxml-6.1.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-04-18T04:32:58Z, size = 5093820, hashes = { sha256 = "9147d8e386ec3b82c3b15d88927f734f565b0aaadef7def562b853adca45784a" } }, + { url = "https://files.pythonhosted.org/packages/31/ba/3c13d3fc24b7cacf675f808a3a1baabf43a30d0cd24c98f94548e9aa58eb/lxml-6.1.0-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-18T04:33:06Z, size = 5240445, hashes = { sha256 = "bc783ee3147e60a25aa0445ea82b3e8aabb83b240f2b95d32cb75587ff781814" } }, +] + +[[packages]] +name = "markdown-it-py" +version = "4.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", upload-time = 2025-08-11T12:57:52Z, size = 73070, hashes = { sha256 = "cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", upload-time = 2025-08-11T12:57:51Z, size = 87321, hashes = { sha256 = "87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147" } }] + +[[packages]] +name = "markupsafe" +version = "3.0.3" +sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", upload-time = 2025-09-27T18:37:40Z, size = 80313, hashes = { sha256 = "722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-09-27T18:36:33Z, size = 22947, hashes = { sha256 = "d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d" } }] + +[[packages]] +name = "matplotlib-inline" +version = "0.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/c7/74/97e72a36efd4ae2bccb3463284300f8953f199b5ffbc04cbbb0ec78f74b1/matplotlib_inline-0.2.1.tar.gz", upload-time = 2025-10-23T09:00:22Z, size = 8110, hashes = { sha256 = "e1ee949c340d771fc39e241ea75683deb94762c8fa5f2927ec57c83c4dffa9fe" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/af/33/ee4519fa02ed11a94aef9559552f3b17bb863f2ecfe1a35dc7f548cde231/matplotlib_inline-0.2.1-py3-none-any.whl", upload-time = 2025-10-23T09:00:20Z, size = 9516, hashes = { sha256 = "d56ce5156ba6085e00a9d54fead6ed29a9c47e215cd1bba2e976ef39f5710a76" } }] + +[[packages]] +name = "mdurl" +version = "0.1.2" +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", upload-time = 2022-08-14T12:40:10Z, size = 8729, hashes = { sha256 = "bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", upload-time = 2022-08-14T12:40:09Z, size = 9979, hashes = { sha256 = "84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8" } }] + +[[packages]] +name = "mistral-common" +version = "1.9.1" +sdist = { url = "https://files.pythonhosted.org/packages/db/ce/685b8127a326478e05501cb4c9ca23d1cd9f37e16c465a1e832c75aea709/mistral_common-1.9.1.tar.gz", upload-time = 2026-02-12T10:53:41Z, size = 6338922, hashes = { sha256 = "550583d70a395c3586cfb748ffab53bd1d7c3409507f0efc0118bff30ffb26e9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ac/72/a38bb1fd9fd4d4ef990341c9dd1a7c8061f1951e10efa6d50c0a3f04eced/mistral_common-1.9.1-py3-none-any.whl", upload-time = 2026-02-12T10:53:39Z, size = 6518623, hashes = { sha256 = "9e2b2520b6f67bac2e2bb06fcf985b7a1277b01938da2b7cda8cf0fdbfa92e91" } }] + +[[packages]] +name = "modelscope" +version = "1.40.2" +sdist = { url = "https://files.pythonhosted.org/packages/d7/af/f92c9824db46757dd1b0b5cbf3778daf54e7e44f0e1e6934d0b1bedfb286/modelscope-1.40.2.tar.gz", upload-time = 2026-10-09T09:09:10Z, size = 4566951, hashes = { sha256 = "7a642cef8c144c28c4ddcc37db5fd803f5481f0d78a7f26c2b9e0e2a225b528c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b9/8a/e85b79ee1c541f7bbf208fd7a6185c9b11e50c192b1071b0750db26b09e9/modelscope-1.40.2-py3-none-any.whl", upload-time = 2026-10-09T09:09:07Z, size = 6062299, hashes = { sha256 = "ea03e0ec4a73398a488d3d240cda4f0c5b62390377a134756d4074a3036cb909" } }] + +[[packages]] +name = "modelscope-hub" +version = "0.4.6" +sdist = { url = "https://files.pythonhosted.org/packages/08/d9/ac46c39b957ff44b55c550c641ad5c625ffe3eb5c0b6f20a849b591e9d14/modelscope_hub-0.4.6.tar.gz", upload-time = 2026-10-09T08:08:21Z, size = 298574, hashes = { sha256 = "c54de09be2ccb27b9214f7c3ebe5751121f335f5016643f789589d0547e78c52" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/4d/74/8872ae511d8a336ca918a8d0234cfbccfff0e2304de672882b2768ff628f/modelscope_hub-0.4.6-py3-none-any.whl", upload-time = 2026-10-09T08:08:19Z, size = 237177, hashes = { sha256 = "361bcec229bfbed645a9291ec5b167d76cd94b795207dc2eceba628108f4023a" } }] + +[[packages]] +name = "mpmath" +version = "1.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", upload-time = 2023-03-07T16:47:11Z, size = 508106, hashes = { sha256 = "7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", upload-time = 2023-03-07T16:47:09Z, size = 536198, hashes = { sha256 = "a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c" } }] + +[[packages]] +name = "msgspec" +version = "0.21.1" +sdist = { url = "https://files.pythonhosted.org/packages/e3/60/f79b9b013a16fa3a58350c9295ddc6789f2e335f36ea61ed10a21b215364/msgspec-0.21.1.tar.gz", upload-time = 2026-04-12T21:44:50Z, size = 319193, hashes = { sha256 = "2313508e394b0d208f8f56892ca9b2799e2561329de9763b19619595a6c0f72c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b5/d1/d4cd9fe89c7d400d7a18f86ccc94daa3f0927f53558846fcb60791dce5d6/msgspec-0.21.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-12T21:44:11Z, size = 225025, hashes = { sha256 = "21995e74b5c598c2e004110ad66ec7f1b8c20bf2bcf3b2de8fd9a3094422d3ff" } }] + +[[packages]] +name = "multidict" +version = "6.7.1" +sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", upload-time = 2026-01-26T02:46:45Z, size = 102010, hashes = { sha256 = "ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-01-26T02:44:03Z, size = 256322, hashes = { sha256 = "bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961" } }, + { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", upload-time = 2026-01-26T02:46:44Z, size = 12319, hashes = { sha256 = "55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56" } }, +] + +[[packages]] +name = "multiprocess" +version = "0.70.16" +sdist = { url = "https://files.pythonhosted.org/packages/b5/ae/04f39c5d0d0def03247c2893d6f2b83c136bf3320a2154d7b8858f2ba72d/multiprocess-0.70.16.tar.gz", upload-time = 2024-01-28T18:52:34Z, size = 1772603, hashes = { sha256 = "161af703d4652a0e1410be6abccecde4a7ddffd19341be0a7011b94aeb171ac1" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bc/f7/7ec7fddc92e50714ea3745631f79bd9c96424cb2702632521028e57d3a36/multiprocess-0.70.16-py310-none-any.whl", upload-time = 2024-01-28T18:52:26Z, size = 134824, hashes = { sha256 = "c4a9944c67bd49f823687463660a2d6daae94c289adff97e0f9d696ba6371d02" } }, + { url = "https://files.pythonhosted.org/packages/50/15/b56e50e8debaf439f44befec5b2af11db85f6e0f344c3113ae0be0593a91/multiprocess-0.70.16-py311-none-any.whl", upload-time = 2024-01-28T18:52:28Z, size = 143519, hashes = { sha256 = "af4cabb0dac72abfb1e794fa7855c325fd2b55a10a44628a3c1ad3311c04127a" } }, + { url = "https://files.pythonhosted.org/packages/0a/7d/a988f258104dcd2ccf1ed40fdc97e26c4ac351eeaf81d76e266c52d84e2f/multiprocess-0.70.16-py312-none-any.whl", upload-time = 2024-01-28T18:52:29Z, size = 146741, hashes = { sha256 = "fc0544c531920dde3b00c29863377f87e1632601092ea2daca74e4beb40faa2e" } }, + { url = "https://files.pythonhosted.org/packages/ea/89/38df130f2c799090c978b366cfdf5b96d08de5b29a4a293df7f7429fa50b/multiprocess-0.70.16-py38-none-any.whl", upload-time = 2024-01-28T18:52:30Z, size = 132628, hashes = { sha256 = "a71d82033454891091a226dfc319d0cfa8019a4e888ef9ca910372a446de4435" } }, + { url = "https://files.pythonhosted.org/packages/da/d9/f7f9379981e39b8c2511c9e0326d212accacb82f12fbfdc1aa2ce2a7b2b6/multiprocess-0.70.16-py39-none-any.whl", upload-time = 2024-01-28T18:52:31Z, size = 133351, hashes = { sha256 = "a0bafd3ae1b732eac64be2e72038231c1ba97724b60b09400d68f229fcc2fbf3" } }, +] + +[[packages]] +name = "nest-asyncio" +version = "1.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", upload-time = 2024-01-21T14:25:19Z, size = 7418, hashes = { sha256 = "6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", upload-time = 2024-01-21T14:25:17Z, size = 5195, hashes = { sha256 = "87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c" } }] + +[[packages]] +name = "networkx" +version = "3.6.1" +sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", upload-time = 2025-12-08T17:02:39Z, size = 2517025, hashes = { sha256 = "26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", upload-time = 2025-12-08T17:02:38Z, size = 2068504, hashes = { sha256 = "d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762" } }] + +[[packages]] +name = "ninja" +version = "1.13.2" +sdist = { url = "https://files.pythonhosted.org/packages/ac/92/410b7917d16ab54c04b05cc32b9284803671d91cf79d33be6009c28d4ea8/ninja-1.13.2.tar.gz", upload-time = 2026-08-30T15:49:51Z, size = 243739, hashes = { sha256 = "525bfa3fc88aa30a4467df270fd5be6f9fcae8061d54d4df74ea1dc5abd5a975" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/6e/53/ebfed7b689c338dd8ebeec9c0730c8d56821292f14e2536e5f3ef1a05744/ninja-1.13.2-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-08-30T15:49:34Z, size = 183365, hashes = { sha256 = "65a24341b5ac09fcadcc37082660be40a94174e51a937fabf6e2cae26225fa2c" } }] + +[[packages]] +name = "numpy" +version = "2.4.4" +sdist = { url = "https://files.pythonhosted.org/packages/d7/9f/b8cef5bffa569759033adda9481211426f12f53299629b410340795c2514/numpy-2.4.4.tar.gz", upload-time = 2026-03-29T13:22:01Z, size = 20731587, hashes = { sha256 = "2d390634c5182175533585cc89f3608a4682ccb173cc9bb940b2881c8d6f8fa0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0a/0d/0e3ecece05b7a7e87ab9fb587855548da437a061326fff64a223b6dcb78a/numpy-2.4.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-29T13:19:03Z, size = 16645480, hashes = { sha256 = "81f4a14bee47aec54f883e0cad2d73986640c1590eb9bfaaba7ad17394481e6e" } }] + +[[packages]] +name = "nvidia-cublas-cu12" +version = "12.8.4.1" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/dc/61/e24b560ab2e2eaeb3c839129175fb330dfcfc29e5203196e5541a4c44682/nvidia_cublas_cu12-12.8.4.1-py3-none-manylinux_2_27_x86_64.whl", upload-time = 2025-03-07T01:44:31Z, size = 594346921, hashes = { sha256 = "8ac4e771d5a348c551b2a426eda6193c19aa630236b418086020df5ba9667142" } }] + +[[packages]] +name = "nvidia-cuda-cupti-cu12" +version = "12.8.90" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/f8/02/2adcaa145158bf1a8295d83591d22e4103dbfd821bcaf6f3f53151ca4ffa/nvidia_cuda_cupti_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-03-07T01:40:21Z, size = 10248621, hashes = { sha256 = "ea0cb07ebda26bb9b29ba82cda34849e73c166c18162d3913575b0c9db9a6182" } }] + +[[packages]] +name = "nvidia-cuda-nvrtc-cu12" +version = "12.8.93" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/05/6b/32f747947df2da6994e999492ab306a903659555dddc0fbdeb9d71f75e52/nvidia_cuda_nvrtc_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", upload-time = 2025-03-07T01:42:13Z, size = 88040029, hashes = { sha256 = "a7756528852ef889772a84c6cd89d41dfa74667e24cca16bb31f8f061e3e9994" } }] + +[[packages]] +name = "nvidia-cuda-runtime-cu12" +version = "12.8.90" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/0d/9b/a997b638fcd068ad6e4d53b8551a7d30fe8b404d6f1804abf1df69838932/nvidia_cuda_runtime_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-03-07T01:40:01Z, size = 954765, hashes = { sha256 = "adade8dcbd0edf427b7204d480d6066d33902cab2a4707dcfc48a2d0fd44ab90" } }] + +[[packages]] +name = "nvidia-cudnn-cu12" +version = "9.10.2.21" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/ba/51/e123d997aa098c61d029f76663dedbfb9bc8dcf8c60cbd6adbe42f76d049/nvidia_cudnn_cu12-9.10.2.21-py3-none-manylinux_2_27_x86_64.whl", upload-time = 2025-06-06T21:54:08Z, size = 706758467, hashes = { sha256 = "949452be657fa16687d0930933f032835951ef0892b37d2d53824d1a84dc97a8" } }] + +[[packages]] +name = "nvidia-cudnn-frontend" +version = "1.31.0" +wheels = [{ url = "https://files.pythonhosted.org/packages/cb/24/8ec9de1fd9ea95e1c1cb9e6e2d3a5547aa9c5ece1136d650ffce1bb5d8c5/nvidia_cudnn_frontend-1.31.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-10-08T18:06:15Z, size = 10159344, hashes = { sha256 = "3171f102254136418f24b4470dfa5419f34b03d9d792a4b773cf65c7a37e6bf8" } }] + +[[packages]] +name = "nvidia-cufft-cu12" +version = "11.3.3.83" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/1f/13/ee4e00f30e676b66ae65b4f08cb5bcbb8392c03f54f2d5413ea99a5d1c80/nvidia_cufft_cu12-11.3.3.83-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-03-07T01:45:27Z, size = 193118695, hashes = { sha256 = "4d2dd21ec0b88cf61b62e6b43564355e5222e4a3fb394cac0db101f2dd0d4f74" } }] + +[[packages]] +name = "nvidia-cufile-cu12" +version = "1.13.1.3" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/bb/fe/1bcba1dfbfb8d01be8d93f07bfc502c93fa23afa6fd5ab3fc7c1df71038a/nvidia_cufile_cu12-1.13.1.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-03-07T01:45:50Z, size = 1197834, hashes = { sha256 = "1d069003be650e131b21c932ec3d8969c1715379251f8d23a1860554b1cb24fc" } }] + +[[packages]] +name = "nvidia-curand-cu12" +version = "10.3.9.90" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/fb/aa/6584b56dc84ebe9cf93226a5cde4d99080c8e90ab40f0c27bda7a0f29aa1/nvidia_curand_cu12-10.3.9.90-py3-none-manylinux_2_27_x86_64.whl", upload-time = 2025-03-07T01:46:23Z, size = 63619976, hashes = { sha256 = "b32331d4f4df5d6eefa0554c565b626c7216f87a06a4f56fab27c3b68a830ec9" } }] + +[[packages]] +name = "nvidia-cusolver-cu12" +version = "11.7.3.90" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/85/48/9a13d2975803e8cf2777d5ed57b87a0b6ca2cc795f9a4f59796a910bfb80/nvidia_cusolver_cu12-11.7.3.90-py3-none-manylinux_2_27_x86_64.whl", upload-time = 2025-03-07T01:47:16Z, size = 267506905, hashes = { sha256 = "4376c11ad263152bd50ea295c05370360776f8c3427b30991df774f9fb26c450" } }] + +[[packages]] +name = "nvidia-cusparse-cu12" +version = "12.5.8.93" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/c2/f5/e1854cb2f2bcd4280c44736c93550cc300ff4b8c95ebe370d0aa7d2b473d/nvidia_cusparse_cu12-12.5.8.93-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-03-07T01:48:13Z, size = 288216466, hashes = { sha256 = "1ec05d76bbbd8b61b06a80e1eaf8cf4959c3d4ce8e711b65ebd0443bb0ebb13b" } }] + +[[packages]] +name = "nvidia-cusparselt-cu12" +version = "0.7.1" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/56/79/12978b96bd44274fe38b5dde5cfb660b1d114f70a65ef962bcbbed99b549/nvidia_cusparselt_cu12-0.7.1-py3-none-manylinux2014_x86_64.whl", upload-time = 2025-02-26T00:15:44Z, size = 287193691, hashes = { sha256 = "f1bb701d6b930d5a7cea44c19ceb973311500847f81b634d802b7b539dc55623" } }] + +[[packages]] +name = "nvidia-cutlass-dsl" +version = "4.8.1" +wheels = [{ url = "https://files.pythonhosted.org/packages/bd/ce/a590b929285faf0aa285c5ccee2b88e0b5259fb39a6326206e0f140ea3fc/nvidia_cutlass_dsl-4.8.1-py3-none-any.whl", upload-time = 2026-10-16T10:54:15Z, size = 10510, hashes = { sha256 = "43ed46b21d151aa643c6765457c7310827b938c1cf45d5109a0152de4ef06227" } }] + +[[packages]] +name = "nvidia-cutlass-dsl-libs-base" +version = "4.8.1" +wheels = [{ url = "https://files.pythonhosted.org/packages/28/97/d8212f685544dc7208d78186128dc8a454158b1817a76b34d25392b9f910/nvidia_cutlass_dsl_libs_base-4.8.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-10-16T08:39:52Z, size = 3050567, hashes = { sha256 = "ac2fd8c7fa3d6ded00917fa7cba8686061005da8c4703c6a29e03c1504543909" } }] + +[[packages]] +name = "nvidia-cutlass-dsl-libs-core" +version = "4.8.1" +wheels = [{ url = "https://files.pythonhosted.org/packages/6c/03/1c59e3caf7c8b5cae3ae4d1753201c7e64d36cdf182fb882e070b0f14a55/nvidia_cutlass_dsl_libs_core-4.8.1-py3-none-any.whl", upload-time = 2026-10-16T08:35:00Z, size = 1635096, hashes = { sha256 = "bacc6760e3286db447d45720d32ae58ac2e6cecade1152345ef784b2d5e44431" } }] + +[[packages]] +name = "nvidia-cutlass-dsl-libs-cu12" +version = "4.8.1" +wheels = [{ url = "https://files.pythonhosted.org/packages/11/f4/a4f35a52b8a495b5dd3ad7b466567b3dbec656442811085ca1cb7d4a1d97/nvidia_cutlass_dsl_libs_cu12-4.8.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-10-16T10:41:51Z, size = 91697915, hashes = { sha256 = "440b88739120c65d96c5f15bbe496a3bd7c26392874d5af6061d38497f84c70c" } }] + +[[packages]] +name = "nvidia-cutlass-dsl-libs-cu13" +version = "4.8.1" +wheels = [{ url = "https://files.pythonhosted.org/packages/a1/f2/0497bd834c92c8f30d6927388a91903e8e995ab7d1b5cbead87f0fd7187f/nvidia_cutlass_dsl_libs_cu13-4.8.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-10-16T10:48:43Z, size = 91954433, hashes = { sha256 = "50191a381d8cc1393373ae0bc879b0aefa9a256c23c22d4fa1c2fe3dfe57bc90" } }] + +[[packages]] +name = "nvidia-ml-py" +version = "13.595.45" +sdist = { url = "https://files.pythonhosted.org/packages/ce/49/c29f6e30d8662d2e94fef17739ea7309cc76aba269922ae999e4cc07f268/nvidia_ml_py-13.595.45.tar.gz", upload-time = 2026-03-19T16:59:44Z, size = 50780, hashes = { sha256 = "c9f34897fe0441ff35bc8f35baf80f830a20b0f4e6ce71e0a325bc0e66acf079" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8a/24/fc256107d23597fa33d319505ce77160fa1a2349c096d01901ffc7cb7fc4/nvidia_ml_py-13.595.45-py3-none-any.whl", upload-time = 2026-03-19T16:59:43Z, size = 51776, hashes = { sha256 = "b65a7977f503d56154b14d683710125ef93594adb63fbf7e559336e3318f1376" } }] + +[[packages]] +name = "nvidia-nccl-cu12" +version = "2.27.5" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/6e/89/f7a07dc961b60645dbbf42e80f2bc85ade7feb9a491b11a1e973aa00071f/nvidia_nccl_cu12-2.27.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-06-26T04:11:28Z, size = 322348229, hashes = { sha256 = "ad730cf15cb5d25fe849c6e6ca9eb5b76db16a80f13f425ac68d8e2e55624457" } }] + +[[packages]] +name = "nvidia-nvjitlink-cu12" +version = "12.8.93" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/f6/74/86a07f1d0f42998ca31312f998bd3b9a7eff7f52378f4f270c8679c77fb9/nvidia_nvjitlink_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", upload-time = 2025-03-07T01:49:55Z, size = 39254836, hashes = { sha256 = "81ff63371a7ebd6e6451970684f916be2eab07321b73c9d244dc2b4da7f73b88" } }] + +[[packages]] +name = "nvidia-nvshmem-cu12" +version = "3.3.20" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/3b/6c/99acb2f9eb85c29fc6f3a7ac4dccfd992e22666dd08a642b303311326a97/nvidia_nvshmem_cu12-3.3.20-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-08-04T20:25:19Z, size = 124657145, hashes = { sha256 = "d00f26d3f9b2e3c3065be895e3059d6479ea5c638a3f38c9fec49b1b9dd7c1e5" } }] + +[[packages]] +name = "nvidia-nvtx-cu12" +version = "12.8.90" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/a2/eb/86626c1bbc2edb86323022371c39aa48df6fd8b0a1647bc274577f72e90b/nvidia_nvtx_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-03-07T01:42:44Z, size = 89954, hashes = { sha256 = "5b17e2001cc0d751a5bc2c6ec6d26ad95913324a4adb86788c944f8ce9ba441f" } }] + +[[packages]] +name = "openai" +version = "2.6.1" +sdist = { url = "https://files.pythonhosted.org/packages/c4/44/303deb97be7c1c9b53118b52825cbd1557aeeff510f3a52566b1fa66f6a2/openai-2.6.1.tar.gz", upload-time = 2025-10-24T13:29:52Z, size = 593043, hashes = { sha256 = "27ae704d190615fca0c0fc2b796a38f8b5879645a3a52c9c453b23f97141bb49" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/15/0e/331df43df633e6105ff9cf45e0ce57762bd126a45ac16b25a43f6738d8a2/openai-2.6.1-py3-none-any.whl", upload-time = 2025-10-24T13:29:50Z, size = 1005551, hashes = { sha256 = "904e4b5254a8416746a2f05649594fa41b19d799843cd134dac86167e094edef" } }] + +[[packages]] +name = "openai-harmony" +version = "0.0.4" +sdist = { url = "https://files.pythonhosted.org/packages/92/94/01509d510bebf6606614e51113e5a415ced15b8f34aa98a8bf2539314650/openai_harmony-0.0.4.tar.gz", upload-time = 2025-08-09T01:43:24Z, size = 279848, hashes = { sha256 = "5c67ac6df349236fb7b64f57c3dbb0273efcdca24314daa108f2a482c427106c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1f/ec/dcdcace0ffcf3a532cca910e0c351b62d3a7decf0b091ea8cf856d2a67a6/openai_harmony-0.0.4-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-08-09T01:43:11Z, size = 3049306, hashes = { sha256 = "31e9bcac0902a309e2fc688e52f247eec7fffcd00d17e958b9a83a8fea6519c2" } }] + +[[packages]] +name = "opentelemetry-api" +version = "1.41.1" +sdist = { url = "https://files.pythonhosted.org/packages/fa/fc/b7564cbef36601aef0d6c9bc01f7badb64be8e862c2e1c3c5c3b43b53e4f/opentelemetry_api-1.41.1.tar.gz", upload-time = 2026-04-24T13:15:38Z, size = 71416, hashes = { sha256 = "0ad1814d73b875f84494387dae86ce0b12c68556331ce6ce8fe789197c949621" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/29/59/3e7118ed140f76b0982ba4321bdaed1997a0473f9720de2d10788a577033/opentelemetry_api-1.41.1-py3-none-any.whl", upload-time = 2026-04-24T13:15:15Z, size = 69007, hashes = { sha256 = "a22df900e75c76dc08440710e51f52f1aa6b451b429298896023e60db5b3139f" } }] + +[[packages]] +name = "orjson" +version = "3.11.8" +sdist = { url = "https://files.pythonhosted.org/packages/9d/1b/2024d06792d0779f9dbc51531b61c24f76c75b9f4ce05e6f3377a1814cea/orjson-3.11.8.tar.gz", upload-time = 2026-03-31T16:16:27Z, size = 5603832, hashes = { sha256 = "96163d9cdc5a202703e9ad1b9ae757d5f0ca62f4fa0cc93d1f27b0e180cc404e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/37/87/5ddeb7fc1fbd9004aeccab08426f34c81a5b4c25c7061281862b015fce2b/orjson-3.11.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-03-31T16:15:22Z, size = 133624, hashes = { sha256 = "53a0f57e59a530d18a142f4d4ba6dfc708dc5fdedce45e98ff06b44930a2a48f" } }] + +[[packages]] +name = "outlines" +version = "0.1.11" +sdist = { url = "https://files.pythonhosted.org/packages/ac/d0/d59ae830bf7026425942899e3d48e77b58a713cff946a695e5405808da1b/outlines-0.1.11.tar.gz", upload-time = 2024-12-13T07:24:08Z, size = 2488858, hashes = { sha256 = "0997bd9da1cc050e430bd08995dc7d4bd855918bafa4531e49d3f37110a23aba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/13/b4/99ea4a122bef60e3fd6402d19665aff1f928e0daf8fac3044d0b73f72003/outlines-0.1.11-py3-none-any.whl", upload-time = 2024-12-13T07:24:05Z, size = 87623, hashes = { sha256 = "f5a5f2242ed9802d3aab7a92789bf4008d734c576be9258cc0a297f690124727" } }] + +[[packages]] +name = "outlines-core" +version = "0.1.26" +sdist = { url = "https://files.pythonhosted.org/packages/d3/f3/274d07f4702728b43581235a77e545ec602b25f9b0098b288a0f3052521d/outlines_core-0.1.26.tar.gz", upload-time = 2024-12-12T23:38:50Z, size = 75139, hashes = { sha256 = "481c4301341e77cc8f1832d616784adb4d461b4fec65878e7c0d2cba7163a189" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e2/1d/a36292b6198986bd9c3ff8c24355deb82ed5475403379ee40b5b5473e2e3/outlines_core-0.1.26-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2024-12-12T23:38:34Z, size = 343201, hashes = { sha256 = "e86a1bb46adc5cbf6dfd7a7fe4105e0e2a4c6e041732a053126b41c521a1f223" } }] + +[[packages]] +name = "packaging" +version = "24.2" +sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", upload-time = 2024-11-08T09:47:47Z, size = 163950, hashes = { sha256 = "c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", upload-time = 2024-11-08T09:47:44Z, size = 65451, hashes = { sha256 = "09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759" } }] + +[[packages]] +name = "pandas" +version = "2.3.3" +sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", upload-time = 2025-09-29T23:34:51Z, size = 4495223, hashes = { sha256 = "e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e5/63/cd7d615331b328e287d8233ba9fdf191a9c2d11b6af0c7a59cfcec23de68/pandas-2.3.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-09-29T23:20:14Z, size = 12362693, hashes = { sha256 = "b3d11d2fda7eb164ef27ffc14b4fcab16a80e1ce67e9f57e19ec0afaf715ba89" } }] + +[[packages]] +name = "parso" +version = "0.8.6" +sdist = { url = "https://files.pythonhosted.org/packages/81/76/a1e769043c0c0c9fe391b702539d594731a4362334cdf4dc25d0c09761e7/parso-0.8.6.tar.gz", upload-time = 2026-02-09T15:45:24Z, size = 401621, hashes = { sha256 = "2b9a0332696df97d454fa67b81618fd69c35a7b90327cbe6ba5c92d2c68a7bfd" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b6/61/fae042894f4296ec49e3f193aff5d7c18440da9e48102c3315e1bc4519a7/parso-0.8.6-py2.py3-none-any.whl", upload-time = 2026-02-09T15:45:21Z, size = 106894, hashes = { sha256 = "2c549f800b70a5c4952197248825584cb00f033b29c692671d3bf08bf380baff" } }] + +[[packages]] +name = "partial-json-parser" +version = "0.2.1.1.post7" +sdist = { url = "https://files.pythonhosted.org/packages/6a/6d/eed37d7ebc1e0bcd27b831c0cf1fe94881934316187c4b30d23f29ea0bd4/partial_json_parser-0.2.1.1.post7.tar.gz", upload-time = 2025-11-17T07:27:41Z, size = 10296, hashes = { sha256 = "86590e1ba6bcb6739a2dfc17d2323f028cb5884f4c6ce23db376999132c9a922" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/42/32/658973117bf0fd82a24abbfb94fe73a5e86216e49342985e10acce54775a/partial_json_parser-0.2.1.1.post7-py3-none-any.whl", upload-time = 2025-11-17T07:27:40Z, size = 10877, hashes = { sha256 = "145119e5eabcf80cbb13844a6b50a85c68bf99d376f8ed771e2a3c3b03e653ae" } }] + +[[packages]] +name = "pexpect" +version = "4.9.0" +marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", upload-time = 2023-11-25T09:07:26Z, size = 166450, hashes = { sha256 = "ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", upload-time = 2023-11-25T06:56:14Z, size = 63772, hashes = { sha256 = "7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523" } }] + +[[packages]] +name = "pillow" +version = "12.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/1c/3d/bb7fca845737cf9d7dbde16ed1843984665ff2e0a518f5db43e77ec540b9/pillow-12.3.0.tar.gz", upload-time = 2026-07-01T11:56:38Z, size = 47025035, hashes = { sha256 = "3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/84/21/a35af28dcc61f37ed850a2d64c65c701321dfbf25085e469d5559360cbbf/pillow-12.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-01T11:54:13Z, size = 6940830, hashes = { sha256 = "78cb2c6865a35ab8ff8b75fd122f6033b92a62c82801110e48ddd6c936a45d91" } }] + +[[packages]] +name = "prometheus-client" +version = "0.26.0" +sdist = { url = "https://files.pythonhosted.org/packages/52/73/f1334c29c2af4cd9dba6c7817e61b611bd0215e2eb5565c6064a4de18802/prometheus_client-0.26.0.tar.gz", upload-time = 2026-07-24T19:36:41Z, size = 92910, hashes = { sha256 = "04a91bcf94e2cf74a44a1a874d651a2e853ed354b6e822f3b7487751465d5c2b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/eb/a3/b69efbf4143b5b9859b977770bbbabcc2796b702fa69dc40271e45cd5a56/prometheus_client-0.26.0-py3-none-any.whl", upload-time = 2026-07-24T19:36:40Z, size = 64494, hashes = { sha256 = "fa93d06737aa02bacd05794768508bb97d2fbee28cb3bca04eaae92f0ca953d6" } }] + +[[packages]] +name = "prompt-toolkit" +version = "3.0.52" +sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", upload-time = 2025-08-27T15:24:02Z, size = 434198, hashes = { sha256 = "28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", upload-time = 2025-08-27T15:23:59Z, size = 391431, hashes = { sha256 = "9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955" } }] + +[[packages]] +name = "propcache" +version = "0.4.1" +sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", upload-time = 2025-10-08T19:49:02Z, size = 46442, hashes = { sha256 = "f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/46/4b/3aae6835b8e5f44ea6a68348ad90f78134047b503765087be2f9912140ea/propcache-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-10-08T19:46:54Z, size = 221575, hashes = { sha256 = "15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf" } }, + { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", upload-time = 2025-10-08T19:49:00Z, size = 13305, hashes = { sha256 = "af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237" } }, +] + +[[packages]] +name = "protobuf" +version = "6.33.6" +sdist = { url = "https://files.pythonhosted.org/packages/66/70/e908e9c5e52ef7c3a6c7902c9dfbb34c7e29c25d2f81ade3856445fd5c94/protobuf-6.33.6.tar.gz", upload-time = 2026-03-18T19:05:00Z, size = 444531, hashes = { sha256 = "a6768d25248312c297558af96a9f9c929e8c4cee0659cb07e780731095f38135" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/16/92/d1e32e3e0d894fe00b15ce28ad4944ab692713f2e7f0a99787405e43533a/protobuf-6.33.6-cp39-abi3-manylinux2014_x86_64.whl", upload-time = 2026-03-18T19:04:55Z, size = 323436, hashes = { sha256 = "e9db7e292e0ab79dd108d7f1a94fe31601ce1ee3f7b79e0692043423020b0593" } }, + { url = "https://files.pythonhosted.org/packages/c4/72/02445137af02769918a93807b2b7890047c32bfb9f90371cbc12688819eb/protobuf-6.33.6-py3-none-any.whl", upload-time = 2026-03-18T19:04:59Z, size = 170656, hashes = { sha256 = "77179e006c476e69bf8e8ce866640091ec42e1beb80b213c3900006ecfba6901" } }, +] + +[[packages]] +name = "psutil" +version = "7.2.2" +sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", upload-time = 2026-01-28T18:14:54Z, size = 493740, hashes = { sha256 = "0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-01-28T18:15:25Z, size = 155560, hashes = { sha256 = "076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9" } }] + +[[packages]] +name = "ptyprocess" +version = "0.7.0" +marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", upload-time = 2020-12-28T15:15:30Z, size = 70762, hashes = { sha256 = "5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", upload-time = 2020-12-28T15:15:28Z, size = 13993, hashes = { sha256 = "4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35" } }] + +[[packages]] +name = "pure-eval" +version = "0.2.3" +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", upload-time = 2024-07-21T12:58:21Z, size = 19752, hashes = { sha256 = "5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", upload-time = 2024-07-21T12:58:20Z, size = 11842, hashes = { sha256 = "1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0" } }] + +[[packages]] +name = "py-spy" +version = "0.4.2" +sdist = { url = "https://files.pythonhosted.org/packages/93/d8/5b71371f50cf153b1307e5a11ac8a4ce4d85651dae946bd7e9a064146545/py_spy-0.4.2.tar.gz", upload-time = 2026-04-24T22:08:54Z, size = 286374, hashes = { sha256 = "90e600b27bb6bb40479637baca5a5b4bc2ba3395c93d889e672315d93042c4ae" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f9/34/dd7d3c763a00b7b965e25a5eab0acd1a345dbaf0f45fffe595278873a1c0/py_spy-0.4.2-py2.py3-none-manylinux_2_5_x86_64.manylinux1_x86_64.whl", upload-time = 2026-04-24T22:08:52Z, size = 2936518, hashes = { sha256 = "aeb0323409199c785f730645e9f4bb7a7b9ca2c481f2c331a55642b5d13fa52f" } }] + +[[packages]] +name = "pyarrow" +version = "23.0.1" +sdist = { url = "https://files.pythonhosted.org/packages/88/22/134986a4cc224d593c1afde5494d18ff629393d74cc2eddb176669f234a4/pyarrow-23.0.1.tar.gz", upload-time = 2026-02-16T10:14:12Z, size = 1167336, hashes = { sha256 = "b8c5873e33440b2bc2f4a79d2b47017a89c5a24116c055625e6f2ee50523f019" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2c/a5/da83046273d990f256cb79796a190bbf7ec999269705ddc609403f8c6b06/pyarrow-23.0.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-02-16T10:10:17Z, size = 47586063, hashes = { sha256 = "813d99f31275919c383aab17f0f455a04f5a429c261cc411b1e9a8f5e4aaaa05" } }] + +[[packages]] +name = "pybase64" +version = "1.4.3" +sdist = { url = "https://files.pythonhosted.org/packages/aa/b8/4ed5c7ad5ec15b08d35cc79ace6145d5c1ae426e46435f4987379439dfea/pybase64-1.4.3.tar.gz", upload-time = 2025-12-06T13:27:04Z, size = 137272, hashes = { sha256 = "c2ed274c9e0ba9c8f9c4083cfe265e66dd679126cd9c2027965d807352f3f053" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/62/f7/965b79ff391ad208b50e412b5d3205ccce372a2d27b7218ae86d5295b105/pybase64-1.4.3-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2025-12-06T13:23:20Z, size = 71599, hashes = { sha256 = "bb632edfd132b3eaf90c39c89aa314beec4e946e210099b57d40311f704e11d4" } }] + +[[packages]] +name = "pycountry" +version = "26.2.16" +sdist = { url = "https://files.pythonhosted.org/packages/de/1d/061b9e7a48b85cfd69f33c33d2ef784a531c359399ad764243399673c8f5/pycountry-26.2.16.tar.gz", upload-time = 2026-02-17T03:42:52Z, size = 7711342, hashes = { sha256 = "5b6027d453fcd6060112b951dd010f01f168b51b4bf8a1f1fc8c95c8d94a0801" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9c/42/7703bd45b62fecd44cd7d3495423097e2f7d28bc2e99e7c1af68892ab157/pycountry-26.2.16-py3-none-any.whl", upload-time = 2026-02-17T03:42:49Z, size = 8044600, hashes = { sha256 = "115c4baf7cceaa30f59a4694d79483c9167dbce7a9de4d3d571c5f3ea77c305a" } }] + +[[packages]] +name = "pycparser" +version = "3.0" +marker = "implementation_name != 'PyPy'" +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", upload-time = 2026-01-21T14:26:51Z, size = 103492, hashes = { sha256 = "600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", upload-time = 2026-01-21T14:26:50Z, size = 48172, hashes = { sha256 = "b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992" } }] + +[[packages]] +name = "pycryptodomex" +version = "3.24.1" +sdist = { url = "https://files.pythonhosted.org/packages/f4/e7/50e72301e32acb73a314e663c2014e1ddefc019d5f434ff14ec89861d664/pycryptodomex-3.24.1.tar.gz", upload-time = 2026-10-11T19:26:49Z, size = 4934627, hashes = { sha256 = "09081666ffc599976c0b8b29caf2cf82212c0f05bed233c8f8ed53e4f6e1d356" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/cf/93/a954b7a8746980e31648943e29772aca0311d0d8a407a3adf5788083b693/pycryptodomex-3.24.1-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-10-11T19:26:17Z, size = 2280275, hashes = { sha256 = "9b94a8c647c1f80b4c82c7ac9642dda94a71abbb4efa29ad652c410ad7a39879" } }] + +[[packages]] +name = "pydantic" +version = "2.12.5" +sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", upload-time = 2025-11-26T15:11:46Z, size = 821591, hashes = { sha256 = "4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", upload-time = 2025-11-26T15:11:44Z, size = 463580, hashes = { sha256 = "e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d" } }] + +[[packages]] +name = "pydantic-core" +version = "2.41.5" +sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", upload-time = 2025-11-04T13:43:49Z, size = 460952, hashes = { sha256 = "08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-04T13:40:09Z, size = 2075366, hashes = { sha256 = "eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c" } }] + +[[packages]] +name = "pydantic-extra-types" +version = "2.11.1" +sdist = { url = "https://files.pythonhosted.org/packages/66/71/dba38ee2651f84f7842206adbd2233d8bbdb59fb85e9fa14232486a8c471/pydantic_extra_types-2.11.1.tar.gz", upload-time = 2026-03-16T08:08:03Z, size = 172002, hashes = { sha256 = "46792d2307383859e923d8fcefa82108b1a141f8a9c0198982b3832ab5ef1049" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/17/c1/3226e6d7f5a4f736f38ac11a6fbb262d701889802595cdb0f53a885ac2e0/pydantic_extra_types-2.11.1-py3-none-any.whl", upload-time = 2026-03-16T08:08:02Z, size = 79526, hashes = { sha256 = "1722ea2bddae5628ace25f2aa685b69978ef533123e5638cfbddb999e0100ec1" } }] + +[[packages]] +name = "pygments" +version = "2.20.0" +sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", upload-time = 2026-03-29T13:29:33Z, size = 4955991, hashes = { sha256 = "6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", upload-time = 2026-03-29T13:29:30Z, size = 1231151, hashes = { sha256 = "81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176" } }] + +[[packages]] +name = "pyproject-hooks" +version = "1.2.0" +sdist = { url = "https://files.pythonhosted.org/packages/e7/82/28175b2414effca1cdac8dc99f76d660e7a4fb0ceefa4b4ab8f5f6742925/pyproject_hooks-1.2.0.tar.gz", upload-time = 2024-09-29T09:24:13Z, size = 19228, hashes = { sha256 = "1e859bd5c40fae9448642dd871adf459e5e2084186e8d2c2a79a824c970da1f8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/bd/24/12818598c362d7f300f18e74db45963dbcb85150324092410c8b49405e42/pyproject_hooks-1.2.0-py3-none-any.whl", upload-time = 2024-09-29T09:24:11Z, size = 10216, hashes = { sha256 = "9e5c6bfa8dcc30091c74b0cf803c81fdd29d94f01992a7707bc97babb1141913" } }] + +[[packages]] +name = "python-dateutil" +version = "2.9.0.post0" +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", upload-time = 2024-03-01T18:36:20Z, size = 342432, hashes = { sha256 = "37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", upload-time = 2024-03-01T18:36:18Z, size = 229892, hashes = { sha256 = "a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427" } }] + +[[packages]] +name = "python-multipart" +version = "0.0.32" +sdist = { url = "https://files.pythonhosted.org/packages/5b/42/55c32bb9b12693c092ad250a0e82edb5b31ddeda6eb772de5f308b3804ad/python_multipart-0.0.32.tar.gz", upload-time = 2026-06-04T16:18:58Z, size = 46881, hashes = { sha256 = "be54b7f3fa167bb83e4fcd936b887b708f4e57fe75911c02aebf53efaf8d938e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e1/04/e8135ebd1ad02c56ec633277529b2602ff99ff634be76cdba5744cf554fd/python_multipart-0.0.32-py3-none-any.whl", upload-time = 2026-06-04T16:18:57Z, size = 30042, hashes = { sha256 = "ff6d3f776f16878c894e52e107296ffc890e913c611b1a4ec6c44e2821fe2e23" } }] + +[[packages]] +name = "pytz" +version = "2026.1.post1" +sdist = { url = "https://files.pythonhosted.org/packages/56/db/b8721d71d945e6a8ac63c0fc900b2067181dbb50805958d4d4661cf7d277/pytz-2026.1.post1.tar.gz", upload-time = 2026-03-03T07:47:50Z, size = 321088, hashes = { sha256 = "3378dde6a0c3d26719182142c56e60c7f9af7e968076f31aae569d72a0358ee1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/10/99/781fe0c827be2742bcc775efefccb3b048a3a9c6ce9aec0cbf4a101677e5/pytz-2026.1.post1-py2.py3-none-any.whl", upload-time = 2026-03-03T07:47:49Z, size = 510489, hashes = { sha256 = "f2fd16142fda348286a75e1a524be810bb05d444e5a081f37f7affc635035f7a" } }] + +[[packages]] +name = "pyyaml" +version = "6.0.3" +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", upload-time = 2025-09-25T21:33:16Z, size = 130960, hashes = { sha256 = "d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-09-25T21:32:16Z, size = 807870, hashes = { sha256 = "ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc" } }] + +[[packages]] +name = "pyzmq" +version = "27.2.0" +sdist = { url = "https://files.pythonhosted.org/packages/e7/8d/5b3d5631c2f4b4b8862f64cd0c9eb777b5710eeb5125b4be8dd0a200a4c0/pyzmq-27.2.0.tar.gz", upload-time = 2026-08-20T19:08:21Z, size = 292316, hashes = { sha256 = "54d4259d1bfae24ecdb5ca79f7acc2eac6c286a02d6a0ae617797cb45f0726d3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/62/2c/d5828306f795e8d34676d266823b74e2101e0ad3760d12083de3e02abbb2/pyzmq-27.2.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-08-20T19:06:44Z, size = 872258, hashes = { sha256 = "dea74fd65f1fc5f7fe167916a473ebe6ed6174e5e5d9de11ea6583661be6cf43" } }] + +[[packages]] +name = "quack-kernels" +version = "0.6.5" +sdist = { url = "https://files.pythonhosted.org/packages/5f/18/6c2a20d00dff254f154fb3b951f4e5a0377a60122c17385e5f08d5f5b5e1/quack_kernels-0.6.5.tar.gz", upload-time = 2026-09-11T05:08:20Z, size = 846876, hashes = { sha256 = "dd9405a4a6fa35fc3a5a18fe35b46a14b0bf7e3ad9fe2451903e355047ac471d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/73/d8/f5e56c38b286308d115a171e3c5c44f24e9d03980c3cfd22588df40261fa/quack_kernels-0.6.5-py3-none-any.whl", upload-time = 2026-09-11T05:08:19Z, size = 729615, hashes = { sha256 = "df1ddd31366c82eb9692fe087c671209189dcbde53c909c81a865d4ee66b158d" } }] + +[[packages]] +name = "referencing" +version = "0.37.0" +sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", upload-time = 2025-10-13T15:30:48Z, size = 78036, hashes = { sha256 = "44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", upload-time = 2025-10-13T15:30:47Z, size = 26766, hashes = { sha256 = "381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231" } }] + +[[packages]] +name = "regex" +version = "2026.4.4" +sdist = { url = "https://files.pythonhosted.org/packages/cb/0e/3a246dbf05666918bd3664d9d787f84a9108f6f43cc953a077e4a7dfdb7e/regex-2026.4.4.tar.gz", upload-time = 2026-04-03T20:56:28Z, size = 416000, hashes = { sha256 = "e08270659717f6973523ce3afbafa53515c4dc5dcad637dc215b6fd50f689423" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/11/0e/a9f6f81013e0deaf559b25711623864970fe6a098314e374ccb1540a4152/regex-2026.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-03T20:53:51Z, size = 801126, hashes = { sha256 = "993f657a7c1c6ec51b5e0ba97c9817d06b84ea5fa8d82e43b9405de0defdc2b9" } }] + +[[packages]] +name = "requests" +version = "2.33.1" +sdist = { url = "https://files.pythonhosted.org/packages/5f/a4/98b9c7c6428a668bf7e42ebb7c79d576a1c3c1e3ae2d47e674b468388871/requests-2.33.1.tar.gz", upload-time = 2026-03-30T16:09:15Z, size = 134120, hashes = { sha256 = "18817f8c57c6263968bc123d237e3b8b08ac046f5456bd1e307ee8f4250d3517" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", upload-time = 2026-03-30T16:09:13Z, size = 64947, hashes = { sha256 = "4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a" } }] + +[[packages]] +name = "rich" +version = "13.9.4" +sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", upload-time = 2024-11-01T16:43:57Z, size = 223149, hashes = { sha256 = "439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", upload-time = 2024-11-01T16:43:55Z, size = 242424, hashes = { sha256 = "6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90" } }] + +[[packages]] +name = "rpds-py" +version = "0.30.0" +sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", upload-time = 2025-11-30T20:24:38Z, size = 69469, hashes = { sha256 = "dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/60/1b/6f8f29f3f995c7ffdde46a626ddccd7c63aefc0efae881dc13b6e5d5bb16/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-30T20:22:27Z, size = 394080, hashes = { sha256 = "47f236970bccb2233267d89173d3ad2703cd36a0e2a6e92d0560d333871a3d23" } }] + +[[packages]] +name = "safetensors" +version = "0.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/29/9c/6e74567782559a63bd040a236edca26fd71bc7ba88de2ef35d75df3bca5e/safetensors-0.7.0.tar.gz", upload-time = 2025-11-19T15:18:43Z, size = 200878, hashes = { sha256 = "07663963b67e8bd9f0b8ad15bb9163606cd27cc5a1b96235a50d8369803b96b0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a0/60/429e9b1cb3fc651937727befe258ea24122d9663e4d5709a48c9cbfceecb/safetensors-0.7.0-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-19T15:18:33Z, size = 507152, hashes = { sha256 = "dac7252938f0696ddea46f5e855dd3138444e82236e3be475f54929f0c510d48" } }] + +[[packages]] +name = "scipy" +version = "1.17.1" +sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", upload-time = 2026-02-23T00:26:24Z, size = 30573822, hashes = { sha256 = "95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/01/8e/1e35281b8ab6d5d72ebe9911edcdffa3f36b04ed9d51dec6dd140396e220/scipy-1.17.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-02-23T00:18:49Z, size = 35235890, hashes = { sha256 = "02ae3b274fde71c5e92ac4d54bc06c42d80e399fec704383dcd99b301df37458" } }] + +[[packages]] +name = "sentencepiece" +version = "0.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/15/15/2e7a025fc62d764b151ae6d0f2a92f8081755ebe8d4a64099accc6f77ba6/sentencepiece-0.2.1.tar.gz", upload-time = 2025-08-12T07:00:51Z, size = 3228515, hashes = { sha256 = "8138cec27c2f2282f4a34d9a016e3374cd40e5c6e9cb335063db66a0a3b71fad" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/04/88/14f2f4a2b922d8b39be45bf63d79e6cd3a9b2f248b2fcb98a69b12af12f5/sentencepiece-0.2.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-08-12T06:59:46Z, size = 1387881, hashes = { sha256 = "0cdfecef430d985f1c2bcbfff3defd1d95dae876fbd0173376012d2d7d24044b" } }] + +[[packages]] +name = "setproctitle" +version = "1.3.8" +sdist = { url = "https://files.pythonhosted.org/packages/49/b0/6b8a516c5a9e9630bd5293db78314ac012f690305fe93beadea388626efb/setproctitle-1.3.8.tar.gz", upload-time = 2026-10-01T21:09:27Z, size = 27214, hashes = { sha256 = "cafe209d064a6efb88cb45a03e97981ff8832802b2b5d009dde0197a3b7b41c8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/cb/21/4df9fbc0c72b9bca39b5d53eff6813dc1738a1562983e0c614054e9dbb8d/setproctitle-1.3.8-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2026-10-01T20:59:09Z, size = 32929, hashes = { sha256 = "4a765e0c80a2453480be27c4fc22ba1c0771867040c5f91e4221940d78a4abfb" } }] + +[[packages]] +name = "setuptools" +version = "83.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/34/26/f5d29e25ffdb535afef2d35cdb55b325298f96debd670da4c325e08d70f4/setuptools-83.0.0.tar.gz", upload-time = 2026-07-04T15:31:22Z, size = 1154254, hashes = { sha256 = "025bccbbf0fa05b6192bc64ae1e7b16e001fd6d6d4d5de03c97b1c1ade523bef" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5d/40/e1e72872c6354b306daef1703549e8e83b4d43cfea356311bf722a043752/setuptools-83.0.0-py3-none-any.whl", upload-time = 2026-07-04T15:31:20Z, size = 1008090, hashes = { sha256 = "29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3" } }] + +[[packages]] +name = "sglang" +version = "0.5.10.post1" +sdist = { url = "https://files.pythonhosted.org/packages/42/38/feb04f6478b90315606fcd62b798917e7fcee9f1d7d84b01cf477398045e/sglang-0.5.10.post1.tar.gz", upload-time = 2026-04-08T22:20:07Z, size = 4701855, hashes = { sha256 = "01f7adfe7cde85b238fb0e1bae4b31d494e19d1471cf35ff3c5489a02f9d2263" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/15/26/f6b6fc49166a716cf79787555118dfe6254786fa1d9c01be0fea17b4f578/sglang-0.5.10.post1-py3-none-any.whl", upload-time = 2026-04-08T22:20:05Z, size = 6064493, hashes = { sha256 = "a854a68b11caf6b4b55c241a44378a7cdede7ede325db85c955f131506703bc6" } }] + +[[packages]] +name = "sglang-kernel" +version = "0.4.1" +wheels = [{ url = "https://files.pythonhosted.org/packages/97/26/d4a84be6587b57d20214cc2ee1e7f41b7e3336df357c45a833f25b1f1abf/sglang_kernel-0.4.1-cp310-abi3-manylinux2014_x86_64.whl", upload-time = 2026-04-03T09:28:02Z, size = 352149358, hashes = { sha256 = "64ab5df34264cdffc36e25fee429dcafe2e204cae73cc1f9736a4e5ab97aa206" } }] + +[[packages]] +name = "shellingham" +version = "1.5.4" +sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", upload-time = 2023-10-24T04:13:40Z, size = 10310, hashes = { sha256 = "8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", upload-time = 2023-10-24T04:13:38Z, size = 9755, hashes = { sha256 = "7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686" } }] + +[[packages]] +name = "six" +version = "1.17.0" +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", upload-time = 2024-12-04T17:35:28Z, size = 34031, hashes = { sha256 = "ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", upload-time = 2024-12-04T17:35:26Z, size = 11050, hashes = { sha256 = "4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274" } }] + +[[packages]] +name = "smg-grpc-proto" +version = "0.4.10" +sdist = { url = "https://files.pythonhosted.org/packages/70/c4/e7fd91bf161fcaeb9c19e5fba73e54f7501bd310078d644700e627c4d7f9/smg_grpc_proto-0.4.10.tar.gz", upload-time = 2026-06-11T16:10:05Z, size = 19304, hashes = { sha256 = "5415618d252e5a2b43d1dbbd2c1eae305760070dd24735308140aed06a7486be" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/67/0d/d2f57ac38d2ecc9593ade6ee99953c2b2ea27e10e9532f69e3c47d2528dc/smg_grpc_proto-0.4.10-py3-none-any.whl", upload-time = 2026-06-11T16:10:04Z, size = 81122, hashes = { sha256 = "cf62b930b541ea117696d0decc2f3bd9f1f8811d066a37340e53adce3a535ccc" } }] + +[[packages]] +name = "smg-grpc-servicer" +version = "0.5.6" +sdist = { url = "https://files.pythonhosted.org/packages/38/fa/fde2418c3e651bb20feba30ee13718cb4ac786a23c34969c5c7a9b0959ec/smg_grpc_servicer-0.5.6.tar.gz", upload-time = 2026-06-17T15:27:30Z, size = 88730, hashes = { sha256 = "b8e5f06a57537689888f67ea7a7d5b1f080038a3c8aada129098529245d185c0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/15/36/2b08a588c2b869ad072882883be4f31349beac6468b93db03f1608505796/smg_grpc_servicer-0.5.6-py3-none-any.whl", upload-time = 2026-06-17T15:27:29Z, size = 91597, hashes = { sha256 = "d583be1c1b6f5fa790b735feca21c870120d37d8b4d79b4641a4bf9c34203d97" } }] + +[[packages]] +name = "sniffio" +version = "1.3.1" +sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", upload-time = 2024-02-25T23:20:04Z, size = 20372, hashes = { sha256 = "f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", upload-time = 2024-02-25T23:20:01Z, size = 10235, hashes = { sha256 = "2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2" } }] + +[[packages]] +name = "soundfile" +version = "0.13.1" +sdist = { url = "https://files.pythonhosted.org/packages/e1/41/9b873a8c055582859b239be17902a85339bec6a30ad162f98c9b0288a2cc/soundfile-0.13.1.tar.gz", upload-time = 2025-01-25T09:17:04Z, size = 46156, hashes = { sha256 = "b2c68dab1e30297317080a5b43df57e302584c49e2942defdde0acccc53f0e5b" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/28/e2a36573ccbcf3d57c00626a21fe51989380636e821b341d36ccca0c1c3a/soundfile-0.13.1-py2.py3-none-any.whl", upload-time = 2025-01-25T09:16:44Z, size = 25751, hashes = { sha256 = "a23c717560da2cf4c7b5ae1142514e0fd82d6bbd9dfc93a50423447142f2c445" } }, + { url = "https://files.pythonhosted.org/packages/57/5e/70bdd9579b35003a489fc850b5047beeda26328053ebadc1fb60f320f7db/soundfile-0.13.1-py2.py3-none-manylinux_2_28_x86_64.whl", upload-time = 2025-01-25T09:16:54Z, size = 1313646, hashes = { sha256 = "03267c4e493315294834a0870f31dbb3b28a95561b80b134f0bd3cf2d5f0e618" } }, +] + +[[packages]] +name = "stack-data" +version = "0.6.3" +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", upload-time = 2023-09-30T13:58:05Z, size = 44707, hashes = { sha256 = "836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", upload-time = 2023-09-30T13:58:03Z, size = 24521, hashes = { sha256 = "d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695" } }] + +[[packages]] +name = "starlette" +version = "1.3.1" +sdist = { url = "https://files.pythonhosted.org/packages/eb/e3/7c1dc7381d9f8ab7d854328ebfa884e62cb3f3d8549ddfd37c7814f42afa/starlette-1.3.1.tar.gz", upload-time = 2026-06-12T09:23:11Z, size = 2703240, hashes = { sha256 = "05d0213193f2fbaae60e2ecb593b4add4262ad4e46536b54abe36f11a71724e0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ec/bb/2799cc2ede3ed41131f8975621e7213dfc7ef4acbbaadfa440f32500c370/starlette-1.3.1-py3-none-any.whl", upload-time = 2026-06-12T09:23:10Z, size = 73632, hashes = { sha256 = "c7372aae11c3c3f26a42df7bd626cec2f47d03483d261d369516a615a53714c6" } }] + +[[packages]] +name = "sympy" +version = "1.14.0" +sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", upload-time = 2025-04-27T18:05:01Z, size = 7793921, hashes = { sha256 = "d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", upload-time = 2025-04-27T18:04:59Z, size = 6299353, hashes = { sha256 = "e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5" } }] + +[[packages]] +name = "tabulate" +version = "0.10.0" +sdist = { url = "https://files.pythonhosted.org/packages/46/58/8c37dea7bbf769b20d58e7ace7e5edfe65b849442b00ffcdd56be88697c6/tabulate-0.10.0.tar.gz", upload-time = 2026-03-04T18:55:34Z, size = 91754, hashes = { sha256 = "e2cfde8f79420f6deeffdeda9aaec3b6bc5abce947655d17ac662b126e48a60d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/99/55/db07de81b5c630da5cbf5c7df646580ca26dfaefa593667fc6f2fe016d2e/tabulate-0.10.0-py3-none-any.whl", upload-time = 2026-03-04T18:55:31Z, size = 39814, hashes = { sha256 = "f0b0622e567335c8fabaaa659f1b33bcb6ddfe2e496071b743aa113f8774f2d3" } }] + +[[packages]] +name = "tiktoken" +version = "0.12.0" +sdist = { url = "https://files.pythonhosted.org/packages/7d/ab/4d017d0f76ec3171d469d80fc03dfbb4e48a4bcaddaa831b31d526f05edc/tiktoken-0.12.0.tar.gz", upload-time = 2025-10-06T20:22:45Z, size = 37806, hashes = { sha256 = "b18ba7ee2b093863978fcb14f74b3707cdc8d4d4d3836853ce7ec60772139931" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f4/90/3dae6cc5436137ebd38944d396b5849e167896fc2073da643a49f372dc4f/tiktoken-0.12.0-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2025-10-06T20:21:56Z, size = 1152665, hashes = { sha256 = "edde1ec917dfd21c1f2f8046b86348b0f54a2c0547f68149d8600859598769ad" } }] + +[[packages]] +name = "timm" +version = "1.0.16" +sdist = { url = "https://files.pythonhosted.org/packages/94/f6/4d7a8c261341fa6ad281920618739f2a650f41043afcedb570f24e99a776/timm-1.0.16.tar.gz", upload-time = 2025-06-26T17:09:44Z, size = 2339999, hashes = { sha256 = "a3b8130dd2cb8dc3b9f5e3d09ab6d677a6315a8695fd5264eb6d52a4a46c1044" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3b/14/10d0ea58a7580b8bd7c8d69420b3dc3a1deb890d4ff297deca9717689598/timm-1.0.16-py3-none-any.whl", upload-time = 2025-06-26T17:09:42Z, size = 2485733, hashes = { sha256 = "a640e58f4ae41e0445517d1133b34be75bb2bd49cdb830d739925ce1fb7d2526" } }] + +[[packages]] +name = "tokenizers" +version = "0.22.2" +sdist = { url = "https://files.pythonhosted.org/packages/73/6f/f80cfef4a312e1fb34baf7d85c72d4411afde10978d4657f8cdd811d3ccc/tokenizers-0.22.2.tar.gz", upload-time = 2026-01-05T10:45:15Z, size = 372115, hashes = { sha256 = "473b83b915e547aa366d1eee11806deaf419e17be16310ac0a14077f1e28f917" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2e/76/932be4b50ef6ccedf9d3c6639b056a967a86258c6d9200643f01269211ca/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-01-05T10:40:58Z, size = 3274982, hashes = { sha256 = "369cc9fc8cc10cb24143873a0d95438bb8ee257bb80c71989e3ee290e8d72c67" } }] + +[[packages]] +name = "torch" +version = "2.9.1" +wheels = [{ url = "https://files.pythonhosted.org/packages/19/17/e377a460603132b00760511299fceba4102bd95db1a0ee788da21298ccff/torch-2.9.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2025-11-12T15:22:17Z, size = 899742281, hashes = { sha256 = "27331cd902fb4322252657f3902adf1c4f6acad9dcad81d8df3ae14c7c4f07c4" } }] + +[[packages]] +name = "torch-c-dlpack-ext" +version = "0.1.5" +sdist = { url = "https://files.pythonhosted.org/packages/37/de/921b6491efce5c389a5ef9bbed3d2d6660005840dae488124173180859ab/torch_c_dlpack_ext-0.1.5.tar.gz", upload-time = 2026-01-12T11:25:08Z, size = 12913, hashes = { sha256 = "d06f0357d575d22a168cc77acb9020fc4bae30968ceb6718a055dcbe92bacabe" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e2/79/a914539b4785f3e44f891aa012a886edb8bc10fe081c440981c57543ce21/torch_c_dlpack_ext-0.1.5-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-01-12T11:24:48Z, size = 897846, hashes = { sha256 = "e6f9da4bb9af70e27facc777458be62e10dbbbddda7672d16138db0553c5a524" } }] + +[[packages]] +name = "torch-memory-saver" +version = "0.0.9" +sdist = { url = "https://files.pythonhosted.org/packages/28/6c/21dfda5d31afb71f52cedff52370acbb8290485b3f0fee6816a15a3d08f1/torch_memory_saver-0.0.9.tar.gz", upload-time = 2025-10-18T02:10:18Z, size = 14220, hashes = { sha256 = "3bbf76391fb16870b1b0df279fc281c8a05ef8f8809400b309b0a8240e8ee5ba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3a/35/b22df9e730d8444d62445a594421992781c7fad271325d41656d8a32d103/torch_memory_saver-0.0.9-cp39-abi3-manylinux2014_x86_64.whl", upload-time = 2025-10-18T02:10:16Z, size = 488722, hashes = { sha256 = "0cf26332993649f8ea1b95d7307dfba3a95ee6cee53de84a3e561fb21752b584" } }] + +[[packages]] +name = "torchao" +version = "0.9.0" +wheels = [ + { url = "https://files.pythonhosted.org/packages/7d/fe/a24225d30775192a4c5d9cea3ecb95e6adc69d0a8b5ed98eb8e58d362344/torchao-0.9.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-02-28T13:54:15Z, size = 5652091, hashes = { sha256 = "bc708910301a9f98344d43f3fe2aa6d5e1fab706d772b6df47ff05087d664145" } }, + { url = "https://files.pythonhosted.org/packages/db/72/01f755514fb61eadc80b974eb4bd4f22f3009b35457773523e3bd497c511/torchao-0.9.0-py3-none-any.whl", upload-time = 2025-02-28T13:54:13Z, size = 712541, hashes = { sha256 = "ea5603c32762f1a9ade1a4dc7b00f5246623b24a28e49e666f614c79a408712a" } }, +] + +[[packages]] +name = "torchaudio" +version = "2.9.1" +wheels = [{ url = "https://files.pythonhosted.org/packages/fe/0d/b5af1d55ede1ca07769a2cf71256073d8958e2a5521fc734fc19f5343283/torchaudio-2.9.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2025-11-12T15:26:19Z, size = 2059899, hashes = { sha256 = "4533fdafba73d7bcfcb5f1225b2cc8974a290ed0fe54c44638d6f440e91b8999" } }] + +[[packages]] +name = "torchcodec" +version = "0.9.1" +marker = "(platform_machine != 'aarch64' and platform_machine != 'arm64' and platform_machine != 'armv7l') or sys_platform != 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/17/c8/bfb74babec98aff11ab4f239b0901f39e1a93338b3438e842d864dc46935/torchcodec-0.9.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2025-12-10T15:55:33Z, size = 2061978, hashes = { sha256 = "a50568ce73b70395d113833fb07394c223f5546ef5d4fafe0fdcd91627fca270" } }] + +[[packages]] +name = "torchvision" +version = "0.24.1" +wheels = [{ url = "https://files.pythonhosted.org/packages/93/b1/db2941526ecddd84884132e2742a55c9311296a6a38627f9e2627f5ac889/torchvision-0.24.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2025-11-12T15:25:13Z, size = 8049868, hashes = { sha256 = "66a98471fc18cad9064123106d810a75f57f0838eee20edc56233fd8484b0cc7" } }] + +[[packages]] +name = "tqdm" +version = "4.67.3" +sdist = { url = "https://files.pythonhosted.org/packages/09/a9/6ba95a270c6f1fbcd8dac228323f2777d886cb206987444e4bce66338dd4/tqdm-4.67.3.tar.gz", upload-time = 2026-02-03T17:35:53Z, size = 169598, hashes = { sha256 = "7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", upload-time = 2026-02-03T17:35:50Z, size = 78374, hashes = { sha256 = "ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf" } }] + +[[packages]] +name = "traitlets" +version = "5.14.3" +sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", upload-time = 2024-04-19T11:11:49Z, size = 161621, hashes = { sha256 = "9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", upload-time = 2024-04-19T11:11:46Z, size = 85359, hashes = { sha256 = "b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f" } }] + +[[packages]] +name = "transformers" +version = "5.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/fc/1a/70e830d53ecc96ce69cfa8de38f163712d2b43ac52fbd743f39f56025c31/transformers-5.3.0.tar.gz", upload-time = 2026-03-04T17:41:46Z, size = 8830831, hashes = { sha256 = "009555b364029da9e2946d41f1c5de9f15e6b1df46b189b7293f33a161b9c557" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b8/88/ae8320064e32679a5429a2c9ebbc05c2bf32cefb6e076f9b07f6d685a9b4/transformers-5.3.0-py3-none-any.whl", upload-time = 2026-03-04T17:41:42Z, size = 10661827, hashes = { sha256 = "50ac8c89c3c7033444fb3f9f53138096b997ebb70d4b5e50a2e810bf12d3d29a" } }] + +[[packages]] +name = "triton" +version = "3.5.1" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/f2/50/9a8358d3ef58162c0a415d173cfb45b67de60176e1024f71fbc4d24c0b6d/triton-3.5.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-11-11T17:41:00Z, size = 170470207, hashes = { sha256 = "d2c6b915a03888ab931a9fd3e55ba36785e1fe70cbea0b40c6ef93b20fc85232" } }] + +[[packages]] +name = "truststore" +version = "0.10.5" +sdist = { url = "https://files.pythonhosted.org/packages/ee/9f/c5201d42a484c061e528825fc8e2d565f5abd50a4ced6fb7d29c4ec99b2b/truststore-0.10.5.tar.gz", upload-time = 2026-10-12T22:27:31Z, size = 28091, hashes = { sha256 = "30d36967ccaded5cbb38d602c433f53600036c79d502f4533a49b60a03bbefcd" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/51/e9/3a7820be2bb0fe53b6bc9c3be26d3d1158004e4c3ab953aa6840b955b1e9/truststore-0.10.5-py3-none-any.whl", upload-time = 2026-10-12T22:27:30Z, size = 19017, hashes = { sha256 = "9aaaedaefaf06d8b206278cf8b5012bc897f485a874503501e12d776df78951c" } }] + +[[packages]] +name = "typer" +version = "0.21.2" +sdist = { url = "https://files.pythonhosted.org/packages/f2/1e/a27cc02a0cd715118c71fa2aef2c687fdefc3c28d90fd0dd789c5118154c/typer-0.21.2.tar.gz", upload-time = 2026-02-10T19:33:46Z, size = 120426, hashes = { sha256 = "1abd95a3b675e17ff61b0838ac637fe9478d446d62ad17fa4bb81ea57cc54028" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b8/cc/d59f893fbdfb5f58770c05febfc4086a46875f1084453621c35605cec946/typer-0.21.2-py3-none-any.whl", upload-time = 2026-02-10T19:33:48Z, size = 56728, hashes = { sha256 = "c3d8de54d00347ef90b82131ca946274f017cffb46683ae3883c360fa958f55c" } }] + +[[packages]] +name = "typing-extensions" +version = "4.15.0" +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", upload-time = 2025-08-25T13:49:26Z, size = 109391, hashes = { sha256 = "0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", upload-time = 2025-08-25T13:49:24Z, size = 44614, hashes = { sha256 = "f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548" } }] + +[[packages]] +name = "typing-inspection" +version = "0.4.2" +sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", upload-time = 2025-10-01T02:14:41Z, size = 75949, hashes = { sha256 = "ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", upload-time = 2025-10-01T02:14:40Z, size = 14611, hashes = { sha256 = "4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7" } }] + +[[packages]] +name = "tzdata" +version = "2026.2" +sdist = { url = "https://files.pythonhosted.org/packages/ba/19/1b9b0e29f30c6d35cb345486df41110984ea67ae69dddbc0e8a100999493/tzdata-2026.2.tar.gz", upload-time = 2026-04-24T15:22:08Z, size = 198254, hashes = { sha256 = "9173fde7d80d9018e02a662e168e5a2d04f87c41ea174b139fbef642eda62d10" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ce/e4/dccd7f47c4b64213ac01ef921a1337ee6e30e8c6466046018326977efd95/tzdata-2026.2-py2.py3-none-any.whl", upload-time = 2026-04-24T15:22:05Z, size = 349321, hashes = { sha256 = "bbe9af844f658da81a5f95019480da3a89415801f6cc966806612cc7169bffe7" } }] + +[[packages]] +name = "urllib3" +version = "2.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", upload-time = 2026-05-07T16:13:18Z, size = 433602, hashes = { sha256 = "231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", upload-time = 2026-05-07T16:13:17Z, size = 131087, hashes = { sha256 = "9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897" } }] + +[[packages]] +name = "uvicorn" +version = "0.46.0" +sdist = { url = "https://files.pythonhosted.org/packages/1f/93/041fca8274050e40e6791f267d82e0e2e27dd165627bd640d3e0e378d877/uvicorn-0.46.0.tar.gz", upload-time = 2026-04-23T07:16:00Z, size = 88758, hashes = { sha256 = "fb9da0926999cc6cb22dc7cd71a94a632f078e6ae47ff683c5c420750fb7413d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/31/a3/5b1562db76a5a488274b2332a97199b32d0442aca0ed193697fd47786316/uvicorn-0.46.0-py3-none-any.whl", upload-time = 2026-04-23T07:15:58Z, size = 70926, hashes = { sha256 = "bbebbcbed972d162afca128605223022bedd345b7bc7855ce66deb31487a9048" } }] + +[[packages]] +name = "uvloop" +version = "0.22.1" +sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", upload-time = 2025-10-16T22:17:19Z, size = 2443250, hashes = { sha256 = "6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-10-16T22:16:32Z, size = 4426307, hashes = { sha256 = "7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4" } }] + +[[packages]] +name = "watchfiles" +version = "1.1.1" +sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8869df9b2a2d6c59d79220a4db37679e74f807c559ffe5265e08b227a210/watchfiles-1.1.1.tar.gz", upload-time = 2025-10-14T15:06:21Z, size = 94440, hashes = { sha256 = "a173cb5c16c4f40ab19cecf48a534c409f7ea983ab8fed0741304a1c0a31b3f2" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/cf/68/5707da262a119fb06fbe214d82dd1fe4a6f4af32d2d14de368d0349eb52a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-10-14T15:04:55Z, size = 456812, hashes = { sha256 = "1db5d7ae38ff20153d542460752ff397fcf5c96090c1230803713cf3147a6803" } }] + +[[packages]] +name = "wcwidth" +version = "0.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/35/a2/8e3becb46433538a38726c948d3399905a4c7cabd0df578ede5dc51f0ec2/wcwidth-0.6.0.tar.gz", upload-time = 2026-02-06T19:19:40Z, size = 159684, hashes = { sha256 = "cdc4e4262d6ef9a1a57e018384cbeb1208d8abbc64176027e2c2455c81313159" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/68/5a/199c59e0a824a3db2b89c5d2dade7ab5f9624dbf6448dc291b46d5ec94d3/wcwidth-0.6.0-py3-none-any.whl", upload-time = 2026-02-06T19:19:39Z, size = 94189, hashes = { sha256 = "1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad" } }] + +[[packages]] +name = "xgrammar" +version = "0.1.32" +sdist = { url = "https://files.pythonhosted.org/packages/99/6a/d51b44fc0b43e2d4adae42b6a17fe9ee49e177d6d768be739ed7dec7b57e/xgrammar-0.1.32.tar.gz", upload-time = 2026-03-04T12:01:52Z, size = 2365047, hashes = { sha256 = "5d424d52779ca2d3ccaf72f2289d6519efe308e933d0d3fc3c292c780825bb12" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/69/62/65e664d861cdadf2d788c03dd8fe67f1faaa7bd4bd2317a2ab850aebee20/xgrammar-0.1.32-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-04T12:00:50Z, size = 37711100, hashes = { sha256 = "f96c7a4fcbd68e18b13cb3b6ed5d24b5326b256933f476bdaf2cc8e609c228db" } }] + +[[packages]] +name = "xxhash" +version = "3.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/24/2f/e183a1b407002f5af81822bee18b61cdb94b8670208ef34734d8d2b8ebe9/xxhash-3.7.0.tar.gz", upload-time = 2026-04-25T11:10:32Z, size = 82022, hashes = { sha256 = "6cc4eefbb542a5d6ffd6d70ea9c502957c925e800f998c5630ecc809d6702bae" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/40/37/558f5a90c0672fc9b4402dc25d87ac5b7406616e8969430c9ca4e52ee74d/xxhash-3.7.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-25T11:06:31Z, size = 193932, hashes = { sha256 = "13805f0461cba0a857924e70ff91ae6d52d2598f79a884e788db80532614a4a1" } }] + +[[packages]] +name = "yarl" +version = "1.23.0" +sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", upload-time = 2026-03-01T22:07:53Z, size = 194676, hashes = { sha256 = "53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-01T22:05:23Z, size = 100132, hashes = { sha256 = "a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51" } }, + { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", upload-time = 2026-03-01T22:07:51Z, size = 48288, hashes = { sha256 = "a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f" } }, +] + +[[packages]] +name = "zipp" +version = "3.23.1" +sdist = { url = "https://files.pythonhosted.org/packages/30/21/093488dfc7cc8964ded15ab726fad40f25fd3d788fd741cc1c5a17d78ee8/zipp-3.23.1.tar.gz", upload-time = 2026-04-13T23:21:46Z, size = 25965, hashes = { sha256 = "32120e378d32cd9714ad503c1d024619063ec28aad2248dc6672ad13edfa5110" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/08/8a/0861bec20485572fbddf3dfba2910e38fe249796cb73ecdeb74e07eeb8d3/zipp-3.23.1-py3-none-any.whl", upload-time = 2026-04-13T23:21:45Z, size = 10378, hashes = { sha256 = "0b3596c50a5c700c9cb40ba8d86d9f2cc4807e9bedb06bcdf7fac85633e444dc" } }] diff --git a/packages/sie_server/bundle-locks/cuda12-transformers5-amd64/manifest.json b/packages/sie_server/bundle-locks/cuda12-transformers5-amd64/manifest.json new file mode 100644 index 000000000..3997bd5a2 --- /dev/null +++ b/packages/sie_server/bundle-locks/cuda12-transformers5-amd64/manifest.json @@ -0,0 +1,24 @@ +{ + "completed_artifact_hashes": [], + "exceptions_sha256": "37835b8c8b636bca70edb39f0252652c5d021bd5521a6690ab324b887905b80e", + "exclude_newer": "2026-10-18T00:00:00Z", + "indexes": [ + "--default-index", + "https://pypi.org/simple" + ], + "inputs": { + "requirements_sha256": "72ca3b4c7893a0ca42603d3a60e435ee1efd1f9a57533ae19d24d1610037398f", + "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" + }, + "lock_sha256": "b1c1101c295e2283084a6bd7d893508c1733e611458a164d94d3b6e389665a56", + "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "schema_version": 1, + "target": { + "architecture": "amd64", + "bundle": "transformers5", + "platform": "cuda12", + "python_platform": "x86_64-manylinux_2_35", + "python_version": "3.12" + }, + "uv_version": "0.9.28" +} diff --git a/packages/sie_server/bundle-locks/cuda12-transformers5-amd64/pylock.toml b/packages/sie_server/bundle-locks/cuda12-transformers5-amd64/pylock.toml new file mode 100644 index 000000000..ba815c2a9 --- /dev/null +++ b/packages/sie_server/bundle-locks/cuda12-transformers5-amd64/pylock.toml @@ -0,0 +1,503 @@ +lock-version = "1.0" +created-by = "uv" +requires-python = ">=3.12" + +[[packages]] +name = "annotated-doc" +version = "0.0.4" +sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", upload-time = 2025-11-10T22:07:42Z, size = 7288, hashes = { sha256 = "fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", upload-time = 2025-11-10T22:07:40Z, size = 5303, hashes = { sha256 = "571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320" } }] + +[[packages]] +name = "annotated-types" +version = "0.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", upload-time = 2024-05-20T21:33:25Z, size = 16081, hashes = { sha256 = "aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", upload-time = 2024-05-20T21:33:24Z, size = 13643, hashes = { sha256 = "1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53" } }] + +[[packages]] +name = "anyio" +version = "4.14.2" +sdist = { url = "https://files.pythonhosted.org/packages/61/cc/a381afa6efea9f496eff839d4a6a1aed3bfafc7b3ab4b0d1b243a12573dd/anyio-4.14.2.tar.gz", upload-time = 2026-07-12T20:29:07Z, size = 260176, hashes = { sha256 = "cfa139f3ed1a23ee8f88a145ddb5ac7605b8bbfd8592baacd7ce3d8bb4313c7f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/da/35/f2287558c17e29fafc8ef3daf819bb9834061cfa43bff8014f7df7f63bdc/anyio-4.14.2-py3-none-any.whl", upload-time = 2026-07-12T20:29:05Z, size = 125813, hashes = { sha256 = "9f505dda5ac9f0c8309b5e8bd445a8c2bf7246f3ce950121e45ea15bc41d1494" } }] + +[[packages]] +name = "certifi" +version = "2026.4.22" +sdist = { url = "https://files.pythonhosted.org/packages/25/ee/6caf7a40c36a1220410afe15a1cc64993a1f864871f698c0f93acb72842a/certifi-2026.4.22.tar.gz", upload-time = 2026-04-22T11:26:11Z, size = 137077, hashes = { sha256 = "8d455352a37b71bf76a79caa83a3d6c25afee4a385d632127b6afb3963f1c580" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/22/30/7cd8fdcdfbc5b869528b079bfb76dcdf6056b1a2097a662e5e8c04f42965/certifi-2026.4.22-py3-none-any.whl", upload-time = 2026-04-22T11:26:09Z, size = 135707, hashes = { sha256 = "3cb2210c8f88ba2318d29b0388d1023c8492ff72ecdde4ebdaddbb13a31b1c4a" } }] + +[[packages]] +name = "cffi" +version = "2.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", upload-time = 2025-09-08T23:24:04Z, size = 523588, hashes = { sha256 = "44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-09-08T23:22:52Z, size = 219572, hashes = { sha256 = "3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba" } }] + +[[packages]] +name = "charset-normalizer" +version = "3.4.7" +sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", upload-time = 2026-04-02T09:28:39Z, size = 144271, hashes = { sha256 = "ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4b/f8/d0118a2f5f23b02cd166fa385c60f9b0d4f9194f574e2b31cef350ad7223/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-02T09:26:29Z, size = 216589, hashes = { sha256 = "5649fd1c7bade02f320a462fdefd0b4bd3ce036065836d4f42e0de958038e116" } }, + { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", upload-time = 2026-04-02T09:28:37Z, size = 61958, hashes = { sha256 = "3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d" } }, +] + +[[packages]] +name = "click" +version = "8.1.8" +sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", upload-time = 2024-12-21T18:38:44Z, size = 226593, hashes = { sha256 = "ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", upload-time = 2024-12-21T18:38:41Z, size = 98188, hashes = { sha256 = "63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2" } }] + +[[packages]] +name = "decorator" +version = "5.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", upload-time = 2025-02-24T04:41:34Z, size = 56711, hashes = { sha256 = "65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", upload-time = 2025-02-24T04:41:32Z, size = 9190, hashes = { sha256 = "d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a" } }] + +[[packages]] +name = "einops" +version = "0.8.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/2c/77/850bef8d72ffb9219f0b1aac23fbc1bf7d038ee6ea666f331fa273031aa2/einops-0.8.2.tar.gz", upload-time = 2026-01-26T04:13:17Z, size = 56261, hashes = { sha256 = "609da665570e5e265e27283aab09e7f279ade90c4f01bcfca111f3d3e13f2827" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/09/f8d8f8f31e4483c10a906437b4ce31bdf3d6d417b73fe33f1a8b59e34228/einops-0.8.2-py3-none-any.whl", upload-time = 2026-01-26T04:13:18Z, size = 65638, hashes = { sha256 = "54058201ac7087911181bfec4af6091bb59380360f069276601256a76af08193" } }] + +[[packages]] +name = "filelock" +version = "3.29.0" +sdist = { url = "https://files.pythonhosted.org/packages/b5/fe/997687a931ab51049acce6fa1f23e8f01216374ea81374ddee763c493db5/filelock-3.29.0.tar.gz", upload-time = 2026-04-19T15:39:10Z, size = 57571, hashes = { sha256 = "69974355e960702e789734cb4871f884ea6fe50bd8404051a3530bc07809cf90" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/81/47/dd9a212ef6e343a6857485ffe25bba537304f1913bdbed446a23f7f592e1/filelock-3.29.0-py3-none-any.whl", upload-time = 2026-04-19T15:39:08Z, size = 39812, hashes = { sha256 = "96f5f6344709aa1572bbf631c640e4ebeeb519e08da902c39a001882f30ac258" } }] + +[[packages]] +name = "fla-core" +version = "0.5.2" +marker = "sys_platform == 'linux'" +sdist = { url = "https://files.pythonhosted.org/packages/94/85/20bdc0fbbbaeec27b5b198e0dbbbc51161a267066a4aebd9e4b413637c6c/fla_core-0.5.2.tar.gz", upload-time = 2026-07-27T18:26:19Z, size = 587835, hashes = { sha256 = "9360fc412f784c1c8f05c320ec2902d5d968764178c9b8a92efc919e17a39680" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2d/ed/dfe19c4da779957eb6a42a26812f9b4e2280bf757a17a71933ff59ffcb98/fla_core-0.5.2-py3-none-any.whl", upload-time = 2026-07-27T18:26:16Z, size = 819225, hashes = { sha256 = "5e830c85bad3d0d34677f98ac7074d08687a3756f0f0499d95ceb96eb6920761" } }] + +[[packages]] +name = "flash-attn" +version = "2.7.4+cu129torch2.9" +marker = "sys_platform == 'linux'" +archive = { url = "https://github.com/mjun0812/flash-attention-prebuild-wheels/releases/download/v0.7.11/flash_attn-2.7.4+cu129torch2.9-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hashes = { sha256 = "0a8f6219e61f8ff923cfd2cdad105d95a66106a6c9e754486d778c3a25e7707f" } } + +[[packages]] +name = "fsspec" +version = "2025.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/34/f4/5721faf47b8c499e776bc34c6a8fc17efdf7fdef0b00f398128bc5dcb4ac/fsspec-2025.3.0.tar.gz", upload-time = 2025-03-07T21:47:56Z, size = 298491, hashes = { sha256 = "a935fd1ea872591f2b5148907d103488fc523295e6c64b835cfad8c3eca44972" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/56/53/eb690efa8513166adef3e0669afd31e95ffde69fb3c52ec2ac7223ed6018/fsspec-2025.3.0-py3-none-any.whl", upload-time = 2025-03-07T21:47:54Z, size = 193615, hashes = { sha256 = "efb87af3efa9103f94ca91a7f8cb7a4df91af9f74fc106c9c7ea0efd7277c1b3" } }] + +[[packages]] +name = "gliner2" +version = "2.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/b2/a8/2dcfdb8862dbeb488b6b86047075a213cc101ca592eae1a43b824cca74dd/gliner2-2.0.0.tar.gz", upload-time = 2026-08-24T15:13:43Z, size = 565826, hashes = { sha256 = "82b149f893ba0f6adf75ef1db599b6dbecd9811cca34dbd0bac7cd9e90b90ce4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/00/44/87d2803c5c5c6c0bd22bce4d52c66c965dacae29e0121d7e04c9883711df/gliner2-2.0.0-py3-none-any.whl", upload-time = 2026-08-24T15:13:41Z, size = 326214, hashes = { sha256 = "6f7c4cba0ef3173636d8bd9404aa94d4e0ccf36d4b4b9a0d27d740dd2d3236c3" } }] + +[[packages]] +name = "h11" +version = "0.16.0" +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", upload-time = 2025-04-24T03:35:25Z, size = 101250, hashes = { sha256 = "4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", upload-time = 2025-04-24T03:35:24Z, size = 37515, hashes = { sha256 = "63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86" } }] + +[[packages]] +name = "hf-xet" +version = "1.4.3" +marker = "platform_machine == 'AMD64' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" +sdist = { url = "https://files.pythonhosted.org/packages/53/92/ec9ad04d0b5728dca387a45af7bc98fbb0d73b2118759f5f6038b61a57e8/hf_xet-1.4.3.tar.gz", upload-time = 2026-03-31T22:40:07Z, size = 670477, hashes = { sha256 = "8ddedb73c8c08928c793df2f3401ec26f95be7f7e516a7bee2fbb546f6676113" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/df/9a/a24b26dc8a65f0ecc0fe5be981a19e61e7ca963b85e062c083f3a9100529/hf_xet-1.4.3-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-03-31T22:39:42Z, size = 4212320, hashes = { sha256 = "fc360b70c815bf340ed56c7b8c63aacf11762a4b099b2fe2c9bd6d6068668c08" } }] + +[[packages]] +name = "httpcore" +version = "1.0.9" +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", upload-time = 2025-04-24T22:06:22Z, size = 85484, hashes = { sha256 = "6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", upload-time = 2025-04-24T22:06:20Z, size = 78784, hashes = { sha256 = "2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55" } }] + +[[packages]] +name = "httpx" +version = "0.28.1" +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", upload-time = 2024-12-06T15:37:23Z, size = 141406, hashes = { sha256 = "75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", upload-time = 2024-12-06T15:37:21Z, size = 73517, hashes = { sha256 = "d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad" } }] + +[[packages]] +name = "huggingface-hub" +version = "1.16.1" +sdist = { url = "https://files.pythonhosted.org/packages/48/0f/ed994dbade67a54407c28cab96ef845e0e6d25500be56aca6394f8bfc9dd/huggingface_hub-1.16.1.tar.gz", upload-time = 2026-05-21T18:40:00Z, size = 792534, hashes = { sha256 = "7f1dc4c5ec21aed69be630ad0c3378616be16f3de1a47b141c0e812965d9c832" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/49/79/621a7dbb80c70974f73a597275351ebe03ce5bc65cb5f8f4acb5859252bc/huggingface_hub-1.16.1-py3-none-any.whl", upload-time = 2026-05-21T18:39:58Z, size = 668176, hashes = { sha256 = "64340de934b9ce37857ef85a82de72f5629e8a270f9119eabb12bf495eb53c22" } }] + +[[packages]] +name = "idna" +version = "3.17" +sdist = { url = "https://files.pythonhosted.org/packages/b9/28/99c51f664567218d824af024c0251650fb27e4ca066df188dab0769c5b91/idna-3.17.tar.gz", upload-time = 2026-05-28T14:32:38Z, size = 196048, hashes = { sha256 = "5eb0cb53bc467c12eadcf6de83163ad8527cec9416f44b9b61b19caedad2b87f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/de/a7/f76514cc40ad6234098ecdebda08732d75964776c51a42845b7da10649e2/idna-3.17-py3-none-any.whl", upload-time = 2026-05-28T14:32:37Z, size = 65316, hashes = { sha256 = "466e48829084efe2548012b855df21540b96f2e20e51bd124c851536556a592c" } }] + +[[packages]] +name = "jinja2" +version = "3.1.6" +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", upload-time = 2025-03-05T20:05:02Z, size = 245115, hashes = { sha256 = "0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", upload-time = 2025-03-05T20:05:00Z, size = 134899, hashes = { sha256 = "85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67" } }] + +[[packages]] +name = "joblib" +version = "1.5.3" +sdist = { url = "https://files.pythonhosted.org/packages/41/f2/d34e8b3a08a9cc79a50b2208a93dce981fe615b64d5a4d4abee421d898df/joblib-1.5.3.tar.gz", upload-time = 2025-12-15T08:41:46Z, size = 331603, hashes = { sha256 = "8561a3269e6801106863fd0d6d84bb737be9e7631e33aaed3fb9ce5953688da3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7b/91/984aca2ec129e2757d1e4e3c81c3fcda9d0f85b74670a094cc443d9ee949/joblib-1.5.3-py3-none-any.whl", upload-time = 2025-12-15T08:41:44Z, size = 309071, hashes = { sha256 = "5fc3c5039fc5ca8c0276333a188bbd59d6b7ab37fe6632daa76bc7f9ec18e713" } }] + +[[packages]] +name = "lazy-loader" +version = "0.6" +sdist = { url = "https://files.pythonhosted.org/packages/19/8c/0f2ff2a8b7513e68871a74740c17a504b0488c679b379e6445ebb7bd78dc/lazy_loader-0.6.tar.gz", upload-time = 2026-09-21T21:31:32Z, size = 18438, hashes = { sha256 = "2f4b7824d6401958639008a0cae20c776b61dff619accd6890693e2de8260167" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/23/93/4e45e37f26c820216704b36b8e67cc55c490a7abd287a78a26a2c0e21386/lazy_loader-0.6-py3-none-any.whl", upload-time = 2026-09-21T21:31:31Z, size = 8791, hashes = { sha256 = "77253be3391b06124a0e16105bd663b6c54470af1a9ca8e1cf026f38d58ed056" } }] + +[[packages]] +name = "librosa" +version = "1.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/8e/c1/ce66b20953b7370421dd13d22b4e04e401346c824ceacb9f4e722eec84dc/librosa-1.0.0.tar.gz", upload-time = 2026-08-11T15:37:37Z, size = 377965, hashes = { sha256 = "73ed480d4022e436e85dfa6f6b06ff38a259b9210039ac99939cd64854b61a57" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/96/14/0b2e4cc8017796dc8f69de740708601832c1e8d5377166eedb4db0a92264/librosa-1.0.0-py3-none-any.whl", upload-time = 2026-08-11T15:37:35Z, size = 294628, hashes = { sha256 = "5910a6c0e1b2e494b92758c1615a7acbd0515a2315e138927ba2982f2af88857" } }] + +[[packages]] +name = "llvmlite" +version = "0.50.0" +sdist = { url = "https://files.pythonhosted.org/packages/11/c5/907cec40688a34eb489cded74d555e1ee4af8cf49d83e03dba2c2d4cfe27/llvmlite-0.50.0.tar.gz", upload-time = 2026-09-29T18:44:46Z, size = 194522, hashes = { sha256 = "f2a2cd6ec9ffcc1b7147dea0d7a49efebf17a2b434e0c2844fe175999d571eb4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/4c/72/22b6449e15bec4cc86c62b659e6c625ab777d01e87aaec717ecef440f87a/llvmlite-0.50.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-09-29T18:43:04Z, size = 59696588, hashes = { sha256 = "d501e5103076b9a14be885d2574dc2f6793171aa54a853d1244e011d476f1399" } }] + +[[packages]] +name = "markdown-it-py" +version = "4.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", upload-time = 2025-08-11T12:57:52Z, size = 73070, hashes = { sha256 = "cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", upload-time = 2025-08-11T12:57:51Z, size = 87321, hashes = { sha256 = "87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147" } }] + +[[packages]] +name = "markupsafe" +version = "3.0.3" +sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", upload-time = 2025-09-27T18:37:40Z, size = 80313, hashes = { sha256 = "722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-09-27T18:36:33Z, size = 22947, hashes = { sha256 = "d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d" } }] + +[[packages]] +name = "mdurl" +version = "0.1.2" +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", upload-time = 2022-08-14T12:40:10Z, size = 8729, hashes = { sha256 = "bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", upload-time = 2022-08-14T12:40:09Z, size = 9979, hashes = { sha256 = "84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8" } }] + +[[packages]] +name = "mpmath" +version = "1.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", upload-time = 2023-03-07T16:47:11Z, size = 508106, hashes = { sha256 = "7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", upload-time = 2023-03-07T16:47:09Z, size = 536198, hashes = { sha256 = "a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c" } }] + +[[packages]] +name = "msgpack" +version = "1.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/31/f9/c0a1c127f9049db9155afc316952ea571720dd01833ff5e4d7e8e6352dbb/msgpack-1.2.1.tar.gz", upload-time = 2026-06-18T16:13:52Z, size = 183960, hashes = { sha256 = "04c721c2c7448767e9e3f2520a475663d8ee0f09c31890f6d2bd70fd636a9647" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/6a/fd/6adabd4f6d5e686f97dd02ce7fce3fe4cf672cbac36b8f67ff4040e8ad8b/msgpack-1.2.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-06-18T16:13:01Z, size = 419989, hashes = { sha256 = "020e881a764b20d8d7ca1a54fc01b8175519d108e3c3f194fddc200bda95951a" } }] + +[[packages]] +name = "networkx" +version = "3.6.1" +sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", upload-time = 2025-12-08T17:02:39Z, size = 2517025, hashes = { sha256 = "26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", upload-time = 2025-12-08T17:02:38Z, size = 2068504, hashes = { sha256 = "d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762" } }] + +[[packages]] +name = "numba" +version = "0.68.0" +sdist = { url = "https://files.pythonhosted.org/packages/4e/cd/e8280f9ffa30fea9fabc5341223701231fcc5d53a31f51419d42d4bec3a6/numba-0.68.0.tar.gz", upload-time = 2026-09-30T15:05:44Z, size = 2855363, hashes = { sha256 = "8a781de54b980b98f43bff7f1093701b5f07c80d031c7cfa8a87493d8bf73f2d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/6f/40/2211b4ff48cccfb21d4c38fb56788d7a975189883efb8d549be9d51aba7d/numba-0.68.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-09-30T15:04:57Z, size = 3888027, hashes = { sha256 = "51fe913a70fe9a7a0b193757ff977a9e96c82ae936ae388aec8990814fffdf9d" } }] + +[[packages]] +name = "numpy" +version = "2.4.4" +sdist = { url = "https://files.pythonhosted.org/packages/d7/9f/b8cef5bffa569759033adda9481211426f12f53299629b410340795c2514/numpy-2.4.4.tar.gz", upload-time = 2026-03-29T13:22:01Z, size = 20731587, hashes = { sha256 = "2d390634c5182175533585cc89f3608a4682ccb173cc9bb940b2881c8d6f8fa0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0a/0d/0e3ecece05b7a7e87ab9fb587855548da437a061326fff64a223b6dcb78a/numpy-2.4.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-29T13:19:03Z, size = 16645480, hashes = { sha256 = "81f4a14bee47aec54f883e0cad2d73986640c1590eb9bfaaba7ad17394481e6e" } }] + +[[packages]] +name = "nvidia-cublas-cu12" +version = "12.8.4.1" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/dc/61/e24b560ab2e2eaeb3c839129175fb330dfcfc29e5203196e5541a4c44682/nvidia_cublas_cu12-12.8.4.1-py3-none-manylinux_2_27_x86_64.whl", upload-time = 2025-03-07T01:44:31Z, size = 594346921, hashes = { sha256 = "8ac4e771d5a348c551b2a426eda6193c19aa630236b418086020df5ba9667142" } }] + +[[packages]] +name = "nvidia-cuda-cupti-cu12" +version = "12.8.90" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/f8/02/2adcaa145158bf1a8295d83591d22e4103dbfd821bcaf6f3f53151ca4ffa/nvidia_cuda_cupti_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-03-07T01:40:21Z, size = 10248621, hashes = { sha256 = "ea0cb07ebda26bb9b29ba82cda34849e73c166c18162d3913575b0c9db9a6182" } }] + +[[packages]] +name = "nvidia-cuda-nvrtc-cu12" +version = "12.8.93" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/05/6b/32f747947df2da6994e999492ab306a903659555dddc0fbdeb9d71f75e52/nvidia_cuda_nvrtc_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", upload-time = 2025-03-07T01:42:13Z, size = 88040029, hashes = { sha256 = "a7756528852ef889772a84c6cd89d41dfa74667e24cca16bb31f8f061e3e9994" } }] + +[[packages]] +name = "nvidia-cuda-runtime-cu12" +version = "12.8.90" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/0d/9b/a997b638fcd068ad6e4d53b8551a7d30fe8b404d6f1804abf1df69838932/nvidia_cuda_runtime_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-03-07T01:40:01Z, size = 954765, hashes = { sha256 = "adade8dcbd0edf427b7204d480d6066d33902cab2a4707dcfc48a2d0fd44ab90" } }] + +[[packages]] +name = "nvidia-cudnn-cu12" +version = "9.10.2.21" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/ba/51/e123d997aa098c61d029f76663dedbfb9bc8dcf8c60cbd6adbe42f76d049/nvidia_cudnn_cu12-9.10.2.21-py3-none-manylinux_2_27_x86_64.whl", upload-time = 2025-06-06T21:54:08Z, size = 706758467, hashes = { sha256 = "949452be657fa16687d0930933f032835951ef0892b37d2d53824d1a84dc97a8" } }] + +[[packages]] +name = "nvidia-cufft-cu12" +version = "11.3.3.83" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/1f/13/ee4e00f30e676b66ae65b4f08cb5bcbb8392c03f54f2d5413ea99a5d1c80/nvidia_cufft_cu12-11.3.3.83-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-03-07T01:45:27Z, size = 193118695, hashes = { sha256 = "4d2dd21ec0b88cf61b62e6b43564355e5222e4a3fb394cac0db101f2dd0d4f74" } }] + +[[packages]] +name = "nvidia-cufile-cu12" +version = "1.13.1.3" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/bb/fe/1bcba1dfbfb8d01be8d93f07bfc502c93fa23afa6fd5ab3fc7c1df71038a/nvidia_cufile_cu12-1.13.1.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-03-07T01:45:50Z, size = 1197834, hashes = { sha256 = "1d069003be650e131b21c932ec3d8969c1715379251f8d23a1860554b1cb24fc" } }] + +[[packages]] +name = "nvidia-curand-cu12" +version = "10.3.9.90" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/fb/aa/6584b56dc84ebe9cf93226a5cde4d99080c8e90ab40f0c27bda7a0f29aa1/nvidia_curand_cu12-10.3.9.90-py3-none-manylinux_2_27_x86_64.whl", upload-time = 2025-03-07T01:46:23Z, size = 63619976, hashes = { sha256 = "b32331d4f4df5d6eefa0554c565b626c7216f87a06a4f56fab27c3b68a830ec9" } }] + +[[packages]] +name = "nvidia-cusolver-cu12" +version = "11.7.3.90" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/85/48/9a13d2975803e8cf2777d5ed57b87a0b6ca2cc795f9a4f59796a910bfb80/nvidia_cusolver_cu12-11.7.3.90-py3-none-manylinux_2_27_x86_64.whl", upload-time = 2025-03-07T01:47:16Z, size = 267506905, hashes = { sha256 = "4376c11ad263152bd50ea295c05370360776f8c3427b30991df774f9fb26c450" } }] + +[[packages]] +name = "nvidia-cusparse-cu12" +version = "12.5.8.93" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/c2/f5/e1854cb2f2bcd4280c44736c93550cc300ff4b8c95ebe370d0aa7d2b473d/nvidia_cusparse_cu12-12.5.8.93-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-03-07T01:48:13Z, size = 288216466, hashes = { sha256 = "1ec05d76bbbd8b61b06a80e1eaf8cf4959c3d4ce8e711b65ebd0443bb0ebb13b" } }] + +[[packages]] +name = "nvidia-cusparselt-cu12" +version = "0.7.1" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/56/79/12978b96bd44274fe38b5dde5cfb660b1d114f70a65ef962bcbbed99b549/nvidia_cusparselt_cu12-0.7.1-py3-none-manylinux2014_x86_64.whl", upload-time = 2025-02-26T00:15:44Z, size = 287193691, hashes = { sha256 = "f1bb701d6b930d5a7cea44c19ceb973311500847f81b634d802b7b539dc55623" } }] + +[[packages]] +name = "nvidia-nccl-cu12" +version = "2.27.5" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/6e/89/f7a07dc961b60645dbbf42e80f2bc85ade7feb9a491b11a1e973aa00071f/nvidia_nccl_cu12-2.27.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-06-26T04:11:28Z, size = 322348229, hashes = { sha256 = "ad730cf15cb5d25fe849c6e6ca9eb5b76db16a80f13f425ac68d8e2e55624457" } }] + +[[packages]] +name = "nvidia-nvjitlink-cu12" +version = "12.8.93" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/f6/74/86a07f1d0f42998ca31312f998bd3b9a7eff7f52378f4f270c8679c77fb9/nvidia_nvjitlink_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", upload-time = 2025-03-07T01:49:55Z, size = 39254836, hashes = { sha256 = "81ff63371a7ebd6e6451970684f916be2eab07321b73c9d244dc2b4da7f73b88" } }] + +[[packages]] +name = "nvidia-nvshmem-cu12" +version = "3.3.20" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/3b/6c/99acb2f9eb85c29fc6f3a7ac4dccfd992e22666dd08a642b303311326a97/nvidia_nvshmem_cu12-3.3.20-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-08-04T20:25:19Z, size = 124657145, hashes = { sha256 = "d00f26d3f9b2e3c3065be895e3059d6479ea5c638a3f38c9fec49b1b9dd7c1e5" } }] + +[[packages]] +name = "nvidia-nvtx-cu12" +version = "12.8.90" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/a2/eb/86626c1bbc2edb86323022371c39aa48df6fd8b0a1647bc274577f72e90b/nvidia_nvtx_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-03-07T01:42:44Z, size = 89954, hashes = { sha256 = "5b17e2001cc0d751a5bc2c6ec6d26ad95913324a4adb86788c944f8ce9ba441f" } }] + +[[packages]] +name = "opf" +version = "0.1.0" +vcs = { type = "git", url = "https://github.com/openai/privacy-filter", requested-revision = "f7f00ca7fb869683eb732c010299d901457f19c3", commit-id = "f7f00ca7fb869683eb732c010299d901457f19c3" } + +[[packages]] +name = "packaging" +version = "24.2" +sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", upload-time = 2024-11-08T09:47:47Z, size = 163950, hashes = { sha256 = "c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", upload-time = 2024-11-08T09:47:44Z, size = 65451, hashes = { sha256 = "09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759" } }] + +[[packages]] +name = "pillow" +version = "12.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/1c/3d/bb7fca845737cf9d7dbde16ed1843984665ff2e0a518f5db43e77ec540b9/pillow-12.3.0.tar.gz", upload-time = 2026-07-01T11:56:38Z, size = 47025035, hashes = { sha256 = "3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/84/21/a35af28dcc61f37ed850a2d64c65c701321dfbf25085e469d5559360cbbf/pillow-12.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-01T11:54:13Z, size = 6940830, hashes = { sha256 = "78cb2c6865a35ab8ff8b75fd122f6033b92a62c82801110e48ddd6c936a45d91" } }] + +[[packages]] +name = "platformdirs" +version = "4.9.6" +sdist = { url = "https://files.pythonhosted.org/packages/9f/4a/0883b8e3802965322523f0b200ecf33d31f10991d0401162f4b23c698b42/platformdirs-4.9.6.tar.gz", upload-time = 2026-04-09T00:04:10Z, size = 29400, hashes = { sha256 = "3bfa75b0ad0db84096ae777218481852c0ebc6c727b3168c1b9e0118e458cf0a" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/75/a6/a0a304dc33b49145b21f4808d763822111e67d1c3a32b524a1baf947b6e1/platformdirs-4.9.6-py3-none-any.whl", upload-time = 2026-04-09T00:04:09Z, size = 21348, hashes = { sha256 = "e61adb1d5e5cb3441b4b7710bea7e4c12250ca49439228cc1021c00dcfac0917" } }] + +[[packages]] +name = "pooch" +version = "1.9.0" +sdist = { url = "https://files.pythonhosted.org/packages/83/43/85ef45e8b36c6a48546af7b266592dc32d7f67837a6514d111bced6d7d75/pooch-1.9.0.tar.gz", upload-time = 2026-01-30T19:15:09Z, size = 61788, hashes = { sha256 = "de46729579b9857ffd3e741987a2f6d5e0e03219892c167c6578c0091fb511ed" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/2d/d4bf65e47cea8ff2c794a600c4fd1273a7902f268757c531e0ee9f18aa58/pooch-1.9.0-py3-none-any.whl", upload-time = 2026-01-30T19:15:08Z, size = 67175, hashes = { sha256 = "f265597baa9f760d25ceb29d0beb8186c243d6607b0f60b83ecf14078dbc703b" } }] + +[[packages]] +name = "pycparser" +version = "3.0" +marker = "implementation_name != 'PyPy'" +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", upload-time = 2026-01-21T14:26:51Z, size = 103492, hashes = { sha256 = "600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", upload-time = 2026-01-21T14:26:50Z, size = 48172, hashes = { sha256 = "b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992" } }] + +[[packages]] +name = "pydantic" +version = "2.12.5" +sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", upload-time = 2025-11-26T15:11:46Z, size = 821591, hashes = { sha256 = "4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", upload-time = 2025-11-26T15:11:44Z, size = 463580, hashes = { sha256 = "e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d" } }] + +[[packages]] +name = "pydantic-core" +version = "2.41.5" +sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", upload-time = 2025-11-04T13:43:49Z, size = 460952, hashes = { sha256 = "08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-04T13:40:09Z, size = 2075366, hashes = { sha256 = "eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c" } }] + +[[packages]] +name = "pygments" +version = "2.20.0" +sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", upload-time = 2026-03-29T13:29:33Z, size = 4955991, hashes = { sha256 = "6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", upload-time = 2026-03-29T13:29:30Z, size = 1231151, hashes = { sha256 = "81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176" } }] + +[[packages]] +name = "pyyaml" +version = "6.0.3" +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", upload-time = 2025-09-25T21:33:16Z, size = 130960, hashes = { sha256 = "d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-09-25T21:32:16Z, size = 807870, hashes = { sha256 = "ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc" } }] + +[[packages]] +name = "regex" +version = "2026.4.4" +sdist = { url = "https://files.pythonhosted.org/packages/cb/0e/3a246dbf05666918bd3664d9d787f84a9108f6f43cc953a077e4a7dfdb7e/regex-2026.4.4.tar.gz", upload-time = 2026-04-03T20:56:28Z, size = 416000, hashes = { sha256 = "e08270659717f6973523ce3afbafa53515c4dc5dcad637dc215b6fd50f689423" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/11/0e/a9f6f81013e0deaf559b25711623864970fe6a098314e374ccb1540a4152/regex-2026.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-03T20:53:51Z, size = 801126, hashes = { sha256 = "993f657a7c1c6ec51b5e0ba97c9817d06b84ea5fa8d82e43b9405de0defdc2b9" } }] + +[[packages]] +name = "requests" +version = "2.33.1" +sdist = { url = "https://files.pythonhosted.org/packages/5f/a4/98b9c7c6428a668bf7e42ebb7c79d576a1c3c1e3ae2d47e674b468388871/requests-2.33.1.tar.gz", upload-time = 2026-03-30T16:09:15Z, size = 134120, hashes = { sha256 = "18817f8c57c6263968bc123d237e3b8b08ac046f5456bd1e307ee8f4250d3517" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", upload-time = 2026-03-30T16:09:13Z, size = 64947, hashes = { sha256 = "4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a" } }] + +[[packages]] +name = "rich" +version = "13.9.4" +sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", upload-time = 2024-11-01T16:43:57Z, size = 223149, hashes = { sha256 = "439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", upload-time = 2024-11-01T16:43:55Z, size = 242424, hashes = { sha256 = "6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90" } }] + +[[packages]] +name = "safetensors" +version = "0.8.0" +sdist = { url = "https://files.pythonhosted.org/packages/45/06/f955dbbb1859e3bd23c8ac6141af5106e7ad5fedec4a3a6e3d60f94b7001/safetensors-0.8.0.tar.gz", upload-time = 2026-06-09T07:52:25Z, size = 325846, hashes = { sha256 = "fabaf3e0f18a6618d9b36560682562157f77c2b71fcffc7b432be2baed9d753d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/28/50/f203ff3a3ddfe19308efc83c5a3a29ed02bf786732ec35e68bf9162f3365/safetensors-0.8.0-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-06-09T07:52:16Z, size = 516040, hashes = { sha256 = "fd6f3f93c9a0a7cc2788ee63fb763353d4bd2e89b0751bc78fcf7dda00bea774" } }] + +[[packages]] +name = "scikit-learn" +version = "1.8.0" +sdist = { url = "https://files.pythonhosted.org/packages/0e/d4/40988bf3b8e34feec1d0e6a051446b1f66225f8529b9309becaeef62b6c4/scikit_learn-1.8.0.tar.gz", upload-time = 2025-12-10T07:08:53Z, size = 7335585, hashes = { sha256 = "9bccbb3b40e3de10351f8f5068e105d0f4083b1a65fa07b6634fbc401a6287fd" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/97/74/b7a304feb2b49df9fafa9382d4d09061a96ee9a9449a7cbea7988dda0828/scikit_learn-1.8.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-12-10T07:07:57Z, size = 8931904, hashes = { sha256 = "a0bcfe4d0d14aec44921545fd2af2338c7471de9cb701f1da4c9d85906ab847a" } }] + +[[packages]] +name = "scipy" +version = "1.17.1" +sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", upload-time = 2026-02-23T00:26:24Z, size = 30573822, hashes = { sha256 = "95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/01/8e/1e35281b8ab6d5d72ebe9911edcdffa3f36b04ed9d51dec6dd140396e220/scipy-1.17.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-02-23T00:18:49Z, size = 35235890, hashes = { sha256 = "02ae3b274fde71c5e92ac4d54bc06c42d80e399fec704383dcd99b301df37458" } }] + +[[packages]] +name = "sentence-transformers" +version = "5.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/9d/59/867381b1414a975da6c9953f48a07c05cb0629305e2d37c9bcc9764367b2/sentence_transformers-5.7.0.tar.gz", upload-time = 2026-08-06T12:12:33Z, size = 466382, hashes = { sha256 = "fd8c8fc35e6323631dff9f3760969ebf7980dc3cfda0ab1354bc6a774cc0e5d8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e8/c8/f63d99e354532f5b83e735dd1e001bda92495fbfde934f65d924abf2b071/sentence_transformers-5.7.0-py3-none-any.whl", upload-time = 2026-08-06T12:12:31Z, size = 611333, hashes = { sha256 = "b78141da3d8137e70d965866e2ca43190b9266f3d4d8752e250ded75e7136730" } }] + +[[packages]] +name = "setuptools" +version = "83.0.0" +marker = "python_full_version >= '3.12'" +sdist = { url = "https://files.pythonhosted.org/packages/34/26/f5d29e25ffdb535afef2d35cdb55b325298f96debd670da4c325e08d70f4/setuptools-83.0.0.tar.gz", upload-time = 2026-07-04T15:31:22Z, size = 1154254, hashes = { sha256 = "025bccbbf0fa05b6192bc64ae1e7b16e001fd6d6d4d5de03c97b1c1ade523bef" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5d/40/e1e72872c6354b306daef1703549e8e83b4d43cfea356311bf722a043752/setuptools-83.0.0-py3-none-any.whl", upload-time = 2026-07-04T15:31:20Z, size = 1008090, hashes = { sha256 = "29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3" } }] + +[[packages]] +name = "shellingham" +version = "1.5.4" +sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", upload-time = 2023-10-24T04:13:40Z, size = 10310, hashes = { sha256 = "8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", upload-time = 2023-10-24T04:13:38Z, size = 9755, hashes = { sha256 = "7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686" } }] + +[[packages]] +name = "soundfile" +version = "0.14.0" +sdist = { url = "https://files.pythonhosted.org/packages/d2/db/949331952a6fb1c5b12e9de80fd08747966c2039d1a61db4764fbd3981c2/soundfile-0.14.0.tar.gz", upload-time = 2026-06-06T08:58:47Z, size = 47842, hashes = { sha256 = "ba1c1a2d618bca5c406647c83b89f07cc8810fa506a50622a6993ba130c1de11" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/d1/5e338af9ca6ed0786cd5bb03f6d60de1c325728c1189014f3b59aae7403c/soundfile-0.14.0-py2.py3-none-any.whl", upload-time = 2026-06-06T08:58:33Z, size = 26799, hashes = { sha256 = "8ba81ae3a89fd5ab3bef8a8eb481fbbe794e806309675a89b4df48b8d31908a8" } }, + { url = "https://files.pythonhosted.org/packages/7b/a2/70fd4432b924684c372df8b0a45708c36c057ef3596c9eb53e0a806b980b/soundfile-0.14.0-py2.py3-none-manylinux_2_28_x86_64.whl", upload-time = 2026-06-06T08:58:41Z, size = 1315963, hashes = { sha256 = "1e38bac1853412871318e82a1ba69a8be677619b56025bbfcccdb41b6cafe82d" } }, +] + +[[packages]] +name = "soxr" +version = "1.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/ed/11/27cebce4a108f77afea7c80545115536b45e3f11ebfb914f638fdd9ba847/soxr-1.1.0.tar.gz", upload-time = 2026-05-03T00:15:18Z, size = 173067, hashes = { sha256 = "9f228ae21c78fa9359ca98d8a5e8e91f30639e438e574133dace62c5b5309e44" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5c/f1/0e55195893228609c9a08c3b13b7a83a46c3a992cd00d3304f0f320cfb07/soxr-1.1.0-cp312-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-05-03T00:14:59Z, size = 240413, hashes = { sha256 = "3b033078e86f3c4a658e5697fac8995764fad9e799563616b630136b613167f1" } }] + +[[packages]] +name = "sympy" +version = "1.14.0" +sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", upload-time = 2025-04-27T18:05:01Z, size = 7793921, hashes = { sha256 = "d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", upload-time = 2025-04-27T18:04:59Z, size = 6299353, hashes = { sha256 = "e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5" } }] + +[[packages]] +name = "threadpoolctl" +version = "3.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/b7/4d/08c89e34946fce2aec4fbb45c9016efd5f4d7f24af8e5d93296e935631d8/threadpoolctl-3.6.0.tar.gz", upload-time = 2025-03-13T13:49:23Z, size = 21274, hashes = { sha256 = "8ab8b4aa3491d812b623328249fab5302a68d2d71745c8a4c719a2fcaba9f44e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", upload-time = 2025-03-13T13:49:21Z, size = 18638, hashes = { sha256 = "43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb" } }] + +[[packages]] +name = "tiktoken" +version = "0.12.0" +sdist = { url = "https://files.pythonhosted.org/packages/7d/ab/4d017d0f76ec3171d469d80fc03dfbb4e48a4bcaddaa831b31d526f05edc/tiktoken-0.12.0.tar.gz", upload-time = 2025-10-06T20:22:45Z, size = 37806, hashes = { sha256 = "b18ba7ee2b093863978fcb14f74b3707cdc8d4d4d3836853ce7ec60772139931" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f4/90/3dae6cc5436137ebd38944d396b5849e167896fc2073da643a49f372dc4f/tiktoken-0.12.0-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2025-10-06T20:21:56Z, size = 1152665, hashes = { sha256 = "edde1ec917dfd21c1f2f8046b86348b0f54a2c0547f68149d8600859598769ad" } }] + +[[packages]] +name = "tokenizers" +version = "0.23.3" +sdist = { url = "https://files.pythonhosted.org/packages/e0/7c/2cabb2174e772636683008f2c5621949b645da7d303c596589e84516a184/tokenizers-0.23.3.tar.gz", upload-time = 2026-10-09T10:16:55Z, size = 385286, hashes = { sha256 = "cded33237c77caeef62944d32aa9a7ef42bdce2b3497e18d137e072a8c4be438" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3a/40/6706b82693715581457c6d5423eaa7faae576bb0526c5738a57085eb4449/tokenizers-0.23.3-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-10-09T10:01:05Z, size = 3396193, hashes = { sha256 = "376851d22bcf9d650a5c3090bb83e6cf9e895fbf0595369fa4cd43c1f69b5f87" } }] + +[[packages]] +name = "torch" +version = "2.9.1" +wheels = [{ url = "https://files.pythonhosted.org/packages/19/17/e377a460603132b00760511299fceba4102bd95db1a0ee788da21298ccff/torch-2.9.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2025-11-12T15:22:17Z, size = 899742281, hashes = { sha256 = "27331cd902fb4322252657f3902adf1c4f6acad9dcad81d8df3ae14c7c4f07c4" } }] + +[[packages]] +name = "torchvision" +version = "0.24.1" +wheels = [{ url = "https://files.pythonhosted.org/packages/93/b1/db2941526ecddd84884132e2742a55c9311296a6a38627f9e2627f5ac889/torchvision-0.24.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2025-11-12T15:25:13Z, size = 8049868, hashes = { sha256 = "66a98471fc18cad9064123106d810a75f57f0838eee20edc56233fd8484b0cc7" } }] + +[[packages]] +name = "tqdm" +version = "4.67.3" +sdist = { url = "https://files.pythonhosted.org/packages/09/a9/6ba95a270c6f1fbcd8dac228323f2777d886cb206987444e4bce66338dd4/tqdm-4.67.3.tar.gz", upload-time = 2026-02-03T17:35:53Z, size = 169598, hashes = { sha256 = "7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", upload-time = 2026-02-03T17:35:50Z, size = 78374, hashes = { sha256 = "ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf" } }] + +[[packages]] +name = "transformers" +version = "5.17.0" +sdist = { url = "https://files.pythonhosted.org/packages/0e/9e/750649904a065007a838981785b2bd8d9ff26154c6c341ac67d0b7f82c68/transformers-5.17.0.tar.gz", upload-time = 2026-09-09T15:39:56Z, size = 9817878, hashes = { sha256 = "a153be279169b55b92d8000bf4af294aed684503d091cca7804da2dd8a9de000" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e8/d0/c502b60d684adbd98a8dc7d5bb866842772b816ac4354e4608be240041ae/transformers-5.17.0-py3-none-any.whl", upload-time = 2026-09-09T15:39:53Z, size = 12295140, hashes = { sha256 = "78ec1ce21579b38dfb83950a0658cd119f87212a2fcfdff478096ce9d6c03801" } }] + +[[packages]] +name = "triton" +version = "3.5.1" +marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/f2/50/9a8358d3ef58162c0a415d173cfb45b67de60176e1024f71fbc4d24c0b6d/triton-3.5.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-11-11T17:41:00Z, size = 170470207, hashes = { sha256 = "d2c6b915a03888ab931a9fd3e55ba36785e1fe70cbea0b40c6ef93b20fc85232" } }] + +[[packages]] +name = "typer" +version = "0.21.2" +sdist = { url = "https://files.pythonhosted.org/packages/f2/1e/a27cc02a0cd715118c71fa2aef2c687fdefc3c28d90fd0dd789c5118154c/typer-0.21.2.tar.gz", upload-time = 2026-02-10T19:33:46Z, size = 120426, hashes = { sha256 = "1abd95a3b675e17ff61b0838ac637fe9478d446d62ad17fa4bb81ea57cc54028" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b8/cc/d59f893fbdfb5f58770c05febfc4086a46875f1084453621c35605cec946/typer-0.21.2-py3-none-any.whl", upload-time = 2026-02-10T19:33:48Z, size = 56728, hashes = { sha256 = "c3d8de54d00347ef90b82131ca946274f017cffb46683ae3883c360fa958f55c" } }] + +[[packages]] +name = "typing-extensions" +version = "4.15.0" +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", upload-time = 2025-08-25T13:49:26Z, size = 109391, hashes = { sha256 = "0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", upload-time = 2025-08-25T13:49:24Z, size = 44614, hashes = { sha256 = "f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548" } }] + +[[packages]] +name = "typing-inspection" +version = "0.4.2" +sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", upload-time = 2025-10-01T02:14:41Z, size = 75949, hashes = { sha256 = "ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", upload-time = 2025-10-01T02:14:40Z, size = 14611, hashes = { sha256 = "4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7" } }] + +[[packages]] +name = "urllib3" +version = "2.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", upload-time = 2026-05-07T16:13:18Z, size = 433602, hashes = { sha256 = "231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", upload-time = 2026-05-07T16:13:17Z, size = 131087, hashes = { sha256 = "9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897" } }] diff --git a/packages/sie_server/bundle-locks/cuda13-sglang-cu130-amd64/manifest.json b/packages/sie_server/bundle-locks/cuda13-sglang-cu130-amd64/manifest.json new file mode 100644 index 000000000..d1f3231dd --- /dev/null +++ b/packages/sie_server/bundle-locks/cuda13-sglang-cu130-amd64/manifest.json @@ -0,0 +1,43 @@ +{ + "completed_artifact_hashes": [ + { + "bytes": 134899, + "sha256": "85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", + "url": "https://download.pytorch.org/whl/jinja2-3.1.6-py3-none-any.whl" + }, + { + "bytes": 22947, + "sha256": "d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", + "url": "https://download.pytorch.org/whl/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl" + } + ], + "exceptions_sha256": "2dd348b07e31ef1b1bbd28fe47fca6e702d194085d2cef6825a2610845cd8852", + "exclude_newer": "2026-10-18T00:00:00Z", + "indexes": [ + "--default-index", + "https://pypi.org/simple", + "--index", + "https://download.pytorch.org/whl/cu130", + "--index", + "https://docs.sglang.ai/whl/cu130/", + "--index-strategy", + "unsafe-best-match", + "--prerelease", + "allow" + ], + "inputs": { + "requirements_sha256": "6d29b7815d5f5105dbc70e23f5c3c51a225c6b2e0127eca3834a327d94eeec4a", + "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" + }, + "lock_sha256": "619a3c7eedc61badcd94a3a19988aa204fc53299b63e8c721723d0697c28d787", + "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "schema_version": 1, + "target": { + "architecture": "amd64", + "bundle": "sglang-cu130", + "platform": "cuda13", + "python_platform": "x86_64-manylinux_2_35", + "python_version": "3.12" + }, + "uv_version": "0.9.28" +} diff --git a/packages/sie_server/bundle-locks/cuda13-sglang-cu130-amd64/pylock.toml b/packages/sie_server/bundle-locks/cuda13-sglang-cu130-amd64/pylock.toml new file mode 100644 index 000000000..80a1ec393 --- /dev/null +++ b/packages/sie_server/bundle-locks/cuda13-sglang-cu130-amd64/pylock.toml @@ -0,0 +1,1282 @@ +lock-version = "1.0" +created-by = "uv" +requires-python = ">=3.12" + +[[packages]] +name = "aiohappyeyeballs" +version = "2.6.1" +sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", upload-time = 2025-03-12T01:42:48Z, size = 22760, hashes = { sha256 = "c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", upload-time = 2025-03-12T01:42:47Z, size = 15265, hashes = { sha256 = "f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8" } }] + +[[packages]] +name = "aiohttp" +version = "3.14.3" +sdist = { url = "https://files.pythonhosted.org/packages/58/d9/22ce5786ac0c1653ae8b6c23bded02c1686d11f0dbb45b31ce128e0df985/aiohttp-3.14.3.tar.gz", upload-time = 2026-07-23T01:57:27Z, size = 7971213, hashes = { sha256 = "9491196535a88924a60afd5b5f434b5b203b6cc616250878dbdb223a8f7844bc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/52/b7/7cd31f29d6055bd711ae6e669367fba6f5ae9de463910a793e30556a8db7/aiohttp-3.14.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-23T01:54:15Z, size = 1792122, hashes = { sha256 = "543906c127fb1d929b95076db19b83fa2d46751006ff1e23b093aa5ac4d8db42" } }] + +[[packages]] +name = "aiosignal" +version = "1.4.0" +sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", upload-time = 2025-07-03T22:54:43Z, size = 25007, hashes = { sha256 = "f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", upload-time = 2025-07-03T22:54:42Z, size = 7490, hashes = { sha256 = "053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e" } }] + +[[packages]] +name = "airportsdata" +version = "20260905" +sdist = { url = "https://files.pythonhosted.org/packages/a5/c2/69ec4b992746c4c7b076a7afffb11fc64267d684ed0cd3db00035f0f682b/airportsdata-20260905.tar.gz", upload-time = 2026-09-05T06:02:21Z, size = 929470, hashes = { sha256 = "a7e17469458ca356a5ca9971f49864b934a559d43e1587e19219cb981d364c45" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/45/f8/65e9d476f84bb60ac7ff1fe525acdd60fe6b4b585ae6f074c947c6ad0fc1/airportsdata-20260905-py3-none-any.whl", upload-time = 2026-09-05T06:02:19Z, size = 931164, hashes = { sha256 = "d7eaa9a57d373b0adaaae0d52da2af0bb0edf73f7baa170f7c415d3342bf4868" } }] + +[[packages]] +name = "annotated-doc" +version = "0.0.4" +sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", upload-time = 2025-11-10T22:07:42Z, size = 7288, hashes = { sha256 = "fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", upload-time = 2025-11-10T22:07:40Z, size = 5303, hashes = { sha256 = "571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320" } }] + +[[packages]] +name = "annotated-types" +version = "0.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", upload-time = 2024-05-20T21:33:25Z, size = 16081, hashes = { sha256 = "aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", upload-time = 2024-05-20T21:33:24Z, size = 13643, hashes = { sha256 = "1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53" } }] + +[[packages]] +name = "anthropic" +version = "1.15.0" +sdist = { url = "https://files.pythonhosted.org/packages/10/37/5a2a4316df8babd28f096477a707cd75f240b4264c97fb128c32375105d6/anthropic-1.15.0.tar.gz", upload-time = 2026-10-15T19:45:34Z, size = 1726101, hashes = { sha256 = "90caa9df83e2fc8bddb4ddeb83b7191bce255f635c03eae055deec521741df08" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d1/65/54437e7edea49a3be9ef56f6b5965999bfdc52b9dadc9b448124ca51a594/anthropic-1.15.0-py3-none-any.whl", upload-time = 2026-10-15T19:45:32Z, size = 2047755, hashes = { sha256 = "10189a7993c5c71a0a2d4bb80020ca6a2fd27679f51e627405da37251d15ff49" } }] + +[[packages]] +name = "anyio" +version = "4.14.2" +sdist = { url = "https://files.pythonhosted.org/packages/61/cc/a381afa6efea9f496eff839d4a6a1aed3bfafc7b3ab4b0d1b243a12573dd/anyio-4.14.2.tar.gz", upload-time = 2026-07-12T20:29:07Z, size = 260176, hashes = { sha256 = "cfa139f3ed1a23ee8f88a145ddb5ac7605b8bbfd8592baacd7ce3d8bb4313c7f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/da/35/f2287558c17e29fafc8ef3daf819bb9834061cfa43bff8014f7df7f63bdc/anyio-4.14.2-py3-none-any.whl", upload-time = 2026-07-12T20:29:05Z, size = 125813, hashes = { sha256 = "9f505dda5ac9f0c8309b5e8bd445a8c2bf7246f3ce950121e45ea15bc41d1494" } }] + +[[packages]] +name = "apache-tvm-ffi" +version = "0.1.11" +sdist = { url = "https://files.pythonhosted.org/packages/6d/3d/4b9226cd45aa800a6904603dda9b323d728f3c3869952a673f3483b78b19/apache_tvm_ffi-0.1.11.tar.gz", upload-time = 2026-05-04T17:48:43Z, size = 2798354, hashes = { sha256 = "153cd2c5a9717804cb0bcd9b2709f22a1e5f80ed05b5a490faf5949b136eedba" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/36/99/2848df4e8ed5bf51df1d286d1718510584fa61e88adbc9c5b23d71b38f7c/apache_tvm_ffi-0.1.11-cp312-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-05-04T17:48:01Z, size = 2725887, hashes = { sha256 = "78aa1857b04a2ea718317041ab3f01288b3d496e6036eb1b99ebdc9da0fdaef5" } }, + { url = "https://files.pythonhosted.org/packages/4d/18/95569107ee83619d61a3bb0d28743a0599f85c5161981e3e098c82c2b185/apache_tvm_ffi-0.1.11-cp312-abi3-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-05-04T17:48:05Z, size = 2697683, hashes = { sha256 = "2843f084cdc94dedacd8b257a395a2b71b8a3dc7fc99711b148bf1d161983128" } }, +] + +[[packages]] +name = "asttokens" +version = "3.0.1" +sdist = { url = "https://files.pythonhosted.org/packages/be/a5/8e3f9b6771b0b408517c82d97aed8f2036509bc247d46114925e32fe33f0/asttokens-3.0.1.tar.gz", upload-time = 2025-11-15T16:43:48Z, size = 62308, hashes = { sha256 = "71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d2/39/e7eaf1799466a4aef85b6a4fe7bd175ad2b1c6345066aa33f1f58d4b18d0/asttokens-3.0.1-py3-none-any.whl", upload-time = 2025-11-15T16:43:16Z, size = 27047, hashes = { sha256 = "15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a" } }] + +[[packages]] +name = "attrs" +version = "26.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", upload-time = 2026-03-19T14:22:25Z, size = 952055, hashes = { sha256 = "d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", upload-time = 2026-03-19T14:22:23Z, size = 67548, hashes = { sha256 = "c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309" } }] + +[[packages]] +name = "blobfile" +version = "3.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/9d/a9/a34e8153b0203d9060ff7aa5dfcd175e161117949697a83c4cc003b523ff/blobfile-3.0.0.tar.gz", upload-time = 2024-08-27T00:02:53Z, size = 77863, hashes = { sha256 = "32ec777414de7bb2a76ca812a838f0d33327ca28ae844a253503cde625cdf2f1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ed/4d/1392562369b1139e741b30d624f09fe7091d17dd5579fae5732f044b12bb/blobfile-3.0.0-py3-none-any.whl", upload-time = 2024-08-27T00:02:51Z, size = 75413, hashes = { sha256 = "48ecc3307e622804bd8fe13bf6f40e6463c4439eba7a1f9ad49fd78aa63cc658" } }] + +[[packages]] +name = "build" +version = "1.4.4" +sdist = { url = "https://files.pythonhosted.org/packages/02/ec/bf5ae0a7e5ab57abe8aabdd0759c971883895d1a20c49ae99f8146840c3c/build-1.4.4.tar.gz", upload-time = 2026-04-22T20:53:44Z, size = 89220, hashes = { sha256 = "f832ae053061f3fb524af812dc94b8b84bac6880cd587630e3b5d91a6a9c1703" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/fa/88/6764e7a109dd84294850741501145da90d13cdeac9d4e614929464a37420/build-1.4.4-py3-none-any.whl", upload-time = 2026-04-22T20:53:43Z, size = 25921, hashes = { sha256 = "8c3f48a6090b39edec1a273d2d57949aaf13723b01e02f9d518396887519f64d" } }] + +[[packages]] +name = "certifi" +version = "2026.4.22" +sdist = { url = "https://files.pythonhosted.org/packages/25/ee/6caf7a40c36a1220410afe15a1cc64993a1f864871f698c0f93acb72842a/certifi-2026.4.22.tar.gz", upload-time = 2026-04-22T11:26:11Z, size = 137077, hashes = { sha256 = "8d455352a37b71bf76a79caa83a3d6c25afee4a385d632127b6afb3963f1c580" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/22/30/7cd8fdcdfbc5b869528b079bfb76dcdf6056b1a2097a662e5e8c04f42965/certifi-2026.4.22-py3-none-any.whl", upload-time = 2026-04-22T11:26:09Z, size = 135707, hashes = { sha256 = "3cb2210c8f88ba2318d29b0388d1023c8492ff72ecdde4ebdaddbb13a31b1c4a" } }] + +[[packages]] +name = "cffi" +version = "2.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", upload-time = 2025-09-08T23:24:04Z, size = 523588, hashes = { sha256 = "44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-09-08T23:22:52Z, size = 219572, hashes = { sha256 = "3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba" } }] + +[[packages]] +name = "charset-normalizer" +version = "3.4.7" +sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", upload-time = 2026-04-02T09:28:39Z, size = 144271, hashes = { sha256 = "ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4b/f8/d0118a2f5f23b02cd166fa385c60f9b0d4f9194f574e2b31cef350ad7223/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-02T09:26:29Z, size = 216589, hashes = { sha256 = "5649fd1c7bade02f320a462fdefd0b4bd3ce036065836d4f42e0de958038e116" } }, + { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", upload-time = 2026-04-02T09:28:37Z, size = 61958, hashes = { sha256 = "3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d" } }, +] + +[[packages]] +name = "click" +version = "8.1.8" +sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", upload-time = 2024-12-21T18:38:44Z, size = 226593, hashes = { sha256 = "ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", upload-time = 2024-12-21T18:38:41Z, size = 98188, hashes = { sha256 = "63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2" } }] + +[[packages]] +name = "cloudpickle" +version = "3.1.2" +sdist = { url = "https://files.pythonhosted.org/packages/27/fb/576f067976d320f5f0114a8d9fa1215425441bb35627b1993e5afd8111e5/cloudpickle-3.1.2.tar.gz", upload-time = 2025-11-03T09:25:26Z, size = 22330, hashes = { sha256 = "7fda9eb655c9c230dab534f1983763de5835249750e85fbcef43aaa30a9a2414" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl", upload-time = 2025-11-03T09:25:25Z, size = 22228, hashes = { sha256 = "9acb47f6afd73f60dc1df93bb801b472f05ff42fa6c84167d25cb206be1fbf4a" } }] + +[[packages]] +name = "compressed-tensors" +version = "0.18.0" +sdist = { url = "https://files.pythonhosted.org/packages/68/3c/93365d6edb698395232d8375273f289d4796a4ec25f49fcd58efbfeaeb4f/compressed_tensors-0.18.0.tar.gz", upload-time = 2026-08-08T01:51:53Z, size = 289481, hashes = { sha256 = "56b90295637cd4027b52041676f6c4e6cb933e1ca10f114b345fddde00c16b8b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2f/bf/e17189bd834e5a4487c97ed576564a66ab56ccd7840608f49dcecf61abfc/compressed_tensors-0.18.0-py3-none-any.whl", upload-time = 2026-08-08T01:51:52Z, size = 224997, hashes = { sha256 = "91168237c2d815614c44dfc354c61c613085c811dabbb2ccdb929e9aaa313b8f" } }] + +[[packages]] +name = "cryptography" +version = "50.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/de/41/6cbdcf9142d00fe82836fbb51e503e58088575cf7a0fe1dbff6695bf0840/cryptography-50.0.0.tar.gz", upload-time = 2026-07-31T14:25:10Z, size = 880201, hashes = { sha256 = "eeac2acb5a20ed25e0ad6d1df9891a520b78b404266b6d11778f25d5d691a6c9" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/41/029086c34d91052fc3b88bcc8056f709a7c915c7a23b235a54eb800b1c97/cryptography-50.0.0-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-07-31T14:23:37Z, size = 4702130, hashes = { sha256 = "06a32a980526a6ab9a4b9bf8f7385800791e2bb960903cb6b530e4817509a3b7" } }, + { url = "https://files.pythonhosted.org/packages/6b/72/a1116d683a6d7ece94590013882515de087edf9ef0e6292aae615a44df73/cryptography-50.0.0-cp311-abi3-manylinux_2_28_x86_64.whl", upload-time = 2026-07-31T14:23:43Z, size = 4734609, hashes = { sha256 = "b42a28c1844fd9de8f3f7d540e36b66f3a9c83fceac7170ebc7a6a19edd9dcae" } }, + { url = "https://files.pythonhosted.org/packages/da/3a/f05e32c99d440c9bb891ea0e36c9091891e36be5a9a87ab2ee6ea20729f6/cryptography-50.0.0-cp311-abi3-manylinux_2_34_x86_64.whl", upload-time = 2026-07-31T14:23:50Z, size = 4734462, hashes = { sha256 = "82148ec5bddac30b51a5b3c1945075f896fa022cb93f8e4a01e9f6ee95292c5f" } }, + { url = "https://files.pythonhosted.org/packages/85/4f/0fa8c2f4428198f15d9ff8d63400e27afbf94ce833f6108da1eb3753f945/cryptography-50.0.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-07-31T14:24:27Z, size = 4728939, hashes = { sha256 = "a91296cb61e8df6f86d0c19cc4068228da256bf59bf86049fbd821084565327f" } }, + { url = "https://files.pythonhosted.org/packages/46/c9/f60aed34c013f317f92817b6c171c2d22a78270fa41109bd4b08af26b194/cryptography-50.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", upload-time = 2026-07-31T14:24:34Z, size = 4762647, hashes = { sha256 = "105110f43a471dbd0060b9c9516cb8a6a79233631a04cc2ba16f28323ac6e025" } }, + { url = "https://files.pythonhosted.org/packages/9c/f8/d97f9603efda3888187bfdb893f26c41be4735c10631d05d284ee6b047c4/cryptography-50.0.0-cp39-abi3-manylinux_2_34_x86_64.whl", upload-time = 2026-07-31T14:24:43Z, size = 4762400, hashes = { sha256 = "37fdb0d0111f1e2ff07139dfb79f1b49531f8e213c46f1163dd7642979b58c47" } }, +] + +[[packages]] +name = "cuda-bindings" +version = "13.4.4" +wheels = [{ url = "https://files.pythonhosted.org/packages/c2/f8/332443cf969734551891cdbd93657eaeaf747ac2b7dd73feb3422701b02b/cuda_bindings-13.4.4-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-10-14T12:35:22Z, size = 7172184, hashes = { sha256 = "433efa31e33c2868621b5f6036bd3bf5de9c45c5546cb1361a5f6ff3415b8bb5" } }] + +[[packages]] +name = "cuda-core" +version = "1.2.2" +wheels = [{ url = "https://files.pythonhosted.org/packages/f2/1c/8e1f7d42984d6b164521a1dec587f3cf6d1fc585ff929f1420faa07da9d3/cuda_core-1.2.2-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-10-16T13:58:51Z, size = 6610599, hashes = { sha256 = "0b299eee52edece08b77428cfc22b33b29be1bc69c42878d2e6114031eac17e6" } }] + +[[packages]] +name = "cuda-pathfinder" +version = "1.8.3" +wheels = [{ url = "https://files.pythonhosted.org/packages/b9/fb/f8e1890428f9f590b4beebd63b068aac1ce32a3331510c847b9f9a78f261/cuda_pathfinder-1.8.3-py3-none-any.whl", upload-time = 2026-10-02T03:20:23Z, size = 62561, hashes = { sha256 = "e29e59829c297a7a5233bd9cc71094fc5bddbd076951482670178f9eade39b1f" } }] + +[[packages]] +name = "cuda-python" +version = "13.4.4" +wheels = [{ url = "https://files.pythonhosted.org/packages/e1/2c/04c83864345051c6281396cd29d7190de1a23e2a533fa038c30b5552eb59/cuda_python-13.4.4-py3-none-any.whl", upload-time = 2026-10-14T12:49:47Z, size = 7594, hashes = { sha256 = "2a4a35c7f102e3c51b9e18e65b34a24b82d7363893b6e2f228978c18bafa1957" } }] + +[[packages]] +name = "cuda-tile" +version = "1.6.0rc5" +sdist = { url = "https://files.pythonhosted.org/packages/7e/d2/177db716b66a1895874aa3ef119645d0bc54fff8cfc6d299b309f366e6b8/cuda_tile-1.6.0rc5.tar.gz", upload-time = 2026-08-06T22:06:44Z, size = 6930, hashes = { sha256 = "611bbd7d3efb81763a3790374d23c8a6f0ecc16735e69e4d3f9ef7762d9335e8" } } + +[[packages]] +name = "cuda-toolkit" +version = "13.0.3.0" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/d1/c7/a79086a62c98befcdb8349656c6f114e2db3b8b2422f6e25c97a7f2a9a3c/cuda_toolkit-13.0.3.0-py2.py3-none-any.whl", upload-time = 2026-04-14T00:50:08Z, size = 2512, hashes = { sha256 = "d693caaa261214ddd7dbb60d68e71cbed884e68c2be7509778f3051da0b91c3f" } }] + +[[packages]] +name = "cython" +version = "3.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/a9/d8/4981ef716ad0e3ff0d3ef383aefc6b03c4a88dee33b272bf8e0d833001ca/cython-3.3.0.tar.gz", upload-time = 2026-08-22T05:16:39Z, size = 3727515, hashes = { sha256 = "eed0d93fbca7087f143b42c34b05a825849bdf17f101572c2105acfa49aa88b8" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/4e/6b1c5a4e6bbe1726104de007aa2fdf01a3e2e386b4ec93c7be5f5085d53f/cython-3.3.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-08-22T05:17:12Z, size = 3412225, hashes = { sha256 = "428fafed98ea26927000a287b4dfc9ef07339f56656a5329a34eaa593f79a4f8" } }, + { url = "https://files.pythonhosted.org/packages/bf/77/67b0b24e45073a699610e50f00c18474ff9b09ea29ecc95083bdf5e60acd/cython-3.3.0-py3-none-any.whl", upload-time = 2026-08-22T05:16:36Z, size = 1349151, hashes = { sha256 = "9b24b5c8cd536946b62086fcafee6d5509d3f549f72d553d2336af87ffbe0da1" } }, +] + +[[packages]] +name = "datasets" +version = "3.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/1a/89/d3d6fef58a488f8569c82fd293ab7cbd4250244d67f425dcae64c63800ea/datasets-3.6.0.tar.gz", upload-time = 2025-05-07T15:15:02Z, size = 569336, hashes = { sha256 = "1b2bf43b19776e2787e181cfd329cb0ca1a358ea014780c3581e0f276375e041" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/20/34/a08b0ee99715eaba118cbe19a71f7b5e2425c2718ef96007c325944a1152/datasets-3.6.0-py3-none-any.whl", upload-time = 2025-05-07T15:14:59Z, size = 491546, hashes = { sha256 = "25000c4a2c0873a710df127d08a202a06eab7bf42441a6bc278b499c2f72cd1b" } }] + +[[packages]] +name = "decorator" +version = "5.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", upload-time = 2025-02-24T04:41:34Z, size = 56711, hashes = { sha256 = "65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", upload-time = 2025-02-24T04:41:32Z, size = 9190, hashes = { sha256 = "d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a" } }] + +[[packages]] +name = "dill" +version = "0.3.8" +sdist = { url = "https://files.pythonhosted.org/packages/17/4d/ac7ffa80c69ea1df30a8aa11b3578692a5118e7cd1aa157e3ef73b092d15/dill-0.3.8.tar.gz", upload-time = 2024-01-27T23:42:16Z, size = 184847, hashes = { sha256 = "3ebe3c479ad625c4553aca177444d89b486b1d84982eeacded644afc0cf797ca" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c9/7a/cef76fd8438a42f96db64ddaa85280485a9c395e7df3db8158cfec1eee34/dill-0.3.8-py3-none-any.whl", upload-time = 2024-01-27T23:42:14Z, size = 116252, hashes = { sha256 = "c36ca9ffb54365bdd2f8eb3eff7d2a21237f8452b57ace88b1ac615b7e815bd7" } }] + +[[packages]] +name = "diskcache" +version = "5.6.3" +sdist = { url = "https://files.pythonhosted.org/packages/3f/21/1c1ffc1a039ddcc459db43cc108658f32c57d271d7289a2794e401d0fdb6/diskcache-5.6.3.tar.gz", upload-time = 2023-08-31T06:12:00Z, size = 67916, hashes = { sha256 = "2c3a3fa2743d8535d832ec61c2054a1641f41775aa7c556758a109941e33e4fc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3f/27/4570e78fc0bf5ea0ca45eb1de3818a23787af9b390c0b0a0033a1b8236f9/diskcache-5.6.3-py3-none-any.whl", upload-time = 2023-08-31T06:11:58Z, size = 45550, hashes = { sha256 = "5e31b2d5fbad117cc363ebaf6b689474db18a1f6438bc82358b024abd4c2ca19" } }] + +[[packages]] +name = "distro" +version = "1.9.0" +sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", upload-time = 2023-12-24T09:54:32Z, size = 60722, hashes = { sha256 = "2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", upload-time = 2023-12-24T09:54:30Z, size = 20277, hashes = { sha256 = "7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2" } }] + +[[packages]] +name = "docstring-parser" +version = "0.18.0" +sdist = { url = "https://files.pythonhosted.org/packages/e0/4d/f332313098c1de1b2d2ff91cf2674415cc7cddab2ca1b01ae29774bd5fdf/docstring_parser-0.18.0.tar.gz", upload-time = 2026-04-14T04:09:19Z, size = 29341, hashes = { sha256 = "292510982205c12b1248696f44959db3cdd1740237a968ea1e2e7a900eeb2015" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a7/5f/ed01f9a3cdffbd5a008556fc7b2a08ddb1cc6ace7effa7340604b1d16699/docstring_parser-0.18.0-py3-none-any.whl", upload-time = 2026-04-14T04:09:18Z, size = 22484, hashes = { sha256 = "b3fcbed555c47d8479be0796ef7e19c2670d428d72e96da63f3a40122860374b" } }] + +[[packages]] +name = "easydict" +version = "1.13" +sdist = { url = "https://files.pythonhosted.org/packages/24/9f/d18d6b5e19244788a6d09c14a8406376b4f4bfcc008e6d17a4f4c15362e8/easydict-1.13.tar.gz", upload-time = 2024-03-04T12:04:41Z, size = 6809, hashes = { sha256 = "b1135dedbc41c8010e2bc1f77ec9744c7faa42bce1a1c87416791449d6c87780" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/05/ec/fa6963f1198172c2b75c9ab6ecefb3045991f92f75f5eb41b6621b198123/easydict-1.13-py3-none-any.whl", upload-time = 2024-03-04T12:04:39Z, size = 6804, hashes = { sha256 = "6b787daf4dcaf6377b4ad9403a5cee5a86adbc0ca9a5bcf5410e9902002aeac2" } }] + +[[packages]] +name = "einops" +version = "0.8.2" +sdist = { url = "https://files.pythonhosted.org/packages/2c/77/850bef8d72ffb9219f0b1aac23fbc1bf7d038ee6ea666f331fa273031aa2/einops-0.8.2.tar.gz", upload-time = 2026-01-26T04:13:17Z, size = 56261, hashes = { sha256 = "609da665570e5e265e27283aab09e7f279ade90c4f01bcfca111f3d3e13f2827" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/09/f8d8f8f31e4483c10a906437b4ce31bdf3d6d417b73fe33f1a8b59e34228/einops-0.8.2-py3-none-any.whl", upload-time = 2026-01-26T04:13:18Z, size = 65638, hashes = { sha256 = "54058201ac7087911181bfec4af6091bb59380360f069276601256a76af08193" } }] + +[[packages]] +name = "executing" +version = "2.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", upload-time = 2025-09-01T09:48:10Z, size = 1129488, hashes = { sha256 = "3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", upload-time = 2025-09-01T09:48:08Z, size = 28317, hashes = { sha256 = "760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017" } }] + +[[packages]] +name = "fastapi" +version = "0.136.1" +sdist = { url = "https://files.pythonhosted.org/packages/5d/45/c130091c2dfa061bbfe3150f2a5091ef1adf149f2a8d2ae769ecaf6e99a2/fastapi-0.136.1.tar.gz", upload-time = 2026-04-23T16:49:44Z, size = 397448, hashes = { sha256 = "7af665ad7acfa0a3baf8983d393b6b471b9da10ede59c60045f49fbc89a0fa7f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5a/ff/2e4eca3ade2c22fe1dea7043b8ee9dabe47753349eb1b56a202de8af6349/fastapi-0.136.1-py3-none-any.whl", upload-time = 2026-04-23T16:49:42Z, size = 117683, hashes = { sha256 = "a6e9d7eeada96c93a4d69cb03836b44fa34e2854accb7244a1ece36cd4781c3f" } }] + +[[packages]] +name = "filelock" +version = "3.29.0" +sdist = { url = "https://files.pythonhosted.org/packages/b5/fe/997687a931ab51049acce6fa1f23e8f01216374ea81374ddee763c493db5/filelock-3.29.0.tar.gz", upload-time = 2026-04-19T15:39:10Z, size = 57571, hashes = { sha256 = "69974355e960702e789734cb4871f884ea6fe50bd8404051a3530bc07809cf90" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/81/47/dd9a212ef6e343a6857485ffe25bba537304f1913bdbed446a23f7f592e1/filelock-3.29.0-py3-none-any.whl", upload-time = 2026-04-19T15:39:08Z, size = 39812, hashes = { sha256 = "96f5f6344709aa1572bbf631c640e4ebeeb519e08da902c39a001882f30ac258" } }] + +[[packages]] +name = "flash-attn-4" +version = "4.0.0b35" +sdist = { url = "https://files.pythonhosted.org/packages/dc/04/8749f4e48bc7f30a502fcd93985792281da2170b676a1dd641ed0880c5b4/flash_attn_4-4.0.0b35.tar.gz", upload-time = 2026-10-14T08:21:14Z, size = 481472, hashes = { sha256 = "45c48469c851c54052f0004c9679b19ea7d70423960788a5be570a75f189e0ab" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/bc/46/020652846c4028f4ec0af1d0f8f9ef1067a2813b9539fa666f4190ba86aa/flash_attn_4-4.0.0b35-py3-none-any.whl", upload-time = 2026-10-14T08:21:12Z, size = 509535, hashes = { sha256 = "6df9a60fab0ca55c3f9c35244e794411afeff565100955e40db6c73e72848f94" } }] + +[[packages]] +name = "flashinfer-python" +version = "0.6.18" +sdist = { url = "https://files.pythonhosted.org/packages/3e/72/12066c5f42a49e7eabe6ec445ac73c59785480bba1b763bd7e0a512f13c1/flashinfer_python-0.6.18.tar.gz", upload-time = 2026-08-29T02:09:18Z, size = 13286160, hashes = { sha256 = "70a2074d78cb17ed39c98e5ed47f626c6e8bb29015cf028c49cbf8f2629405a1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/31/7d/3dae45fc293cd5f16cefe4dcf59683d964ca8faf2303ed7fff54f4bca490/flashinfer_python-0.6.18-py3-none-any.whl", upload-time = 2026-08-29T02:09:15Z, size = 18347767, hashes = { sha256 = "d5d26edb48f8def0bf28b2c94415aef7f0754e2cd9e3cb3d6e7081262d068aad" } }] + +[[packages]] +name = "frozenlist" +version = "1.8.0" +sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", upload-time = 2025-10-06T05:38:17Z, size = 45875, hashes = { sha256 = "3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2025-10-06T05:36:09Z, size = 242411, hashes = { sha256 = "494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383" } }, + { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", upload-time = 2025-10-06T05:38:16Z, size = 13409, hashes = { sha256 = "0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d" } }, +] + +[[packages]] +name = "fsspec" +version = "2025.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/34/f4/5721faf47b8c499e776bc34c6a8fc17efdf7fdef0b00f398128bc5dcb4ac/fsspec-2025.3.0.tar.gz", upload-time = 2025-03-07T21:47:56Z, size = 298491, hashes = { sha256 = "a935fd1ea872591f2b5148907d103488fc523295e6c64b835cfad8c3eca44972" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/56/53/eb690efa8513166adef3e0669afd31e95ffde69fb3c52ec2ac7223ed6018/fsspec-2025.3.0-py3-none-any.whl", upload-time = 2025-03-07T21:47:54Z, size = 193615, hashes = { sha256 = "efb87af3efa9103f94ca91a7f8cb7a4df91af9f74fc106c9c7ea0efd7277c1b3" } }] + +[[packages]] +name = "gguf" +version = "0.19.0" +sdist = { url = "https://files.pythonhosted.org/packages/48/ae/17f1308ae45cd7b08ebb521747d5b23f4efc4d172038a4e228dd5106c3ff/gguf-0.19.0.tar.gz", upload-time = 2026-05-06T13:04:03Z, size = 111220, hashes = { sha256 = "dbadcd6cc7ccd44256f2229fe7c2dff5e8aa5cf0612ab987fd2b1a57e428923f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b3/bb/d71d6da82763528c2c2ed6b59a9d6142c6595545a4c448e2085d155e88c2/gguf-0.19.0-py3-none-any.whl", upload-time = 2026-05-06T13:04:02Z, size = 118475, hashes = { sha256 = "70bcd10edfe697fb2dad6e40af2234b9d8ece9a41a99761405121ebda1c3c1cd" } }] + +[[packages]] +name = "grpcio" +version = "1.85.0rc1" +sdist = { url = "https://files.pythonhosted.org/packages/fd/2c/b149bcb59a6e74365d2e8387a29bf200300c4aeb1376961d94091d063f4a/grpcio-1.85.0rc1.tar.gz", upload-time = 2026-10-09T16:23:49Z, size = 14171507, hashes = { sha256 = "cd95cdbae5f87474d9888534f6e68b83b368615fbe6868a66fd96e67d5375812" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/66/52/8d29d8af710bc6723fbc28eb658eb7ab4c22b89ac9c3d5d84bc74a1fdd3c/grpcio-1.85.0rc1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-10-09T16:12:49Z, size = 7396140, hashes = { sha256 = "b5ae303310312ea0817a8c1ca46cf7ce1d10bc256e0e46b7e0b84f9cd5d316dd" } }] + +[[packages]] +name = "grpcio-health-checking" +version = "1.82.0rc2" +sdist = { url = "https://files.pythonhosted.org/packages/26/d8/c4df3bc46853b7bc2f2fdcf410ddeaee1ccb273703c9b0206da9f8fdb5e0/grpcio_health_checking-1.82.0rc2.tar.gz", upload-time = 2026-06-29T04:42:17Z, size = 17119, hashes = { sha256 = "07046aa0bb86775065cf0433147a8a9998d16a20fab9dff9eb5a635a24c2a9a5" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/83/cd/35927823932f881bd12a8241ca6be3356207beec3934b1131cf734da975b/grpcio_health_checking-1.82.0rc2-py3-none-any.whl", upload-time = 2026-06-29T04:42:01Z, size = 19155, hashes = { sha256 = "49a9d7caff4377198a8ac668ce1a6ee02d3290b4e5854e0194b812ad234ee67d" } }] + +[[packages]] +name = "grpcio-reflection" +version = "1.82.0rc2" +sdist = { url = "https://files.pythonhosted.org/packages/81/aa/15c7f564c397f0466bff48831753154c7f3149211cba4639657fa85e8288/grpcio_reflection-1.82.0rc2.tar.gz", upload-time = 2026-06-29T04:42:14Z, size = 19221, hashes = { sha256 = "7b1210e6776fb61219d557a5a9ff8129b830c2fc83ee2e96622a9ace60c82d99" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/76/41/ae2558849fd344cd25f10f2f4b5284b8fe66a13b6659fc94ddb093df8bbd/grpcio_reflection-1.82.0rc2-py3-none-any.whl", upload-time = 2026-06-29T04:42:05Z, size = 22944, hashes = { sha256 = "828468937cc6b5e3fd63e622be4667be2c2c195b5c24d9891f55de1538bb7cd7" } }] + +[[packages]] +name = "h11" +version = "0.16.0" +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", upload-time = 2025-04-24T03:35:25Z, size = 101250, hashes = { sha256 = "4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", upload-time = 2025-04-24T03:35:24Z, size = 37515, hashes = { sha256 = "63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86" } }] + +[[packages]] +name = "hf-xet" +version = "1.4.3" +marker = "platform_machine == 'AMD64' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" +sdist = { url = "https://files.pythonhosted.org/packages/53/92/ec9ad04d0b5728dca387a45af7bc98fbb0d73b2118759f5f6038b61a57e8/hf_xet-1.4.3.tar.gz", upload-time = 2026-03-31T22:40:07Z, size = 670477, hashes = { sha256 = "8ddedb73c8c08928c793df2f3401ec26f95be7f7e516a7bee2fbb546f6676113" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/df/9a/a24b26dc8a65f0ecc0fe5be981a19e61e7ca963b85e062c083f3a9100529/hf_xet-1.4.3-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-03-31T22:39:42Z, size = 4212320, hashes = { sha256 = "fc360b70c815bf340ed56c7b8c63aacf11762a4b099b2fe2c9bd6d6068668c08" } }] + +[[packages]] +name = "httpcore" +version = "1.0.9" +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", upload-time = 2025-04-24T22:06:22Z, size = 85484, hashes = { sha256 = "6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", upload-time = 2025-04-24T22:06:20Z, size = 78784, hashes = { sha256 = "2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55" } }] + +[[packages]] +name = "httpcore2" +version = "2.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/e6/34/18f1c596e677962f040284246f393b10a1f8ce440b3a7e69c637d0f1c7ad/httpcore2-2.3.0.tar.gz", upload-time = 2026-06-01T13:15:02Z, size = 64300, hashes = { sha256 = "07327e251560960eea8e969d92d4c6a325feb13cca39e25340731336c3baf924" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c2/dd/3357218c69360d1cecc196c230c9a1d5c9afd5dba362056e23e60a5e64e5/httpcore2-2.3.0-py3-none-any.whl", upload-time = 2026-06-01T13:15:00Z, size = 80024, hashes = { sha256 = "477e9e334f74e5240dcac002e890580f36a57d40ff0fb14cc9655731d23b8415" } }] + +[[packages]] +name = "httpx" +version = "0.28.1" +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", upload-time = 2024-12-06T15:37:23Z, size = 141406, hashes = { sha256 = "75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", upload-time = 2024-12-06T15:37:21Z, size = 73517, hashes = { sha256 = "d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad" } }] + +[[packages]] +name = "httpx2" +version = "2.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/9f/9a/cca0b9145f13d8ae34b885ae28d403a1469a433abc78e0f94f4ce94e650b/httpx2-2.3.0.tar.gz", upload-time = 2026-06-01T13:15:04Z, size = 81115, hashes = { sha256 = "227e7c41d95a76d4077a52640564132777215fc3394e07b66a3116c33d668fa9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/87/ce/ae2911859847f9ba1d6b23027e53481cbeb50b93234f355a968d300ca2cb/httpx2-2.3.0-py3-none-any.whl", upload-time = 2026-06-01T13:15:01Z, size = 74538, hashes = { sha256 = "6f393663bdf6dbe7fe90118e3eb5b2bd024a675cae0390ac08cec9198812d8b7" } }] + +[[packages]] +name = "huggingface-hub" +version = "1.16.1" +sdist = { url = "https://files.pythonhosted.org/packages/48/0f/ed994dbade67a54407c28cab96ef845e0e6d25500be56aca6394f8bfc9dd/huggingface_hub-1.16.1.tar.gz", upload-time = 2026-05-21T18:40:00Z, size = 792534, hashes = { sha256 = "7f1dc4c5ec21aed69be630ad0c3378616be16f3de1a47b141c0e812965d9c832" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/49/79/621a7dbb80c70974f73a597275351ebe03ce5bc65cb5f8f4acb5859252bc/huggingface_hub-1.16.1-py3-none-any.whl", upload-time = 2026-05-21T18:39:58Z, size = 668176, hashes = { sha256 = "64340de934b9ce37857ef85a82de72f5629e8a270f9119eabb12bf495eb53c22" } }] + +[[packages]] +name = "humming-kernels" +version = "0.1.12" +sdist = { url = "https://files.pythonhosted.org/packages/93/b9/53797fff4b1b31b4567453a365646d724469b1bb0d76c07f8746617d0cb6/humming_kernels-0.1.12.tar.gz", upload-time = 2026-07-31T14:28:23Z, size = 259323, hashes = { sha256 = "c96c37c95f74379067d2d2d0c5154d12ee9a8cfa29a7c3370a7f3e34f207ca72" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ec/a2/f96912ee7d68f56e61c15555657ffa057b8afbaa21241c63342b5969bb74/humming_kernels-0.1.12-py3-none-manylinux_2_28_x86_64.whl", upload-time = 2026-07-31T14:28:21Z, size = 322656, hashes = { sha256 = "cd3ef712a93f3a9075ea99de2c72bcd3ec89dab3759b3a248d869f5507b60331" } }] + +[[packages]] +name = "idna" +version = "3.17" +sdist = { url = "https://files.pythonhosted.org/packages/b9/28/99c51f664567218d824af024c0251650fb27e4ca066df188dab0769c5b91/idna-3.17.tar.gz", upload-time = 2026-05-28T14:32:38Z, size = 196048, hashes = { sha256 = "5eb0cb53bc467c12eadcf6de83163ad8527cec9416f44b9b61b19caedad2b87f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/de/a7/f76514cc40ad6234098ecdebda08732d75964776c51a42845b7da10649e2/idna-3.17-py3-none-any.whl", upload-time = 2026-05-28T14:32:37Z, size = 65316, hashes = { sha256 = "466e48829084efe2548012b855df21540b96f2e20e51bd124c851536556a592c" } }] + +[[packages]] +name = "importlib-metadata" +version = "8.5.0" +sdist = { url = "https://files.pythonhosted.org/packages/cd/12/33e59336dca5be0c398a7482335911a33aa0e20776128f038019f1a95f1b/importlib_metadata-8.5.0.tar.gz", upload-time = 2024-09-11T14:56:08Z, size = 55304, hashes = { sha256 = "71522656f0abace1d072b9e5481a48f07c138e00f079c38c8f883823f9c26bd7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a0/d9/a1e041c5e7caa9a05c925f4bdbdfb7f006d1f74996af53467bc394c97be7/importlib_metadata-8.5.0-py3-none-any.whl", upload-time = 2024-09-11T14:56:07Z, size = 26514, hashes = { sha256 = "45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b" } }] + +[[packages]] +name = "interegular" +version = "0.3.3" +sdist = { url = "https://files.pythonhosted.org/packages/dc/9d/8b6dde58a028a3962ce17e84d5fe73758df61378e00ef8ac3d85da34b0ff/interegular-0.3.3.tar.gz", upload-time = 2024-01-06T23:01:22Z, size = 24705, hashes = { sha256 = "d9b697b21b34884711399ba0f0376914b81899ce670032486d0d048344a76600" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c4/01/72d6472f80651673716d1deda2a5bbb633e563ecf94f4479da5519d69d25/interegular-0.3.3-py37-none-any.whl", upload-time = 2024-01-06T23:01:20Z, size = 23635, hashes = { sha256 = "b0c07007d48c89d6d19f7204972d369b2a77222722e126b6aa63aa721dc3b19c" } }] + +[[packages]] +name = "ipython" +version = "9.13.0" +sdist = { url = "https://files.pythonhosted.org/packages/cd/c4/87cda5842cf5c31837c06ddb588e11c3c35d8ece89b7a0108c06b8c9b00a/ipython-9.13.0.tar.gz", upload-time = 2026-04-24T12:24:55Z, size = 4430549, hashes = { sha256 = "7e834b6afc99f020e3f05966ced34792f40267d64cb1ea9043886dab0dde5967" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b9/86/3060e8029b7cc505cce9a0137431dda81d0a3fde93a8f0f50ee0bf37a795/ipython-9.13.0-py3-none-any.whl", upload-time = 2026-04-24T12:24:53Z, size = 627274, hashes = { sha256 = "57f9d4639e20818d328d287c7b549af3d05f12486ea8f2e7f73e52a36ec4d201" } }] + +[[packages]] +name = "ipython-pygments-lexers" +version = "1.1.1" +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", upload-time = 2025-01-17T11:24:34Z, size = 8393, hashes = { sha256 = "09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", upload-time = 2025-01-17T11:24:33Z, size = 8074, hashes = { sha256 = "a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c" } }] + +[[packages]] +name = "jedi" +version = "0.19.2" +sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", upload-time = 2024-11-11T01:41:42Z, size = 1231287, hashes = { sha256 = "4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", upload-time = 2024-11-11T01:41:40Z, size = 1572278, hashes = { sha256 = "a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9" } }] + +[[packages]] +name = "jinja2" +version = "3.1.6" +wheels = [{ url = "https://download.pytorch.org/whl/jinja2-3.1.6-py3-none-any.whl", upload-time = 2025-10-14T18:38:59Z, hashes = { sha256 = "85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67" } }] + +[[packages]] +name = "jiter" +version = "0.13.0" +sdist = { url = "https://files.pythonhosted.org/packages/0d/5e/4ec91646aee381d01cdb9974e30882c9cd3b8c5d1079d6b5ff4af522439a/jiter-0.13.0.tar.gz", upload-time = 2026-02-02T12:37:56Z, size = 164847, hashes = { sha256 = "f2839f9c2c7e2dffc1bc5929a510e14ce0a946be9365fd1219e7ef342dae14f4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f8/4c/09b93e30e984a187bc8aaa3510e1ec8dcbdcd71ca05d2f56aac0492453aa/jiter-0.13.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-02-02T12:36:06Z, size = 360735, hashes = { sha256 = "bdaba7d87e66f26a2c45d8cbadcbfc4bf7884182317907baf39cfe9775bb4d93" } }] + +[[packages]] +name = "jsonschema" +version = "4.23.0" +sdist = { url = "https://files.pythonhosted.org/packages/38/2e/03362ee4034a4c917f697890ccd4aec0800ccf9ded7f511971c75451deec/jsonschema-4.23.0.tar.gz", upload-time = 2024-07-08T18:40:05Z, size = 325778, hashes = { sha256 = "d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/69/4a/4f9dbeb84e8850557c02365a0eee0649abe5eb1d84af92a25731c6c0f922/jsonschema-4.23.0-py3-none-any.whl", upload-time = 2024-07-08T18:40:00Z, size = 88462, hashes = { sha256 = "fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566" } }] + +[[packages]] +name = "jsonschema-specifications" +version = "2025.9.1" +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", upload-time = 2025-09-08T01:34:59Z, size = 32855, hashes = { sha256 = "b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", upload-time = 2025-09-08T01:34:57Z, size = 18437, hashes = { sha256 = "98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe" } }] + +[[packages]] +name = "kernels" +version = "0.14.1" +sdist = { url = "https://files.pythonhosted.org/packages/cd/16/d9c473289d72d07a5c8e00367e5de9326bf0135e65ba74a235e2eb2510f2/kernels-0.14.1.tar.gz", upload-time = 2026-05-14T06:42:36Z, size = 62800, hashes = { sha256 = "ba21b7b509b7a0c2d2c7a0efd546e9dda2b1022ed5ff2b8fde8e94d7637754d3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/94/94/fb8cbf1427af4b520ad08a458b6696f1958732761bc284b55273fa3aa684/kernels-0.14.1-py3-none-any.whl", upload-time = 2026-05-14T06:42:35Z, size = 57977, hashes = { sha256 = "be1a91116e14be1e012fc8f47afb51173ee052586a570fba3d594ef0d1b38920" } }] + +[[packages]] +name = "kernels-data" +version = "0.16.2" +sdist = { url = "https://files.pythonhosted.org/packages/bc/31/b09b168a30a31de97b824661e02cc89d295ffd85fe50635c0192a4f189d8/kernels_data-0.16.2.tar.gz", upload-time = 2026-09-15T09:00:39Z, size = 49746, hashes = { sha256 = "c45c88b8c49b8d8130615b5ea78b51621b5c5c94ea47c902d6002750abe6108a" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d4/07/f0ffdefaaa46df69b7ec2710c65ad8cd03200f0898e188cb9c96d1acfee9/kernels_data-0.16.2-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-09-15T09:00:20Z, size = 1284019, hashes = { sha256 = "9526362517c7b128f7baec080301890875cc3f5284a0f125b082c19737e5c1d5" } }] + +[[packages]] +name = "lark" +version = "1.3.1" +sdist = { url = "https://files.pythonhosted.org/packages/da/34/28fff3ab31ccff1fd4f6c7c7b0ceb2b6968d8ea4950663eadcb5720591a0/lark-1.3.1.tar.gz", upload-time = 2025-10-27T18:25:56Z, size = 382732, hashes = { sha256 = "b426a7a6d6d53189d318f2b6236ab5d6429eaf09259f1ca33eb716eed10d2905" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl", upload-time = 2025-10-27T18:25:54Z, size = 113151, hashes = { sha256 = "c629b661023a014c37da873b4ff58a817398d12635d3bbb2c5a03be7fe5d1e12" } }] + +[[packages]] +name = "llguidance" +version = "1.9.1" +sdist = { url = "https://files.pythonhosted.org/packages/1e/2e/3b0e13c1e01d5598708a6e7b77c55f3ae9c6c4e242a50a239f03ee800630/llguidance-1.9.1.tar.gz", upload-time = 2026-09-30T19:13:37Z, size = 1196000, hashes = { sha256 = "3ba1b37585d07f50bb73e06dca6d45c88c9d5801789c071c8ff784c9dbcc5c46" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/46/c3/b50a05a16af0a84f5a9a6fb4707006d3fc377d1b446599d23ac78f3e144c/llguidance-1.9.1-cp39-abi3-manylinux_2_31_x86_64.whl", upload-time = 2026-09-30T19:13:27Z, size = 3071973, hashes = { sha256 = "dfac6021d9c4c5ef16b3a1d336c05ca5e8208ff30dec29d1c63ebcafbee3a346" } }] + +[[packages]] +name = "llvmlite" +version = "0.47.0" +sdist = { url = "https://files.pythonhosted.org/packages/01/88/a8952b6d5c21e74cbf158515b779666f692846502623e9e3c39d8e8ba25f/llvmlite-0.47.0.tar.gz", upload-time = 2026-03-31T18:29:53Z, size = 193614, hashes = { sha256 = "62031ce968ec74e95092184d4b0e857e444f8fdff0b8f9213707699570c33ccc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e6/4b/e3f2cd17822cf772a4a51a0a8080b0032e6d37b2dbe8cfb724eac4e31c52/llvmlite-0.47.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-03-31T18:28:48Z, size = 56275178, hashes = { sha256 = "5853bf26160857c0c2573415ff4efe01c4c651e59e2c55c2a088740acfee51cd" } }] + +[[packages]] +name = "loguru" +version = "0.7.3" +sdist = { url = "https://files.pythonhosted.org/packages/3a/05/a1dae3dffd1116099471c643b8924f5aa6524411dc6c63fdae648c4f1aca/loguru-0.7.3.tar.gz", upload-time = 2024-12-06T11:20:56Z, size = 63559, hashes = { sha256 = "19480589e77d47b8d85b2c827ad95d49bf31b0dcde16593892eb51dd18706eb6" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl", upload-time = 2024-12-06T11:20:54Z, size = 61595, hashes = { sha256 = "31a33c10c8e1e10422bfd431aeb5d351c7cf7fa671e3c4df004162264b28220c" } }] + +[[packages]] +name = "lxml" +version = "6.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/28/30/9abc9e34c657c33834eaf6cd02124c61bdf5944d802aa48e69be8da3585d/lxml-6.1.0.tar.gz", upload-time = 2026-04-18T04:32:51Z, size = 4197006, hashes = { sha256 = "bfd57d8008c4965709a919c3e9a98f76c2c7cb319086b3d26858250620023b13" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/7c/e08a970727d556caa040a44773c7b7e3ad0f0d73dedc863543e9a8b931f2/lxml-6.1.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-04-18T04:32:58Z, size = 5093820, hashes = { sha256 = "9147d8e386ec3b82c3b15d88927f734f565b0aaadef7def562b853adca45784a" } }, + { url = "https://files.pythonhosted.org/packages/31/ba/3c13d3fc24b7cacf675f808a3a1baabf43a30d0cd24c98f94548e9aa58eb/lxml-6.1.0-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-18T04:33:06Z, size = 5240445, hashes = { sha256 = "bc783ee3147e60a25aa0445ea82b3e8aabb83b240f2b95d32cb75587ff781814" } }, +] + +[[packages]] +name = "markdown-it-py" +version = "4.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", upload-time = 2025-08-11T12:57:52Z, size = 73070, hashes = { sha256 = "cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", upload-time = 2025-08-11T12:57:51Z, size = 87321, hashes = { sha256 = "87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147" } }] + +[[packages]] +name = "markupsafe" +version = "3.0.3" +wheels = [{ url = "https://download.pytorch.org/whl/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-27T13:54:35Z, hashes = { sha256 = "d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d" } }] + +[[packages]] +name = "matplotlib-inline" +version = "0.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/c7/74/97e72a36efd4ae2bccb3463284300f8953f199b5ffbc04cbbb0ec78f74b1/matplotlib_inline-0.2.1.tar.gz", upload-time = 2025-10-23T09:00:22Z, size = 8110, hashes = { sha256 = "e1ee949c340d771fc39e241ea75683deb94762c8fa5f2927ec57c83c4dffa9fe" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/af/33/ee4519fa02ed11a94aef9559552f3b17bb863f2ecfe1a35dc7f548cde231/matplotlib_inline-0.2.1-py3-none-any.whl", upload-time = 2025-10-23T09:00:20Z, size = 9516, hashes = { sha256 = "d56ce5156ba6085e00a9d54fead6ed29a9c47e215cd1bba2e976ef39f5710a76" } }] + +[[packages]] +name = "mdurl" +version = "0.1.2" +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", upload-time = 2022-08-14T12:40:10Z, size = 8729, hashes = { sha256 = "bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", upload-time = 2022-08-14T12:40:09Z, size = 9979, hashes = { sha256 = "84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8" } }] + +[[packages]] +name = "mistral-common" +version = "1.12.0" +sdist = { url = "https://files.pythonhosted.org/packages/45/ee/e7860b0c9919a74fe43664f0bf19508df15243a27825aebc500b6c516d3b/mistral_common-1.12.0.tar.gz", upload-time = 2026-09-22T15:17:56Z, size = 6416138, hashes = { sha256 = "d0f150926733cf422d4750ca19b47568df1f714557c9054a432b866f1f30bf52" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c0/78/2881bae14f5d79c6d4626439e74f1bc1591d0f10a9eb7eea5a408ecdb877/mistral_common-1.12.0-py3-none-any.whl", upload-time = 2026-09-22T15:17:53Z, size = 6580267, hashes = { sha256 = "fa4504b66c30c0201ae4578c0340c5ee2abd22151c271532f62e373b985a53cf" } }] + +[[packages]] +name = "ml-dtypes" +version = "0.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/12/72/307d7c4bd0600601c7133fba5cb78af7db968152951c1cd473abb1cda782/ml_dtypes-0.6.0.tar.gz", upload-time = 2026-08-13T14:14:40Z, size = 3032327, hashes = { sha256 = "5e60251d32ced5598972e4d5e06a2f044341f9291402551a3f6f0ec44f9299b0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c7/f9/7d76c1eae866f5d4636401b31b6d6dd90e4b4ced1fa7cfdfcca9c60e4bd3/ml_dtypes-0.6.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-08-13T14:14:04Z, size = 409890, hashes = { sha256 = "3b4a480aa8fd54a1805b8ac10f3f91763926a74f73c0c364c10f9231854f4170" } }] + +[[packages]] +name = "modelscope" +version = "1.40.2" +sdist = { url = "https://files.pythonhosted.org/packages/d7/af/f92c9824db46757dd1b0b5cbf3778daf54e7e44f0e1e6934d0b1bedfb286/modelscope-1.40.2.tar.gz", upload-time = 2026-10-09T09:09:10Z, size = 4566951, hashes = { sha256 = "7a642cef8c144c28c4ddcc37db5fd803f5481f0d78a7f26c2b9e0e2a225b528c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b9/8a/e85b79ee1c541f7bbf208fd7a6185c9b11e50c192b1071b0750db26b09e9/modelscope-1.40.2-py3-none-any.whl", upload-time = 2026-10-09T09:09:07Z, size = 6062299, hashes = { sha256 = "ea03e0ec4a73398a488d3d240cda4f0c5b62390377a134756d4074a3036cb909" } }] + +[[packages]] +name = "modelscope-hub" +version = "0.4.6" +sdist = { url = "https://files.pythonhosted.org/packages/08/d9/ac46c39b957ff44b55c550c641ad5c625ffe3eb5c0b6f20a849b591e9d14/modelscope_hub-0.4.6.tar.gz", upload-time = 2026-10-09T08:08:21Z, size = 298574, hashes = { sha256 = "c54de09be2ccb27b9214f7c3ebe5751121f335f5016643f789589d0547e78c52" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/4d/74/8872ae511d8a336ca918a8d0234cfbccfff0e2304de672882b2768ff628f/modelscope_hub-0.4.6-py3-none-any.whl", upload-time = 2026-10-09T08:08:19Z, size = 237177, hashes = { sha256 = "361bcec229bfbed645a9291ec5b167d76cd94b795207dc2eceba628108f4023a" } }] + +[[packages]] +name = "mpmath" +version = "1.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", upload-time = 2023-03-07T16:47:11Z, size = 508106, hashes = { sha256 = "7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", upload-time = 2023-03-07T16:47:09Z, size = 536198, hashes = { sha256 = "a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c" } }] + +[[packages]] +name = "msgspec" +version = "0.21.1" +sdist = { url = "https://files.pythonhosted.org/packages/e3/60/f79b9b013a16fa3a58350c9295ddc6789f2e335f36ea61ed10a21b215364/msgspec-0.21.1.tar.gz", upload-time = 2026-04-12T21:44:50Z, size = 319193, hashes = { sha256 = "2313508e394b0d208f8f56892ca9b2799e2561329de9763b19619595a6c0f72c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b5/d1/d4cd9fe89c7d400d7a18f86ccc94daa3f0927f53558846fcb60791dce5d6/msgspec-0.21.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-12T21:44:11Z, size = 225025, hashes = { sha256 = "21995e74b5c598c2e004110ad66ec7f1b8c20bf2bcf3b2de8fd9a3094422d3ff" } }] + +[[packages]] +name = "multidict" +version = "6.7.1" +sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", upload-time = 2026-01-26T02:46:45Z, size = 102010, hashes = { sha256 = "ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-01-26T02:44:03Z, size = 256322, hashes = { sha256 = "bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961" } }, + { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", upload-time = 2026-01-26T02:46:44Z, size = 12319, hashes = { sha256 = "55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56" } }, +] + +[[packages]] +name = "multiprocess" +version = "0.70.16" +sdist = { url = "https://files.pythonhosted.org/packages/b5/ae/04f39c5d0d0def03247c2893d6f2b83c136bf3320a2154d7b8858f2ba72d/multiprocess-0.70.16.tar.gz", upload-time = 2024-01-28T18:52:34Z, size = 1772603, hashes = { sha256 = "161af703d4652a0e1410be6abccecde4a7ddffd19341be0a7011b94aeb171ac1" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bc/f7/7ec7fddc92e50714ea3745631f79bd9c96424cb2702632521028e57d3a36/multiprocess-0.70.16-py310-none-any.whl", upload-time = 2024-01-28T18:52:26Z, size = 134824, hashes = { sha256 = "c4a9944c67bd49f823687463660a2d6daae94c289adff97e0f9d696ba6371d02" } }, + { url = "https://files.pythonhosted.org/packages/50/15/b56e50e8debaf439f44befec5b2af11db85f6e0f344c3113ae0be0593a91/multiprocess-0.70.16-py311-none-any.whl", upload-time = 2024-01-28T18:52:28Z, size = 143519, hashes = { sha256 = "af4cabb0dac72abfb1e794fa7855c325fd2b55a10a44628a3c1ad3311c04127a" } }, + { url = "https://files.pythonhosted.org/packages/0a/7d/a988f258104dcd2ccf1ed40fdc97e26c4ac351eeaf81d76e266c52d84e2f/multiprocess-0.70.16-py312-none-any.whl", upload-time = 2024-01-28T18:52:29Z, size = 146741, hashes = { sha256 = "fc0544c531920dde3b00c29863377f87e1632601092ea2daca74e4beb40faa2e" } }, + { url = "https://files.pythonhosted.org/packages/ea/89/38df130f2c799090c978b366cfdf5b96d08de5b29a4a293df7f7429fa50b/multiprocess-0.70.16-py38-none-any.whl", upload-time = 2024-01-28T18:52:30Z, size = 132628, hashes = { sha256 = "a71d82033454891091a226dfc319d0cfa8019a4e888ef9ca910372a446de4435" } }, + { url = "https://files.pythonhosted.org/packages/da/d9/f7f9379981e39b8c2511c9e0326d212accacb82f12fbfdc1aa2ce2a7b2b6/multiprocess-0.70.16-py39-none-any.whl", upload-time = 2024-01-28T18:52:31Z, size = 133351, hashes = { sha256 = "a0bafd3ae1b732eac64be2e72038231c1ba97724b60b09400d68f229fcc2fbf3" } }, +] + +[[packages]] +name = "nccl4py" +version = "0.6.0" +wheels = [{ url = "https://files.pythonhosted.org/packages/bf/c5/bd7d2f1251215881233580f402606e5a480b60f469f7dbea01d30fb99066/nccl4py-0.6.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-09-23T17:14:37Z, size = 3695883, hashes = { sha256 = "f4006cf8c12c26ed29811b80858a58f8f31e4b42ea85b6c1d23401981449ab9d" } }] + +[[packages]] +name = "nest-asyncio" +version = "1.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", upload-time = 2024-01-21T14:25:19Z, size = 7418, hashes = { sha256 = "6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", upload-time = 2024-01-21T14:25:17Z, size = 5195, hashes = { sha256 = "87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c" } }] + +[[packages]] +name = "networkx" +version = "3.6.1" +sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", upload-time = 2025-12-08T17:02:39Z, size = 2517025, hashes = { sha256 = "26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", upload-time = 2025-12-08T17:02:38Z, size = 2068504, hashes = { sha256 = "d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762" } }] + +[[packages]] +name = "ninja" +version = "1.13.2" +sdist = { url = "https://files.pythonhosted.org/packages/ac/92/410b7917d16ab54c04b05cc32b9284803671d91cf79d33be6009c28d4ea8/ninja-1.13.2.tar.gz", upload-time = 2026-08-30T15:49:51Z, size = 243739, hashes = { sha256 = "525bfa3fc88aa30a4467df270fd5be6f9fcae8061d54d4df74ea1dc5abd5a975" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/6e/53/ebfed7b689c338dd8ebeec9c0730c8d56821292f14e2536e5f3ef1a05744/ninja-1.13.2-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-08-30T15:49:34Z, size = 183365, hashes = { sha256 = "65a24341b5ac09fcadcc37082660be40a94174e51a937fabf6e2cae26225fa2c" } }] + +[[packages]] +name = "numba" +version = "0.65.1" +sdist = { url = "https://files.pythonhosted.org/packages/f6/c5/db2ac3685833d626c0dcae6bd2330cd68433e1fd248d15f70998160d3ad7/numba-0.65.1.tar.gz", upload-time = 2026-04-24T02:02:56Z, size = 2765600, hashes = { sha256 = "19357146c32fe9ed25059ab915e8465fb13951cf6b0aace3826b76886373ab23" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/69/47/a415af0283e4db0398104c6d1c11c9861a98dc67a7aa442a7769ed5d6196/numba-0.65.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-04-24T02:02:27Z, size = 3802467, hashes = { sha256 = "52bc6f3ceb8fcaff9b2ae26b4c6b1e9fee39db8d355534c0fe4f39a901246b84" } }] + +[[packages]] +name = "numpy" +version = "2.3.5" +sdist = { url = "https://files.pythonhosted.org/packages/76/65/21b3bc86aac7b8f2862db1e808f1ea22b028e30a225a34a5ede9bf8678f2/numpy-2.3.5.tar.gz", upload-time = 2025-11-16T22:52:42Z, size = 20584950, hashes = { sha256 = "784db1dcdab56bf0517743e746dfb0f885fc68d948aba86eeec2cba234bdf1c0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b6/23/2a1b231b8ff672b4c450dac27164a8b2ca7d9b7144f9c02d2396518352eb/numpy-2.3.5-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-11-16T22:50:02Z, size = 16606086, hashes = { sha256 = "0d8163f43acde9a73c2a33605353a4f1bc4798745a8b1d73183b28e5b435ae28" } }] + +[[packages]] +name = "nvidia-cublas" +version = "13.1.1.3" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/3b/cd/154ca20c38269e05eff77c1464e6c1da89f50a6390b565e9d82e06bc11e1/nvidia_cublas-13.1.1.3-py3-none-manylinux_2_27_x86_64.whl", upload-time = 2026-04-08T18:46:58Z, size = 423138758, hashes = { sha256 = "37936a16db8fe4ac1f065c2139360608a543a09275cb1a1af612e08cfa065436" } }] + +[[packages]] +name = "nvidia-cuda-cccl" +version = "13.3.4.3.1" +wheels = [{ url = "https://files.pythonhosted.org/packages/7b/b2/a048b57f2ee4c5ff27a329bd1c4c3fae34c84771ad0ebfea179034c8cf29/nvidia_cuda_cccl-13.3.4.3.1-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-09-16T20:36:58Z, size = 3930678, hashes = { sha256 = "48ba8e44a1162face51306d5bfd67604d9949be5acb9105dbb93734d2df8b3a4" } }] + +[[packages]] +name = "nvidia-cuda-crt" +version = "13.4.92" +wheels = [{ url = "https://files.pythonhosted.org/packages/f0/70/d39914f4e88389484bd6a864eda44a31d3bd072e63338bead1a1d80e1f79/nvidia_cuda_crt-13.4.92-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-09-16T20:37:10Z, size = 160871, hashes = { sha256 = "731ce3de11df8add8306404417a1edaede225dbe27eb233aed37c8de9d4fe720" } }] + +[[packages]] +name = "nvidia-cuda-cupti" +version = "13.0.85" +marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" +wheels = [{ url = "https://files.pythonhosted.org/packages/33/6d/737d164b4837a9bbd202f5ae3078975f0525a55730fe871d8ed4e3b952b0/nvidia_cuda_cupti-13.0.85-py3-none-manylinux_2_25_x86_64.whl", upload-time = 2025-09-04T08:26:51Z, size = 10715597, hashes = { sha256 = "4eb01c08e859bf924d222250d2e8f8b8ff6d3db4721288cf35d14252a4d933c8" } }] + +[[packages]] +name = "nvidia-cuda-nvcc" +version = "13.4.92" +wheels = [{ url = "https://files.pythonhosted.org/packages/5a/8c/19c959c7497421559575a6c574ba40e18981558bb8289ddd8ef043b98c54/nvidia_cuda_nvcc-13.4.92-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-09-16T20:38:23Z, size = 47672022, hashes = { sha256 = "a1f3bfb27299e060b444d5df1f4bcd762501326cf0fd3141ed61756816ab9a0e" } }] + +[[packages]] +name = "nvidia-cuda-nvdisasm" +version = "13.4.92" +wheels = [{ url = "https://files.pythonhosted.org/packages/59/ea/b83b98288fd3d37b16c0da8846987d9c8719e9ff49ab974c1988d9e63f5a/nvidia_cuda_nvdisasm-13.4.92-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-09-16T20:38:39Z, size = 5203296, hashes = { sha256 = "f35a5b6ddb64b6758c22c0b078c5b6ff6d54f7c240cd74bf131ab5bf13b6c3fe" } }] + +[[packages]] +name = "nvidia-cuda-nvrtc" +version = "13.0.88" +wheels = [{ url = "https://files.pythonhosted.org/packages/c3/68/483a78f5e8f31b08fb1bb671559968c0ca3a065ac7acabfc7cee55214fd6/nvidia_cuda_nvrtc-13.0.88-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", upload-time = 2025-09-04T08:28:44Z, size = 90215200, hashes = { sha256 = "ad9b6d2ead2435f11cbb6868809d2adeeee302e9bb94bcf0539c7a40d80e8575" } }] + +[[packages]] +name = "nvidia-cuda-runtime" +version = "13.0.96" +wheels = [{ url = "https://files.pythonhosted.org/packages/2e/24/d1558f3b68b1d26e706813b1d10aa1d785e4698c425af8db8edc3dced472/nvidia_cuda_runtime-13.0.96-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-10-09T08:55:36Z, size = 2243632, hashes = { sha256 = "7f82250d7782aa23b6cfe765ecc7db554bd3c2870c43f3d1821f1d18aebf0548" } }] + +[[packages]] +name = "nvidia-cudnn-cu13" +version = "9.20.0.48" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/6e/5e/edb9c0ae051602c3ccaffe424256463636d639e27d7f302dde9975ef9e7a/nvidia_cudnn_cu13-9.20.0.48-py3-none-manylinux_2_27_x86_64.whl", upload-time = 2026-03-09T19:29:34Z, size = 366173588, hashes = { sha256 = "0c45dd8eeb50b603f07995b1b300c62ffe6a1980482b82b3bcf94a4ca9d49304" } }] + +[[packages]] +name = "nvidia-cudnn-frontend" +version = "1.31.0" +wheels = [{ url = "https://files.pythonhosted.org/packages/cb/24/8ec9de1fd9ea95e1c1cb9e6e2d3a5547aa9c5ece1136d650ffce1bb5d8c5/nvidia_cudnn_frontend-1.31.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-10-08T18:06:15Z, size = 10159344, hashes = { sha256 = "3171f102254136418f24b4470dfa5419f34b03d9d792a4b773cf65c7a37e6bf8" } }] + +[[packages]] +name = "nvidia-cufft" +version = "12.0.0.61" +marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" +wheels = [{ url = "https://files.pythonhosted.org/packages/a8/2f/7b57e29836ea8714f81e9898409196f47d772d5ddedddf1592eadb8ab743/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-09-04T08:31:56Z, size = 214085489, hashes = { sha256 = "6c44f692dce8fd5ffd3e3df134b6cdb9c2f72d99cf40b62c32dde45eea9ddad3" } }] + +[[packages]] +name = "nvidia-cufile" +version = "1.15.1.6" +marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" +wheels = [{ url = "https://files.pythonhosted.org/packages/3f/70/4f193de89a48b71714e74602ee14d04e4019ad36a5a9f20c425776e72cd6/nvidia_cufile-1.15.1.6-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-09-04T08:32:22Z, size = 1223672, hashes = { sha256 = "08a3ecefae5a01c7f5117351c64f17c7c62efa5fffdbe24fc7d298da19cd0b44" } }] + +[[packages]] +name = "nvidia-curand" +version = "10.4.0.35" +marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" +wheels = [{ url = "https://files.pythonhosted.org/packages/a5/9f/be0a41ca4a4917abf5cb9ae0daff1a6060cc5de950aec0396de9f3b52bc5/nvidia_curand-10.4.0.35-py3-none-manylinux_2_27_x86_64.whl", upload-time = 2025-08-04T10:22:03Z, size = 59544258, hashes = { sha256 = "1aee33a5da6e1db083fe2b90082def8915f30f3248d5896bcec36a579d941bfc" } }] + +[[packages]] +name = "nvidia-cusolver" +version = "12.0.4.66" +marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" +wheels = [{ url = "https://files.pythonhosted.org/packages/5f/67/cba3777620cdacb99102da4042883709c41c709f4b6323c10781a9c3aa34/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_x86_64.whl", upload-time = 2025-09-04T08:33:22Z, size = 200941980, hashes = { sha256 = "0a759da5dea5c0ea10fd307de75cdeb59e7ea4fcb8add0924859b944babf1112" } }] + +[[packages]] +name = "nvidia-cusparse" +version = "12.6.3.3" +marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" +wheels = [{ url = "https://files.pythonhosted.org/packages/fa/18/623c77619c31d62efd55302939756966f3ecc8d724a14dab2b75f1508850/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-09-04T08:33:58Z, size = 145942937, hashes = { sha256 = "2b3c89c88d01ee0e477cb7f82ef60a11a4bcd57b6b87c33f789350b59759360b" } }] + +[[packages]] +name = "nvidia-cusparselt-cu13" +version = "0.8.1" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/34/7d/2661f2fb3ac4302f3a246f5fc030213ac60c1fe0bce84f9783dbd831dbb7/nvidia_cusparselt_cu13-0.8.1-py3-none-manylinux2014_x86_64.whl", upload-time = 2025-09-05T18:50:50Z, size = 170148586, hashes = { sha256 = "786ce87568c303fadb5afcc7102d454cd3040d75f6f8626f5db460d1871f4dd0" } }] + +[[packages]] +name = "nvidia-cutlass-dsl" +version = "4.6.2" +wheels = [{ url = "https://files.pythonhosted.org/packages/b2/ec/14e6ecbfed31ec35bbd1bb6965ae61f879370906a8f9c2e851e292704ba4/nvidia_cutlass_dsl-4.6.2-py3-none-any.whl", upload-time = 2026-08-05T14:39:41Z, size = 10460, hashes = { sha256 = "06ac62deb182a852dfb053032cf945bf02b9aa1bf502a18b129d280d7babb26c" } }] + +[[packages]] +name = "nvidia-cutlass-dsl-libs-base" +version = "4.6.2" +wheels = [{ url = "https://files.pythonhosted.org/packages/54/1b/cf4a0837054bb4b9dc36cdd86f9d2e7fead3629e3373aaa7f7ec1e5e1542/nvidia_cutlass_dsl_libs_base-4.6.2-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-08-05T14:12:49Z, size = 2824987, hashes = { sha256 = "24dfaddad6077fd0de14eecaf66a72762f2f5f30ae1872231f5bf8b243ac2eac" } }] + +[[packages]] +name = "nvidia-cutlass-dsl-libs-core" +version = "4.6.2" +wheels = [{ url = "https://files.pythonhosted.org/packages/7c/ef/10c0089234a32f1379e1f213f28f8c7521a9ff0154e3acc58f613d5ef3be/nvidia_cutlass_dsl_libs_core-4.6.2-py3-none-any.whl", upload-time = 2026-08-05T14:09:50Z, size = 772393, hashes = { sha256 = "571d4b46fca1bfbb123d0dc348eaa7fd80af0014ddffc07b849e8195b2364333" } }] + +[[packages]] +name = "nvidia-cutlass-dsl-libs-cu12" +version = "4.6.2" +wheels = [{ url = "https://files.pythonhosted.org/packages/80/6e/70c545a600b52b3f0fbbe01608aefc4e675c924ba886485ad72541f5c88e/nvidia_cutlass_dsl_libs_cu12-4.6.2-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-08-05T14:21:14Z, size = 88454261, hashes = { sha256 = "7f510307369d522da8e7d666557b9b9e7df06b94748bd5dc0198d59dfd0d918a" } }] + +[[packages]] +name = "nvidia-cutlass-dsl-libs-cu13" +version = "4.6.2" +wheels = [{ url = "https://files.pythonhosted.org/packages/ca/05/7874c37d50e112177a64a96dd6c7eaeacb1661ebb864e0fe5cfd9f706767/nvidia_cutlass_dsl_libs_cu13-4.6.2-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-08-05T14:27:58Z, size = 88036030, hashes = { sha256 = "a299a623fad75eb752c1a4e447b924e9049ed396b037509c41a48da82d1f340a" } }] + +[[packages]] +name = "nvidia-mathdx" +version = "25.6.0" +wheels = [{ url = "https://files.pythonhosted.org/packages/20/1a/a418b8c1adc58abd87fd69414c19883af5c1b10514e3dbfcc27cde831b13/nvidia_mathdx-25.6.0-py3-none-any.whl", upload-time = 2025-11-13T18:25:11Z, size = 23013087, hashes = { sha256 = "22e6ad5d0d005f836be5cbd14e836cf2e9ea42c82deb602707246ce8198eaa96" } }] + +[[packages]] +name = "nvidia-ml-py" +version = "13.595.45" +sdist = { url = "https://files.pythonhosted.org/packages/ce/49/c29f6e30d8662d2e94fef17739ea7309cc76aba269922ae999e4cc07f268/nvidia_ml_py-13.595.45.tar.gz", upload-time = 2026-03-19T16:59:44Z, size = 50780, hashes = { sha256 = "c9f34897fe0441ff35bc8f35baf80f830a20b0f4e6ce71e0a325bc0e66acf079" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8a/24/fc256107d23597fa33d319505ce77160fa1a2349c096d01901ffc7cb7fc4/nvidia_ml_py-13.595.45-py3-none-any.whl", upload-time = 2026-03-19T16:59:43Z, size = 51776, hashes = { sha256 = "b65a7977f503d56154b14d683710125ef93594adb63fbf7e559336e3318f1376" } }] + +[[packages]] +name = "nvidia-nccl-cu13" +version = "2.29.7" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/67/f4/58e4e91b6919367c7aafb8e36fce9aad1a3047e536bf7e2fd560927d3a4c/nvidia_nccl_cu13-2.29.7-py3-none-manylinux_2_18_x86_64.whl", upload-time = 2026-03-03T05:36:24Z, size = 205976000, hashes = { sha256 = "edd81538446786ec3b73972543e53bb43bcaf0bfc8ef76cb679fcc390ffe136d" } }] + +[[packages]] +name = "nvidia-nvjitlink" +version = "13.4.92" +marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" +wheels = [{ url = "https://files.pythonhosted.org/packages/1d/6b/eef7a9e32872b8f41e145bf10cddc9af26e153c338852811fe9a9baddf9e/nvidia_nvjitlink-13.4.92-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", upload-time = 2026-09-16T20:45:29Z, size = 42452378, hashes = { sha256 = "e0391f24ed94ec879b84e3da4d4ec320c879aff681f2c7a638462f7199284323" } }] + +[[packages]] +name = "nvidia-nvshmem-cu13" +version = "3.4.5" +wheels = [{ url = "https://files.pythonhosted.org/packages/3c/35/a9bf80a609e74e3b000fef598933235c908fcefcef9026042b8e6dfde2a9/nvidia_nvshmem_cu13-3.4.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-09-06T00:32:41Z, size = 60412546, hashes = { sha256 = "290f0a2ee94c9f3687a02502f3b9299a9f9fe826e6d0287ee18482e78d495b80" } }] + +[[packages]] +name = "nvidia-nvtx" +version = "13.0.85" +marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" +wheels = [{ url = "https://files.pythonhosted.org/packages/c2/f3/d86c845465a2723ad7e1e5c36dcd75ddb82898b3f53be47ebd429fb2fa5d/nvidia_nvtx-13.0.85-py3-none-manylinux1_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2025-09-04T08:29:01Z, size = 148047, hashes = { sha256 = "4936d1d6780fbe68db454f5e72a42ff64d1fd6397df9f363ae786930fd5c1cd4" } }] + +[[packages]] +name = "nvidia-nvvm" +version = "13.4.92" +wheels = [{ url = "https://files.pythonhosted.org/packages/28/c9/6f50b170d6d6d55e5d8c30b773ea024bc4f4e8ce450904cbed12b47907c2/nvidia_nvvm-13.4.92-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", upload-time = 2026-09-16T20:46:17Z, size = 72604627, hashes = { sha256 = "e4c81cb321dd9743bcf871c5e7e8fecd7f05dea607944426e102bdda8d49e137" } }] + +[[packages]] +name = "nvshmem4py-cu13" +version = "0.4.1" +wheels = [{ url = "https://files.pythonhosted.org/packages/29/cb/e7bc2677b32a7935e341bd182e6ada44e0ea7a07984969ee1e57121c19ce/nvshmem4py_cu13-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_34_x86_64.whl", upload-time = 2026-10-15T15:41:49Z, size = 4986488, hashes = { sha256 = "eb7c9118581954fe1a01747bc6fdbca7d6305ce3202a1deec0b3c9474cdac79a" } }] + +[[packages]] +name = "openai" +version = "2.6.1" +sdist = { url = "https://files.pythonhosted.org/packages/c4/44/303deb97be7c1c9b53118b52825cbd1557aeeff510f3a52566b1fa66f6a2/openai-2.6.1.tar.gz", upload-time = 2025-10-24T13:29:52Z, size = 593043, hashes = { sha256 = "27ae704d190615fca0c0fc2b796a38f8b5879645a3a52c9c453b23f97141bb49" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/15/0e/331df43df633e6105ff9cf45e0ce57762bd126a45ac16b25a43f6738d8a2/openai-2.6.1-py3-none-any.whl", upload-time = 2025-10-24T13:29:50Z, size = 1005551, hashes = { sha256 = "904e4b5254a8416746a2f05649594fa41b19d799843cd134dac86167e094edef" } }] + +[[packages]] +name = "openai-harmony" +version = "0.0.4" +sdist = { url = "https://files.pythonhosted.org/packages/92/94/01509d510bebf6606614e51113e5a415ced15b8f34aa98a8bf2539314650/openai_harmony-0.0.4.tar.gz", upload-time = 2025-08-09T01:43:24Z, size = 279848, hashes = { sha256 = "5c67ac6df349236fb7b64f57c3dbb0273efcdca24314daa108f2a482c427106c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1f/ec/dcdcace0ffcf3a532cca910e0c351b62d3a7decf0b091ea8cf856d2a67a6/openai_harmony-0.0.4-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-08-09T01:43:11Z, size = 3049306, hashes = { sha256 = "31e9bcac0902a309e2fc688e52f247eec7fffcd00d17e958b9a83a8fea6519c2" } }] + +[[packages]] +name = "opentelemetry-api" +version = "1.41.1" +sdist = { url = "https://files.pythonhosted.org/packages/fa/fc/b7564cbef36601aef0d6c9bc01f7badb64be8e862c2e1c3c5c3b43b53e4f/opentelemetry_api-1.41.1.tar.gz", upload-time = 2026-04-24T13:15:38Z, size = 71416, hashes = { sha256 = "0ad1814d73b875f84494387dae86ce0b12c68556331ce6ce8fe789197c949621" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/29/59/3e7118ed140f76b0982ba4321bdaed1997a0473f9720de2d10788a577033/opentelemetry_api-1.41.1-py3-none-any.whl", upload-time = 2026-04-24T13:15:15Z, size = 69007, hashes = { sha256 = "a22df900e75c76dc08440710e51f52f1aa6b451b429298896023e60db5b3139f" } }] + +[[packages]] +name = "orjson" +version = "3.11.8" +sdist = { url = "https://files.pythonhosted.org/packages/9d/1b/2024d06792d0779f9dbc51531b61c24f76c75b9f4ce05e6f3377a1814cea/orjson-3.11.8.tar.gz", upload-time = 2026-03-31T16:16:27Z, size = 5603832, hashes = { sha256 = "96163d9cdc5a202703e9ad1b9ae757d5f0ca62f4fa0cc93d1f27b0e180cc404e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/37/87/5ddeb7fc1fbd9004aeccab08426f34c81a5b4c25c7061281862b015fce2b/orjson-3.11.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-03-31T16:15:22Z, size = 133624, hashes = { sha256 = "53a0f57e59a530d18a142f4d4ba6dfc708dc5fdedce45e98ff06b44930a2a48f" } }] + +[[packages]] +name = "outlines" +version = "0.1.11" +sdist = { url = "https://files.pythonhosted.org/packages/ac/d0/d59ae830bf7026425942899e3d48e77b58a713cff946a695e5405808da1b/outlines-0.1.11.tar.gz", upload-time = 2024-12-13T07:24:08Z, size = 2488858, hashes = { sha256 = "0997bd9da1cc050e430bd08995dc7d4bd855918bafa4531e49d3f37110a23aba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/13/b4/99ea4a122bef60e3fd6402d19665aff1f928e0daf8fac3044d0b73f72003/outlines-0.1.11-py3-none-any.whl", upload-time = 2024-12-13T07:24:05Z, size = 87623, hashes = { sha256 = "f5a5f2242ed9802d3aab7a92789bf4008d734c576be9258cc0a297f690124727" } }] + +[[packages]] +name = "outlines-core" +version = "0.1.26" +sdist = { url = "https://files.pythonhosted.org/packages/d3/f3/274d07f4702728b43581235a77e545ec602b25f9b0098b288a0f3052521d/outlines_core-0.1.26.tar.gz", upload-time = 2024-12-12T23:38:50Z, size = 75139, hashes = { sha256 = "481c4301341e77cc8f1832d616784adb4d461b4fec65878e7c0d2cba7163a189" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e2/1d/a36292b6198986bd9c3ff8c24355deb82ed5475403379ee40b5b5473e2e3/outlines_core-0.1.26-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2024-12-12T23:38:34Z, size = 343201, hashes = { sha256 = "e86a1bb46adc5cbf6dfd7a7fe4105e0e2a4c6e041732a053126b41c521a1f223" } }] + +[[packages]] +name = "packaging" +version = "24.2" +sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", upload-time = 2024-11-08T09:47:47Z, size = 163950, hashes = { sha256 = "c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", upload-time = 2024-11-08T09:47:44Z, size = 65451, hashes = { sha256 = "09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759" } }] + +[[packages]] +name = "pandas" +version = "2.3.3" +sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", upload-time = 2025-09-29T23:34:51Z, size = 4495223, hashes = { sha256 = "e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e5/63/cd7d615331b328e287d8233ba9fdf191a9c2d11b6af0c7a59cfcec23de68/pandas-2.3.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-09-29T23:20:14Z, size = 12362693, hashes = { sha256 = "b3d11d2fda7eb164ef27ffc14b4fcab16a80e1ce67e9f57e19ec0afaf715ba89" } }] + +[[packages]] +name = "parso" +version = "0.8.6" +sdist = { url = "https://files.pythonhosted.org/packages/81/76/a1e769043c0c0c9fe391b702539d594731a4362334cdf4dc25d0c09761e7/parso-0.8.6.tar.gz", upload-time = 2026-02-09T15:45:24Z, size = 401621, hashes = { sha256 = "2b9a0332696df97d454fa67b81618fd69c35a7b90327cbe6ba5c92d2c68a7bfd" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b6/61/fae042894f4296ec49e3f193aff5d7c18440da9e48102c3315e1bc4519a7/parso-0.8.6-py2.py3-none-any.whl", upload-time = 2026-02-09T15:45:21Z, size = 106894, hashes = { sha256 = "2c549f800b70a5c4952197248825584cb00f033b29c692671d3bf08bf380baff" } }] + +[[packages]] +name = "partial-json-parser" +version = "0.2.1.1.post7" +sdist = { url = "https://files.pythonhosted.org/packages/6a/6d/eed37d7ebc1e0bcd27b831c0cf1fe94881934316187c4b30d23f29ea0bd4/partial_json_parser-0.2.1.1.post7.tar.gz", upload-time = 2025-11-17T07:27:41Z, size = 10296, hashes = { sha256 = "86590e1ba6bcb6739a2dfc17d2323f028cb5884f4c6ce23db376999132c9a922" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/42/32/658973117bf0fd82a24abbfb94fe73a5e86216e49342985e10acce54775a/partial_json_parser-0.2.1.1.post7-py3-none-any.whl", upload-time = 2025-11-17T07:27:40Z, size = 10877, hashes = { sha256 = "145119e5eabcf80cbb13844a6b50a85c68bf99d376f8ed771e2a3c3b03e653ae" } }] + +[[packages]] +name = "pexpect" +version = "4.9.0" +marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", upload-time = 2023-11-25T09:07:26Z, size = 166450, hashes = { sha256 = "ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", upload-time = 2023-11-25T06:56:14Z, size = 63772, hashes = { sha256 = "7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523" } }] + +[[packages]] +name = "pillow" +version = "12.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/1c/3d/bb7fca845737cf9d7dbde16ed1843984665ff2e0a518f5db43e77ec540b9/pillow-12.3.0.tar.gz", upload-time = 2026-07-01T11:56:38Z, size = 47025035, hashes = { sha256 = "3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/84/21/a35af28dcc61f37ed850a2d64c65c701321dfbf25085e469d5559360cbbf/pillow-12.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-01T11:54:13Z, size = 6940830, hashes = { sha256 = "78cb2c6865a35ab8ff8b75fd122f6033b92a62c82801110e48ddd6c936a45d91" } }] + +[[packages]] +name = "prometheus-client" +version = "0.26.0" +sdist = { url = "https://files.pythonhosted.org/packages/52/73/f1334c29c2af4cd9dba6c7817e61b611bd0215e2eb5565c6064a4de18802/prometheus_client-0.26.0.tar.gz", upload-time = 2026-07-24T19:36:41Z, size = 92910, hashes = { sha256 = "04a91bcf94e2cf74a44a1a874d651a2e853ed354b6e822f3b7487751465d5c2b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/eb/a3/b69efbf4143b5b9859b977770bbbabcc2796b702fa69dc40271e45cd5a56/prometheus_client-0.26.0-py3-none-any.whl", upload-time = 2026-07-24T19:36:40Z, size = 64494, hashes = { sha256 = "fa93d06737aa02bacd05794768508bb97d2fbee28cb3bca04eaae92f0ca953d6" } }] + +[[packages]] +name = "prompt-toolkit" +version = "3.0.52" +sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", upload-time = 2025-08-27T15:24:02Z, size = 434198, hashes = { sha256 = "28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", upload-time = 2025-08-27T15:23:59Z, size = 391431, hashes = { sha256 = "9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955" } }] + +[[packages]] +name = "propcache" +version = "0.4.1" +sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", upload-time = 2025-10-08T19:49:02Z, size = 46442, hashes = { sha256 = "f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/46/4b/3aae6835b8e5f44ea6a68348ad90f78134047b503765087be2f9912140ea/propcache-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-10-08T19:46:54Z, size = 221575, hashes = { sha256 = "15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf" } }, + { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", upload-time = 2025-10-08T19:49:00Z, size = 13305, hashes = { sha256 = "af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237" } }, +] + +[[packages]] +name = "protobuf" +version = "6.33.6" +sdist = { url = "https://files.pythonhosted.org/packages/66/70/e908e9c5e52ef7c3a6c7902c9dfbb34c7e29c25d2f81ade3856445fd5c94/protobuf-6.33.6.tar.gz", upload-time = 2026-03-18T19:05:00Z, size = 444531, hashes = { sha256 = "a6768d25248312c297558af96a9f9c929e8c4cee0659cb07e780731095f38135" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/16/92/d1e32e3e0d894fe00b15ce28ad4944ab692713f2e7f0a99787405e43533a/protobuf-6.33.6-cp39-abi3-manylinux2014_x86_64.whl", upload-time = 2026-03-18T19:04:55Z, size = 323436, hashes = { sha256 = "e9db7e292e0ab79dd108d7f1a94fe31601ce1ee3f7b79e0692043423020b0593" } }, + { url = "https://files.pythonhosted.org/packages/c4/72/02445137af02769918a93807b2b7890047c32bfb9f90371cbc12688819eb/protobuf-6.33.6-py3-none-any.whl", upload-time = 2026-03-18T19:04:59Z, size = 170656, hashes = { sha256 = "77179e006c476e69bf8e8ce866640091ec42e1beb80b213c3900006ecfba6901" } }, +] + +[[packages]] +name = "psutil" +version = "7.2.2" +sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", upload-time = 2026-01-28T18:14:54Z, size = 493740, hashes = { sha256 = "0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-01-28T18:15:25Z, size = 155560, hashes = { sha256 = "076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9" } }] + +[[packages]] +name = "ptyprocess" +version = "0.7.0" +marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", upload-time = 2020-12-28T15:15:30Z, size = 70762, hashes = { sha256 = "5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", upload-time = 2020-12-28T15:15:28Z, size = 13993, hashes = { sha256 = "4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35" } }] + +[[packages]] +name = "pure-eval" +version = "0.2.3" +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", upload-time = 2024-07-21T12:58:21Z, size = 19752, hashes = { sha256 = "5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", upload-time = 2024-07-21T12:58:20Z, size = 11842, hashes = { sha256 = "1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0" } }] + +[[packages]] +name = "py-spy" +version = "0.4.2" +sdist = { url = "https://files.pythonhosted.org/packages/93/d8/5b71371f50cf153b1307e5a11ac8a4ce4d85651dae946bd7e9a064146545/py_spy-0.4.2.tar.gz", upload-time = 2026-04-24T22:08:54Z, size = 286374, hashes = { sha256 = "90e600b27bb6bb40479637baca5a5b4bc2ba3395c93d889e672315d93042c4ae" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f9/34/dd7d3c763a00b7b965e25a5eab0acd1a345dbaf0f45fffe595278873a1c0/py_spy-0.4.2-py2.py3-none-manylinux_2_5_x86_64.manylinux1_x86_64.whl", upload-time = 2026-04-24T22:08:52Z, size = 2936518, hashes = { sha256 = "aeb0323409199c785f730645e9f4bb7a7b9ca2c481f2c331a55642b5d13fa52f" } }] + +[[packages]] +name = "pyarrow" +version = "23.0.1" +sdist = { url = "https://files.pythonhosted.org/packages/88/22/134986a4cc224d593c1afde5494d18ff629393d74cc2eddb176669f234a4/pyarrow-23.0.1.tar.gz", upload-time = 2026-02-16T10:14:12Z, size = 1167336, hashes = { sha256 = "b8c5873e33440b2bc2f4a79d2b47017a89c5a24116c055625e6f2ee50523f019" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2c/a5/da83046273d990f256cb79796a190bbf7ec999269705ddc609403f8c6b06/pyarrow-23.0.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-02-16T10:10:17Z, size = 47586063, hashes = { sha256 = "813d99f31275919c383aab17f0f455a04f5a429c261cc411b1e9a8f5e4aaaa05" } }] + +[[packages]] +name = "pybase64" +version = "1.4.3" +sdist = { url = "https://files.pythonhosted.org/packages/aa/b8/4ed5c7ad5ec15b08d35cc79ace6145d5c1ae426e46435f4987379439dfea/pybase64-1.4.3.tar.gz", upload-time = 2025-12-06T13:27:04Z, size = 137272, hashes = { sha256 = "c2ed274c9e0ba9c8f9c4083cfe265e66dd679126cd9c2027965d807352f3f053" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/62/f7/965b79ff391ad208b50e412b5d3205ccce372a2d27b7218ae86d5295b105/pybase64-1.4.3-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2025-12-06T13:23:20Z, size = 71599, hashes = { sha256 = "bb632edfd132b3eaf90c39c89aa314beec4e946e210099b57d40311f704e11d4" } }] + +[[packages]] +name = "pycountry" +version = "26.2.16" +sdist = { url = "https://files.pythonhosted.org/packages/de/1d/061b9e7a48b85cfd69f33c33d2ef784a531c359399ad764243399673c8f5/pycountry-26.2.16.tar.gz", upload-time = 2026-02-17T03:42:52Z, size = 7711342, hashes = { sha256 = "5b6027d453fcd6060112b951dd010f01f168b51b4bf8a1f1fc8c95c8d94a0801" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9c/42/7703bd45b62fecd44cd7d3495423097e2f7d28bc2e99e7c1af68892ab157/pycountry-26.2.16-py3-none-any.whl", upload-time = 2026-02-17T03:42:49Z, size = 8044600, hashes = { sha256 = "115c4baf7cceaa30f59a4694d79483c9167dbce7a9de4d3d571c5f3ea77c305a" } }] + +[[packages]] +name = "pycparser" +version = "3.0" +marker = "implementation_name != 'PyPy'" +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", upload-time = 2026-01-21T14:26:51Z, size = 103492, hashes = { sha256 = "600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", upload-time = 2026-01-21T14:26:50Z, size = 48172, hashes = { sha256 = "b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992" } }] + +[[packages]] +name = "pycryptodomex" +version = "3.24.1" +sdist = { url = "https://files.pythonhosted.org/packages/f4/e7/50e72301e32acb73a314e663c2014e1ddefc019d5f434ff14ec89861d664/pycryptodomex-3.24.1.tar.gz", upload-time = 2026-10-11T19:26:49Z, size = 4934627, hashes = { sha256 = "09081666ffc599976c0b8b29caf2cf82212c0f05bed233c8f8ed53e4f6e1d356" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/cf/93/a954b7a8746980e31648943e29772aca0311d0d8a407a3adf5788083b693/pycryptodomex-3.24.1-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-10-11T19:26:17Z, size = 2280275, hashes = { sha256 = "9b94a8c647c1f80b4c82c7ac9642dda94a71abbb4efa29ad652c410ad7a39879" } }] + +[[packages]] +name = "pydantic" +version = "2.12.5" +sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", upload-time = 2025-11-26T15:11:46Z, size = 821591, hashes = { sha256 = "4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", upload-time = 2025-11-26T15:11:44Z, size = 463580, hashes = { sha256 = "e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d" } }] + +[[packages]] +name = "pydantic-core" +version = "2.41.5" +sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", upload-time = 2025-11-04T13:43:49Z, size = 460952, hashes = { sha256 = "08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-04T13:40:09Z, size = 2075366, hashes = { sha256 = "eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c" } }] + +[[packages]] +name = "pydantic-extra-types" +version = "2.11.1" +sdist = { url = "https://files.pythonhosted.org/packages/66/71/dba38ee2651f84f7842206adbd2233d8bbdb59fb85e9fa14232486a8c471/pydantic_extra_types-2.11.1.tar.gz", upload-time = 2026-03-16T08:08:03Z, size = 172002, hashes = { sha256 = "46792d2307383859e923d8fcefa82108b1a141f8a9c0198982b3832ab5ef1049" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/17/c1/3226e6d7f5a4f736f38ac11a6fbb262d701889802595cdb0f53a885ac2e0/pydantic_extra_types-2.11.1-py3-none-any.whl", upload-time = 2026-03-16T08:08:02Z, size = 79526, hashes = { sha256 = "1722ea2bddae5628ace25f2aa685b69978ef533123e5638cfbddb999e0100ec1" } }] + +[[packages]] +name = "pygments" +version = "2.20.0" +sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", upload-time = 2026-03-29T13:29:33Z, size = 4955991, hashes = { sha256 = "6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", upload-time = 2026-03-29T13:29:30Z, size = 1231151, hashes = { sha256 = "81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176" } }] + +[[packages]] +name = "pyproject-hooks" +version = "1.2.0" +sdist = { url = "https://files.pythonhosted.org/packages/e7/82/28175b2414effca1cdac8dc99f76d660e7a4fb0ceefa4b4ab8f5f6742925/pyproject_hooks-1.2.0.tar.gz", upload-time = 2024-09-29T09:24:13Z, size = 19228, hashes = { sha256 = "1e859bd5c40fae9448642dd871adf459e5e2084186e8d2c2a79a824c970da1f8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/bd/24/12818598c362d7f300f18e74db45963dbcb85150324092410c8b49405e42/pyproject_hooks-1.2.0-py3-none-any.whl", upload-time = 2024-09-29T09:24:11Z, size = 10216, hashes = { sha256 = "9e5c6bfa8dcc30091c74b0cf803c81fdd29d94f01992a7707bc97babb1141913" } }] + +[[packages]] +name = "python-dateutil" +version = "2.9.0.post0" +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", upload-time = 2024-03-01T18:36:20Z, size = 342432, hashes = { sha256 = "37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", upload-time = 2024-03-01T18:36:18Z, size = 229892, hashes = { sha256 = "a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427" } }] + +[[packages]] +name = "python-multipart" +version = "0.0.32" +sdist = { url = "https://files.pythonhosted.org/packages/5b/42/55c32bb9b12693c092ad250a0e82edb5b31ddeda6eb772de5f308b3804ad/python_multipart-0.0.32.tar.gz", upload-time = 2026-06-04T16:18:58Z, size = 46881, hashes = { sha256 = "be54b7f3fa167bb83e4fcd936b887b708f4e57fe75911c02aebf53efaf8d938e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e1/04/e8135ebd1ad02c56ec633277529b2602ff99ff634be76cdba5744cf554fd/python_multipart-0.0.32-py3-none-any.whl", upload-time = 2026-06-04T16:18:57Z, size = 30042, hashes = { sha256 = "ff6d3f776f16878c894e52e107296ffc890e913c611b1a4ec6c44e2821fe2e23" } }] + +[[packages]] +name = "pytz" +version = "2026.1.post1" +sdist = { url = "https://files.pythonhosted.org/packages/56/db/b8721d71d945e6a8ac63c0fc900b2067181dbb50805958d4d4661cf7d277/pytz-2026.1.post1.tar.gz", upload-time = 2026-03-03T07:47:50Z, size = 321088, hashes = { sha256 = "3378dde6a0c3d26719182142c56e60c7f9af7e968076f31aae569d72a0358ee1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/10/99/781fe0c827be2742bcc775efefccb3b048a3a9c6ce9aec0cbf4a101677e5/pytz-2026.1.post1-py2.py3-none-any.whl", upload-time = 2026-03-03T07:47:49Z, size = 510489, hashes = { sha256 = "f2fd16142fda348286a75e1a524be810bb05d444e5a081f37f7affc635035f7a" } }] + +[[packages]] +name = "pyyaml" +version = "6.0.3" +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", upload-time = 2025-09-25T21:33:16Z, size = 130960, hashes = { sha256 = "d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-09-25T21:32:16Z, size = 807870, hashes = { sha256 = "ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc" } }] + +[[packages]] +name = "pyzmq" +version = "27.2.0" +sdist = { url = "https://files.pythonhosted.org/packages/e7/8d/5b3d5631c2f4b4b8862f64cd0c9eb777b5710eeb5125b4be8dd0a200a4c0/pyzmq-27.2.0.tar.gz", upload-time = 2026-08-20T19:08:21Z, size = 292316, hashes = { sha256 = "54d4259d1bfae24ecdb5ca79f7acc2eac6c286a02d6a0ae617797cb45f0726d3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/62/2c/d5828306f795e8d34676d266823b74e2101e0ad3760d12083de3e02abbb2/pyzmq-27.2.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-08-20T19:06:44Z, size = 872258, hashes = { sha256 = "dea74fd65f1fc5f7fe167916a473ebe6ed6174e5e5d9de11ea6583661be6cf43" } }] + +[[packages]] +name = "quack-kernels" +version = "0.6.4" +sdist = { url = "https://files.pythonhosted.org/packages/75/5c/67c4a0d54cbb8d4d05af73132d620d1900a193b33e0d5ea6a25829b941d2/quack_kernels-0.6.4.tar.gz", upload-time = 2026-08-07T23:25:31Z, size = 845485, hashes = { sha256 = "8bf08a0e1a85aecc892ce84f4b6ed7abb6a44ec7c68b83040abe174bc8c2b936" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/28/f5/36ec7e075e90bd92bdf30fee0606f189348c2bbb0af6aebaf7382927c622/quack_kernels-0.6.4-py3-none-any.whl", upload-time = 2026-08-07T23:25:30Z, size = 728458, hashes = { sha256 = "e77c5d1f1299b0b38487fe8737df6c6975daa16bca7f7eb883bd1a74d09e7e78" } }] + +[[packages]] +name = "referencing" +version = "0.37.0" +sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", upload-time = 2025-10-13T15:30:48Z, size = 78036, hashes = { sha256 = "44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", upload-time = 2025-10-13T15:30:47Z, size = 26766, hashes = { sha256 = "381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231" } }] + +[[packages]] +name = "regex" +version = "2026.4.4" +sdist = { url = "https://files.pythonhosted.org/packages/cb/0e/3a246dbf05666918bd3664d9d787f84a9108f6f43cc953a077e4a7dfdb7e/regex-2026.4.4.tar.gz", upload-time = 2026-04-03T20:56:28Z, size = 416000, hashes = { sha256 = "e08270659717f6973523ce3afbafa53515c4dc5dcad637dc215b6fd50f689423" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/11/0e/a9f6f81013e0deaf559b25711623864970fe6a098314e374ccb1540a4152/regex-2026.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-03T20:53:51Z, size = 801126, hashes = { sha256 = "993f657a7c1c6ec51b5e0ba97c9817d06b84ea5fa8d82e43b9405de0defdc2b9" } }] + +[[packages]] +name = "requests" +version = "2.33.1" +sdist = { url = "https://files.pythonhosted.org/packages/5f/a4/98b9c7c6428a668bf7e42ebb7c79d576a1c3c1e3ae2d47e674b468388871/requests-2.33.1.tar.gz", upload-time = 2026-03-30T16:09:15Z, size = 134120, hashes = { sha256 = "18817f8c57c6263968bc123d237e3b8b08ac046f5456bd1e307ee8f4250d3517" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", upload-time = 2026-03-30T16:09:13Z, size = 64947, hashes = { sha256 = "4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a" } }] + +[[packages]] +name = "rich" +version = "13.9.4" +sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", upload-time = 2024-11-01T16:43:57Z, size = 223149, hashes = { sha256 = "439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", upload-time = 2024-11-01T16:43:55Z, size = 242424, hashes = { sha256 = "6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90" } }] + +[[packages]] +name = "rpds-py" +version = "0.30.0" +sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", upload-time = 2025-11-30T20:24:38Z, size = 69469, hashes = { sha256 = "dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/60/1b/6f8f29f3f995c7ffdde46a626ddccd7c63aefc0efae881dc13b6e5d5bb16/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-30T20:22:27Z, size = 394080, hashes = { sha256 = "47f236970bccb2233267d89173d3ad2703cd36a0e2a6e92d0560d333871a3d23" } }] + +[[packages]] +name = "safetensors" +version = "0.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/29/9c/6e74567782559a63bd040a236edca26fd71bc7ba88de2ef35d75df3bca5e/safetensors-0.7.0.tar.gz", upload-time = 2025-11-19T15:18:43Z, size = 200878, hashes = { sha256 = "07663963b67e8bd9f0b8ad15bb9163606cd27cc5a1b96235a50d8369803b96b0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a0/60/429e9b1cb3fc651937727befe258ea24122d9663e4d5709a48c9cbfceecb/safetensors-0.7.0-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-19T15:18:33Z, size = 507152, hashes = { sha256 = "dac7252938f0696ddea46f5e855dd3138444e82236e3be475f54929f0c510d48" } }] + +[[packages]] +name = "scipy" +version = "1.17.1" +sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", upload-time = 2026-02-23T00:26:24Z, size = 30573822, hashes = { sha256 = "95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/01/8e/1e35281b8ab6d5d72ebe9911edcdffa3f36b04ed9d51dec6dd140396e220/scipy-1.17.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-02-23T00:18:49Z, size = 35235890, hashes = { sha256 = "02ae3b274fde71c5e92ac4d54bc06c42d80e399fec704383dcd99b301df37458" } }] + +[[packages]] +name = "sentencepiece" +version = "0.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/15/15/2e7a025fc62d764b151ae6d0f2a92f8081755ebe8d4a64099accc6f77ba6/sentencepiece-0.2.1.tar.gz", upload-time = 2025-08-12T07:00:51Z, size = 3228515, hashes = { sha256 = "8138cec27c2f2282f4a34d9a016e3374cd40e5c6e9cb335063db66a0a3b71fad" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/04/88/14f2f4a2b922d8b39be45bf63d79e6cd3a9b2f248b2fcb98a69b12af12f5/sentencepiece-0.2.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-08-12T06:59:46Z, size = 1387881, hashes = { sha256 = "0cdfecef430d985f1c2bcbfff3defd1d95dae876fbd0173376012d2d7d24044b" } }] + +[[packages]] +name = "setproctitle" +version = "1.3.8" +sdist = { url = "https://files.pythonhosted.org/packages/49/b0/6b8a516c5a9e9630bd5293db78314ac012f690305fe93beadea388626efb/setproctitle-1.3.8.tar.gz", upload-time = 2026-10-01T21:09:27Z, size = 27214, hashes = { sha256 = "cafe209d064a6efb88cb45a03e97981ff8832802b2b5d009dde0197a3b7b41c8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/cb/21/4df9fbc0c72b9bca39b5d53eff6813dc1738a1562983e0c614054e9dbb8d/setproctitle-1.3.8-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2026-10-01T20:59:09Z, size = 32929, hashes = { sha256 = "4a765e0c80a2453480be27c4fc22ba1c0771867040c5f91e4221940d78a4abfb" } }] + +[[packages]] +name = "setuptools" +version = "83.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/34/26/f5d29e25ffdb535afef2d35cdb55b325298f96debd670da4c325e08d70f4/setuptools-83.0.0.tar.gz", upload-time = 2026-07-04T15:31:22Z, size = 1154254, hashes = { sha256 = "025bccbbf0fa05b6192bc64ae1e7b16e001fd6d6d4d5de03c97b1c1ade523bef" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5d/40/e1e72872c6354b306daef1703549e8e83b4d43cfea356311bf722a043752/setuptools-83.0.0-py3-none-any.whl", upload-time = 2026-07-04T15:31:20Z, size = 1008090, hashes = { sha256 = "29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3" } }] + +[[packages]] +name = "sgl-deep-ep" +version = "0.1.2" +wheels = [{ url = "https://files.pythonhosted.org/packages/e5/4d/eff6ebd61e34c4e617f1373a4ebc35a25b884cf54a4879664dfd6327c87d/sgl_deep_ep-0.1.2-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-08-19T23:29:21Z, size = 15331145, hashes = { sha256 = "63c90e60b5cbb63dac10ab62b432306c37ce2f7777ffb3f05bee765210a31c80" } }] + +[[packages]] +name = "sgl-deep-gemm" +version = "0.2.0" +wheels = [{ url = "https://files.pythonhosted.org/packages/d3/7e/f334fc133f1a710841b0d6ddf8d29148c6b367f32b270f8664529e622559/sgl_deep_gemm-0.2.0-py3-none-manylinux2014_x86_64.whl", upload-time = 2026-09-14T06:16:37Z, size = 5419649, hashes = { sha256 = "f208c333fca6686b482abc1e2dbb1960cd73be92f632829dc46fd6f7e9b9fb4d" } }] + +[[packages]] +name = "sglang" +version = "0.5.20" +wheels = [{ url = "https://files.pythonhosted.org/packages/34/33/a253bf07c3973f2ad0f9fec4f30f8aadf9242705dfa3e9f36f0fe9dd0b60/sglang-0.5.20-cp312-cp312-manylinux_2_34_x86_64.whl", upload-time = 2026-09-18T09:54:55Z, size = 27393093, hashes = { sha256 = "ffaced7e91c3536c63077b16b08210b5c1a2f362418e9841a8767d5e019cf08a" } }] + +[[packages]] +name = "sglang-kernel" +version = "0.4.7" +wheels = [{ url = "https://files.pythonhosted.org/packages/63/db/45fcc5dc66de8e8f2e63c908b30bc309f20086d6b063a1aaa813c6dc478f/sglang_kernel-0.4.7-cp310-abi3-manylinux2014_x86_64.whl", upload-time = 2026-09-13T22:54:51Z, size = 373107099, hashes = { sha256 = "666f39de214a1558c5a98f43e6562e1032d8d08823b61f6a307830882f3241ce" } }] + +[[packages]] +name = "shellingham" +version = "1.5.4" +sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", upload-time = 2023-10-24T04:13:40Z, size = 10310, hashes = { sha256 = "8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", upload-time = 2023-10-24T04:13:38Z, size = 9755, hashes = { sha256 = "7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686" } }] + +[[packages]] +name = "six" +version = "1.17.0" +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", upload-time = 2024-12-04T17:35:28Z, size = 34031, hashes = { sha256 = "ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", upload-time = 2024-12-04T17:35:26Z, size = 11050, hashes = { sha256 = "4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274" } }] + +[[packages]] +name = "smg-grpc-proto" +version = "0.4.27" +sdist = { url = "https://files.pythonhosted.org/packages/cb/77/26920fe4654f11067e5b970433657b4dc96546e7b702f3394580ce760e02/smg_grpc_proto-0.4.27.tar.gz", upload-time = 2026-10-15T18:57:59Z, size = 35614, hashes = { sha256 = "f90f082ff4274a6baf32b6c185dcfe9623615cc3f3226af157a7dd93f2d140e0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/94/82/760c84998c37fc7bae8805f596cafc1117553c6b6af87863cc85d80dbc23/smg_grpc_proto-0.4.27-py3-none-any.whl", upload-time = 2026-10-15T18:57:58Z, size = 109659, hashes = { sha256 = "58dbd801d0d2745f8bc18ccdd73499e6d43f27a91bf84d7b18f99bfc9e59db14" } }] + +[[packages]] +name = "smg-grpc-servicer" +version = "0.14.0" +sdist = { url = "https://files.pythonhosted.org/packages/e0/5a/5781860ffd563c6e3c89fe18489ad25b70e36ddd26fe99877a8f2ad0a039/smg_grpc_servicer-0.14.0.tar.gz", upload-time = 2026-10-15T18:58:36Z, size = 481847, hashes = { sha256 = "7cf8718683d3e90627311ff4d507a6783cb159d1f98d9baac574f904a8872b94" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/94/34/c632a5cb8984279f26a3ebbfeeedc2177e09b6739daa3422739f27c81ab0/smg_grpc_servicer-0.14.0-py3-none-any.whl", upload-time = 2026-10-15T18:58:34Z, size = 304074, hashes = { sha256 = "93e83f4bfffa16c3953ce2b431600ed3395c25d8f711932e21df870524ae4c83" } }] + +[[packages]] +name = "sniffio" +version = "1.3.1" +sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", upload-time = 2024-02-25T23:20:04Z, size = 20372, hashes = { sha256 = "f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", upload-time = 2024-02-25T23:20:01Z, size = 10235, hashes = { sha256 = "2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2" } }] + +[[packages]] +name = "soundfile" +version = "0.13.1" +sdist = { url = "https://files.pythonhosted.org/packages/e1/41/9b873a8c055582859b239be17902a85339bec6a30ad162f98c9b0288a2cc/soundfile-0.13.1.tar.gz", upload-time = 2025-01-25T09:17:04Z, size = 46156, hashes = { sha256 = "b2c68dab1e30297317080a5b43df57e302584c49e2942defdde0acccc53f0e5b" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/28/e2a36573ccbcf3d57c00626a21fe51989380636e821b341d36ccca0c1c3a/soundfile-0.13.1-py2.py3-none-any.whl", upload-time = 2025-01-25T09:16:44Z, size = 25751, hashes = { sha256 = "a23c717560da2cf4c7b5ae1142514e0fd82d6bbd9dfc93a50423447142f2c445" } }, + { url = "https://files.pythonhosted.org/packages/57/5e/70bdd9579b35003a489fc850b5047beeda26328053ebadc1fb60f320f7db/soundfile-0.13.1-py2.py3-none-manylinux_2_28_x86_64.whl", upload-time = 2025-01-25T09:16:54Z, size = 1313646, hashes = { sha256 = "03267c4e493315294834a0870f31dbb3b28a95561b80b134f0bd3cf2d5f0e618" } }, +] + +[[packages]] +name = "stack-data" +version = "0.6.3" +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", upload-time = 2023-09-30T13:58:05Z, size = 44707, hashes = { sha256 = "836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", upload-time = 2023-09-30T13:58:03Z, size = 24521, hashes = { sha256 = "d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695" } }] + +[[packages]] +name = "starlette" +version = "1.3.1" +sdist = { url = "https://files.pythonhosted.org/packages/eb/e3/7c1dc7381d9f8ab7d854328ebfa884e62cb3f3d8549ddfd37c7814f42afa/starlette-1.3.1.tar.gz", upload-time = 2026-06-12T09:23:11Z, size = 2703240, hashes = { sha256 = "05d0213193f2fbaae60e2ecb593b4add4262ad4e46536b54abe36f11a71724e0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ec/bb/2799cc2ede3ed41131f8975621e7213dfc7ef4acbbaadfa440f32500c370/starlette-1.3.1-py3-none-any.whl", upload-time = 2026-06-12T09:23:10Z, size = 73632, hashes = { sha256 = "c7372aae11c3c3f26a42df7bd626cec2f47d03483d261d369516a615a53714c6" } }] + +[[packages]] +name = "sympy" +version = "1.14.0" +sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", upload-time = 2025-04-27T18:05:01Z, size = 7793921, hashes = { sha256 = "d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", upload-time = 2025-04-27T18:04:59Z, size = 6299353, hashes = { sha256 = "e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5" } }] + +[[packages]] +name = "tabulate" +version = "0.10.0" +sdist = { url = "https://files.pythonhosted.org/packages/46/58/8c37dea7bbf769b20d58e7ace7e5edfe65b849442b00ffcdd56be88697c6/tabulate-0.10.0.tar.gz", upload-time = 2026-03-04T18:55:34Z, size = 91754, hashes = { sha256 = "e2cfde8f79420f6deeffdeda9aaec3b6bc5abce947655d17ac662b126e48a60d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/99/55/db07de81b5c630da5cbf5c7df646580ca26dfaefa593667fc6f2fe016d2e/tabulate-0.10.0-py3-none-any.whl", upload-time = 2026-03-04T18:55:31Z, size = 39814, hashes = { sha256 = "f0b0622e567335c8fabaaa659f1b33bcb6ddfe2e496071b743aa113f8774f2d3" } }] + +[[packages]] +name = "tiktoken" +version = "0.12.0" +sdist = { url = "https://files.pythonhosted.org/packages/7d/ab/4d017d0f76ec3171d469d80fc03dfbb4e48a4bcaddaa831b31d526f05edc/tiktoken-0.12.0.tar.gz", upload-time = 2025-10-06T20:22:45Z, size = 37806, hashes = { sha256 = "b18ba7ee2b093863978fcb14f74b3707cdc8d4d4d3836853ce7ec60772139931" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f4/90/3dae6cc5436137ebd38944d396b5849e167896fc2073da643a49f372dc4f/tiktoken-0.12.0-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2025-10-06T20:21:56Z, size = 1152665, hashes = { sha256 = "edde1ec917dfd21c1f2f8046b86348b0f54a2c0547f68149d8600859598769ad" } }] + +[[packages]] +name = "tilelang" +version = "0.1.12" +sdist = { url = "https://files.pythonhosted.org/packages/6d/9a/5776adb5b6e03e141c8cff020e16c45b87c9b7a7a5bdfe83416d6cc23933/tilelang-0.1.12.tar.gz", upload-time = 2026-07-08T04:22:52Z, size = 93565090, hashes = { sha256 = "595b39581d099a53f875bd8d553863e7e4f58998052b58764f5472cbfbb87043" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d1/53/f281a0bd9ee7e03d6a97828fc0e443321ed26ea2b0bd74bf9f1d9451d30f/tilelang-0.1.12-cp38-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-08T04:22:39Z, size = 50501074, hashes = { sha256 = "bbeb5573cbe2544a51a5c9a6cc737c5e3b5c2d95411caa3687fd9b08eb9d5f97" } }] + +[[packages]] +name = "timm" +version = "1.0.16" +sdist = { url = "https://files.pythonhosted.org/packages/94/f6/4d7a8c261341fa6ad281920618739f2a650f41043afcedb570f24e99a776/timm-1.0.16.tar.gz", upload-time = 2025-06-26T17:09:44Z, size = 2339999, hashes = { sha256 = "a3b8130dd2cb8dc3b9f5e3d09ab6d677a6315a8695fd5264eb6d52a4a46c1044" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3b/14/10d0ea58a7580b8bd7c8d69420b3dc3a1deb890d4ff297deca9717689598/timm-1.0.16-py3-none-any.whl", upload-time = 2025-06-26T17:09:42Z, size = 2485733, hashes = { sha256 = "a640e58f4ae41e0445517d1133b34be75bb2bd49cdb830d739925ce1fb7d2526" } }] + +[[packages]] +name = "tokenizers" +version = "0.22.2" +sdist = { url = "https://files.pythonhosted.org/packages/73/6f/f80cfef4a312e1fb34baf7d85c72d4411afde10978d4657f8cdd811d3ccc/tokenizers-0.22.2.tar.gz", upload-time = 2026-01-05T10:45:15Z, size = 372115, hashes = { sha256 = "473b83b915e547aa366d1eee11806deaf419e17be16310ac0a14077f1e28f917" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2e/76/932be4b50ef6ccedf9d3c6639b056a967a86258c6d9200643f01269211ca/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-01-05T10:40:58Z, size = 3274982, hashes = { sha256 = "369cc9fc8cc10cb24143873a0d95438bb8ee257bb80c71989e3ee290e8d72c67" } }] + +[[packages]] +name = "tokenspeed-mla" +version = "0.1.8" +wheels = [{ url = "https://files.pythonhosted.org/packages/27/df/0037ade72b165ac97859040919e006aa3d80cb8cc3a79420fb6c03eb16a0/tokenspeed_mla-0.1.8-py3-none-manylinux_2_28_x86_64.whl", upload-time = 2026-06-24T03:36:29Z, size = 755827, hashes = { sha256 = "6a7526d7327746893f8c20d24aa63ba5b8a123d0dfd6e66388e13b768b6452c6" } }] + +[[packages]] +name = "tokenspeed-triton" +version = "3.9.10.post20261008" +wheels = [{ url = "https://files.pythonhosted.org/packages/1c/79/ffd666bee268dc27ee34ed471e43f0357f9154c93d5180381861f8673c21/tokenspeed_triton-3.9.10.post20261008-cp312-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-10-09T23:23:09Z, size = 93285278, hashes = { sha256 = "5cb864b8a55f3b0b6d95dca81af85abd702496265971d8c44366eb68c8851154" } }] + +[[packages]] +name = "tomlkit" +version = "0.15.2" +sdist = { url = "https://files.pythonhosted.org/packages/08/72/fc01563df95c189a9f65850096bdc205bc2fe37da6c740cd64afaf18d07e/tomlkit-0.15.2.tar.gz", upload-time = 2026-10-16T04:07:08Z, size = 190522, hashes = { sha256 = "83e32755ba1d20d9340bd069ee97e9f6232ba2346b63ffcba425de01f7e327a6" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/da/46/7d84138a60a8bd796825b2d38ebe92d0d16501ca57d501b7c5d677401bbc/tomlkit-0.15.2-py3-none-any.whl", upload-time = 2026-10-16T04:07:09Z, size = 52225, hashes = { sha256 = "05562412163a3037b94497385fb7f9204c637bc605af7a48199e41cf2272f437" } }] + +[[packages]] +name = "torch" +version = "2.13.0+cu130" +wheels = [{ url = "https://download-r2.pytorch.org/whl/cu130/torch-2.13.0%2Bcu130-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-07-08T20:24:52Z, hashes = { sha256 = "8db7338e6895c3d4bd89a02ff4209507d1f0cf2ffeb3b898538b5a07d1ea8c1e" } }] + +[[packages]] +name = "torch-c-dlpack-ext" +version = "0.1.5" +sdist = { url = "https://files.pythonhosted.org/packages/37/de/921b6491efce5c389a5ef9bbed3d2d6660005840dae488124173180859ab/torch_c_dlpack_ext-0.1.5.tar.gz", upload-time = 2026-01-12T11:25:08Z, size = 12913, hashes = { sha256 = "d06f0357d575d22a168cc77acb9020fc4bae30968ceb6718a055dcbe92bacabe" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e2/79/a914539b4785f3e44f891aa012a886edb8bc10fe081c440981c57543ce21/torch_c_dlpack_ext-0.1.5-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-01-12T11:24:48Z, size = 897846, hashes = { sha256 = "e6f9da4bb9af70e27facc777458be62e10dbbbddda7672d16138db0553c5a524" } }] + +[[packages]] +name = "torch-memory-saver" +version = "0.0.10" +sdist = { url = "https://files.pythonhosted.org/packages/82/54/88f020fd9bd55303931ca51ee297a4a156208a6ce868e3f473b4fb13272d/torch_memory_saver-0.0.10.tar.gz", upload-time = 2026-09-12T01:49:33Z, size = 36134, hashes = { sha256 = "480fe8e35e5b8cb5005d816d21e5382a1dc970c47d405dd36d8c5a21844dc427" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/74/f7/110c708c723ffe0425f3df6c890ba9d42bc2cb4fe643256ff6d1fad7f59b/torch_memory_saver-0.0.10-cp39-abi3-manylinux2014_x86_64.whl", upload-time = 2026-09-12T01:49:32Z, size = 2600103, hashes = { sha256 = "786e18755a9af255ae692b0e19a62ff06861dbf55a19fa8545e62a100ab5a28f" } }] + +[[packages]] +name = "torchaudio" +version = "2.11.0+cu130" +wheels = [{ url = "https://download-r2.pytorch.org/whl/cu130/torchaudio-2.11.0%2Bcu130-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-03-23T15:50:26Z, hashes = { sha256 = "3fba988f4301fe13547fe5e99c76d9ae36a27e19ded82eeffed9d2456e12edef" } }] + +[[packages]] +name = "torchcodec" +version = "0.15.0+cu130" +marker = "(platform_machine != 'aarch64' and platform_machine != 'arm64' and platform_machine != 'armv7l') or sys_platform != 'linux'" +wheels = [{ url = "https://download.pytorch.org/whl/cu130/torchcodec-0.15.0%2Bcu130-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-07-15T10:08:12Z, hashes = { sha256 = "54e9c069270f7cbe84123d53b87678acd834a62f14acaa45bf8558cd21669bb0" } }] + +[[packages]] +name = "torchvision" +version = "0.28.0+cu130" +wheels = [{ url = "https://download-r2.pytorch.org/whl/cu130/torchvision-0.28.0%2Bcu130-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-07-08T12:26:52Z, hashes = { sha256 = "8a0008d34ccc4e81066b97ff0ae5a34c676bfdf3464baf40c01b320dc9a45ce0" } }] + +[[packages]] +name = "tqdm" +version = "4.67.3" +sdist = { url = "https://files.pythonhosted.org/packages/09/a9/6ba95a270c6f1fbcd8dac228323f2777d886cb206987444e4bce66338dd4/tqdm-4.67.3.tar.gz", upload-time = 2026-02-03T17:35:53Z, size = 169598, hashes = { sha256 = "7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", upload-time = 2026-02-03T17:35:50Z, size = 78374, hashes = { sha256 = "ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf" } }] + +[[packages]] +name = "traitlets" +version = "5.14.3" +sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", upload-time = 2024-04-19T11:11:49Z, size = 161621, hashes = { sha256 = "9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", upload-time = 2024-04-19T11:11:46Z, size = 85359, hashes = { sha256 = "b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f" } }] + +[[packages]] +name = "transformers" +version = "5.12.1" +sdist = { url = "https://files.pythonhosted.org/packages/aa/7c/8240f612819718100a9346dc28dea6a11370c3ca9c8c6eabadd3dea4ef29/transformers-5.12.1.tar.gz", upload-time = 2026-06-15T17:27:50Z, size = 8924054, hashes = { sha256 = "679ee731c8225347889ad4fb3b2c926a62e9da3b7d284e9d12c791da7272466b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/df/56/bbd60dd8668055803bf8ba55a81f9b8a8b31497f620109a9671d26a2076d/transformers-5.12.1-py3-none-any.whl", upload-time = 2026-06-15T17:27:46Z, size = 11150587, hashes = { sha256 = "2a5e109d2021265df7098ffbb738295acaf5ad256f12cbc586db2ea4dcbb1a8a" } }] + +[[packages]] +name = "triton" +version = "3.7.1" +wheels = [{ url = "https://download-r2.pytorch.org/whl/triton-3.7.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-06-17T16:39:06Z, hashes = { sha256 = "225910e79149807de74a0ca63160aa285956a8d64a2951d558997c57e2584ae1" } }] + +[[packages]] +name = "truststore" +version = "0.10.5" +sdist = { url = "https://files.pythonhosted.org/packages/ee/9f/c5201d42a484c061e528825fc8e2d565f5abd50a4ced6fb7d29c4ec99b2b/truststore-0.10.5.tar.gz", upload-time = 2026-10-12T22:27:31Z, size = 28091, hashes = { sha256 = "30d36967ccaded5cbb38d602c433f53600036c79d502f4533a49b60a03bbefcd" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/51/e9/3a7820be2bb0fe53b6bc9c3be26d3d1158004e4c3ab953aa6840b955b1e9/truststore-0.10.5-py3-none-any.whl", upload-time = 2026-10-12T22:27:30Z, size = 19017, hashes = { sha256 = "9aaaedaefaf06d8b206278cf8b5012bc897f485a874503501e12d776df78951c" } }] + +[[packages]] +name = "typer" +version = "0.21.2" +sdist = { url = "https://files.pythonhosted.org/packages/f2/1e/a27cc02a0cd715118c71fa2aef2c687fdefc3c28d90fd0dd789c5118154c/typer-0.21.2.tar.gz", upload-time = 2026-02-10T19:33:46Z, size = 120426, hashes = { sha256 = "1abd95a3b675e17ff61b0838ac637fe9478d446d62ad17fa4bb81ea57cc54028" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b8/cc/d59f893fbdfb5f58770c05febfc4086a46875f1084453621c35605cec946/typer-0.21.2-py3-none-any.whl", upload-time = 2026-02-10T19:33:48Z, size = 56728, hashes = { sha256 = "c3d8de54d00347ef90b82131ca946274f017cffb46683ae3883c360fa958f55c" } }] + +[[packages]] +name = "typing-extensions" +version = "4.15.0" +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", upload-time = 2025-08-25T13:49:26Z, size = 109391, hashes = { sha256 = "0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", upload-time = 2025-08-25T13:49:24Z, size = 44614, hashes = { sha256 = "f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548" } }] + +[[packages]] +name = "typing-inspection" +version = "0.4.2" +sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", upload-time = 2025-10-01T02:14:41Z, size = 75949, hashes = { sha256 = "ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", upload-time = 2025-10-01T02:14:40Z, size = 14611, hashes = { sha256 = "4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7" } }] + +[[packages]] +name = "tzdata" +version = "2026.2" +sdist = { url = "https://files.pythonhosted.org/packages/ba/19/1b9b0e29f30c6d35cb345486df41110984ea67ae69dddbc0e8a100999493/tzdata-2026.2.tar.gz", upload-time = 2026-04-24T15:22:08Z, size = 198254, hashes = { sha256 = "9173fde7d80d9018e02a662e168e5a2d04f87c41ea174b139fbef642eda62d10" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ce/e4/dccd7f47c4b64213ac01ef921a1337ee6e30e8c6466046018326977efd95/tzdata-2026.2-py2.py3-none-any.whl", upload-time = 2026-04-24T15:22:05Z, size = 349321, hashes = { sha256 = "bbe9af844f658da81a5f95019480da3a89415801f6cc966806612cc7169bffe7" } }] + +[[packages]] +name = "urllib3" +version = "2.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", upload-time = 2026-05-07T16:13:18Z, size = 433602, hashes = { sha256 = "231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", upload-time = 2026-05-07T16:13:17Z, size = 131087, hashes = { sha256 = "9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897" } }] + +[[packages]] +name = "uvicorn" +version = "0.46.0" +sdist = { url = "https://files.pythonhosted.org/packages/1f/93/041fca8274050e40e6791f267d82e0e2e27dd165627bd640d3e0e378d877/uvicorn-0.46.0.tar.gz", upload-time = 2026-04-23T07:16:00Z, size = 88758, hashes = { sha256 = "fb9da0926999cc6cb22dc7cd71a94a632f078e6ae47ff683c5c420750fb7413d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/31/a3/5b1562db76a5a488274b2332a97199b32d0442aca0ed193697fd47786316/uvicorn-0.46.0-py3-none-any.whl", upload-time = 2026-04-23T07:15:58Z, size = 70926, hashes = { sha256 = "bbebbcbed972d162afca128605223022bedd345b7bc7855ce66deb31487a9048" } }] + +[[packages]] +name = "uvloop" +version = "0.22.1" +sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", upload-time = 2025-10-16T22:17:19Z, size = 2443250, hashes = { sha256 = "6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-10-16T22:16:32Z, size = 4426307, hashes = { sha256 = "7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4" } }] + +[[packages]] +name = "watchfiles" +version = "1.1.1" +sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8869df9b2a2d6c59d79220a4db37679e74f807c559ffe5265e08b227a210/watchfiles-1.1.1.tar.gz", upload-time = 2025-10-14T15:06:21Z, size = 94440, hashes = { sha256 = "a173cb5c16c4f40ab19cecf48a534c409f7ea983ab8fed0741304a1c0a31b3f2" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/cf/68/5707da262a119fb06fbe214d82dd1fe4a6f4af32d2d14de368d0349eb52a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-10-14T15:04:55Z, size = 456812, hashes = { sha256 = "1db5d7ae38ff20153d542460752ff397fcf5c96090c1230803713cf3147a6803" } }] + +[[packages]] +name = "wcwidth" +version = "0.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/35/a2/8e3becb46433538a38726c948d3399905a4c7cabd0df578ede5dc51f0ec2/wcwidth-0.6.0.tar.gz", upload-time = 2026-02-06T19:19:40Z, size = 159684, hashes = { sha256 = "cdc4e4262d6ef9a1a57e018384cbeb1208d8abbc64176027e2c2455c81313159" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/68/5a/199c59e0a824a3db2b89c5d2dade7ab5f9624dbf6448dc291b46d5ec94d3/wcwidth-0.6.0-py3-none-any.whl", upload-time = 2026-02-06T19:19:39Z, size = 94189, hashes = { sha256 = "1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad" } }] + +[[packages]] +name = "xgrammar" +version = "0.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/d8/ea/6394caddd078d33772070eefaaf77cb0a826a3047b908b688dece7d040b5/xgrammar-0.2.1.tar.gz", upload-time = 2026-05-17T21:39:26Z, size = 2427065, hashes = { sha256 = "4c48c251b75d211e9ffa7f4f4ac8b5b0164f89fd5f0d1883ad7ff4554922030d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/96/4b/327b3cf702b685a2be28d15490faa4beeac00c4fbcf9bb2d7db0fda32931/xgrammar-0.2.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-05-17T21:38:00Z, size = 44678489, hashes = { sha256 = "cbc6014dc1c92fc317b14519121c8163fe35fd934179e5a45d83f780ff231826" } }] + +[[packages]] +name = "xxhash" +version = "3.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/24/2f/e183a1b407002f5af81822bee18b61cdb94b8670208ef34734d8d2b8ebe9/xxhash-3.7.0.tar.gz", upload-time = 2026-04-25T11:10:32Z, size = 82022, hashes = { sha256 = "6cc4eefbb542a5d6ffd6d70ea9c502957c925e800f998c5630ecc809d6702bae" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/40/37/558f5a90c0672fc9b4402dc25d87ac5b7406616e8969430c9ca4e52ee74d/xxhash-3.7.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-25T11:06:31Z, size = 193932, hashes = { sha256 = "13805f0461cba0a857924e70ff91ae6d52d2598f79a884e788db80532614a4a1" } }] + +[[packages]] +name = "yarl" +version = "1.23.0" +sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", upload-time = 2026-03-01T22:07:53Z, size = 194676, hashes = { sha256 = "53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-01T22:05:23Z, size = 100132, hashes = { sha256 = "a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51" } }, + { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", upload-time = 2026-03-01T22:07:51Z, size = 48288, hashes = { sha256 = "a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f" } }, +] + +[[packages]] +name = "z3-solver" +version = "4.15.4.0" +sdist = { url = "https://files.pythonhosted.org/packages/8a/8e/0c8f17309549d2e5cde9a3ccefa6365437f1e7bafe71878eaf9478e47b18/z3_solver-4.15.4.0.tar.gz", upload-time = 2025-10-29T18:12:03Z, size = 5018600, hashes = { sha256 = "928c29b58c4eb62106da51c1914f6a4a55d0441f8f48a81b9da07950434a8946" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/21/c9/bb51a96af0091324c81b803f16c49f719f9f6ea0b0bb52200f5c97ec4892/z3_solver-4.15.4.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-10-29T18:11:53Z, size = 29268352, hashes = { sha256 = "7e103a6f203f505b8b8b8e5c931cc407c95b61556512d4921c1ddc0b3f41b08e" } }] + +[[packages]] +name = "zipp" +version = "3.23.1" +sdist = { url = "https://files.pythonhosted.org/packages/30/21/093488dfc7cc8964ded15ab726fad40f25fd3d788fd741cc1c5a17d78ee8/zipp-3.23.1.tar.gz", upload-time = 2026-04-13T23:21:46Z, size = 25965, hashes = { sha256 = "32120e378d32cd9714ad503c1d024619063ec28aad2248dc6672ad13edfa5110" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/08/8a/0861bec20485572fbddf3dfba2910e38fe249796cb73ecdeb74e07eeb8d3/zipp-3.23.1-py3-none-any.whl", upload-time = 2026-04-13T23:21:45Z, size = 10378, hashes = { sha256 = "0b3596c50a5c700c9cb40ba8d86d9f2cc4807e9bedb06bcdf7fac85633e444dc" } }] + +[[packages]] +name = "zstandard" +version = "0.25.0" +sdist = { url = "https://files.pythonhosted.org/packages/fd/aa/3e0508d5a5dd96529cdc5a97011299056e14c6505b678fd58938792794b1/zstandard-0.25.0.tar.gz", upload-time = 2025-09-14T22:15:54Z, size = 711513, hashes = { sha256 = "7713e1179d162cf5c7906da876ec2ccb9c3a9dcbdffef0cc7f70c3667a205f0b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/53/60/7be26e610767316c028a2cbedb9a3beabdbe33e2182c373f71a1c0b88f36/zstandard-0.25.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-09-14T22:17:06Z, size = 5546993, hashes = { sha256 = "5a56ba0db2d244117ed744dfa8f6f5b366e14148e00de44723413b2f3938a902" } }] diff --git a/packages/sie_server/bundle-locks/cuda13-tensorrt-llm-amd64/manifest.json b/packages/sie_server/bundle-locks/cuda13-tensorrt-llm-amd64/manifest.json new file mode 100644 index 000000000..a21e0e6d6 --- /dev/null +++ b/packages/sie_server/bundle-locks/cuda13-tensorrt-llm-amd64/manifest.json @@ -0,0 +1,43 @@ +{ + "completed_artifact_hashes": [ + { + "bytes": 134899, + "sha256": "85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", + "url": "https://download.pytorch.org/whl/jinja2-3.1.6-py3-none-any.whl" + }, + { + "bytes": 22947, + "sha256": "d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", + "url": "https://download.pytorch.org/whl/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl" + } + ], + "exceptions_sha256": "19be864d293ebf7373e9f62dbde7bd01eb7ae8a1a82835a123b46eb63b493084", + "exclude_newer": "2026-10-18T00:00:00Z", + "indexes": [ + "--default-index", + "https://pypi.org/simple", + "--index", + "https://download.pytorch.org/whl/cu130", + "--index", + "https://docs.sglang.ai/whl/cu130/", + "--index-strategy", + "unsafe-best-match", + "--prerelease", + "allow" + ], + "inputs": { + "requirements_sha256": "16719ba49f177504ae160a1872b8d0c23e0a4b6d176ecad85c882977d27be9fe", + "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" + }, + "lock_sha256": "53da95f8af3e7c4b2b35daa5265c2e7962c833940b234dff71cb24829ecbc78c", + "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "schema_version": 1, + "target": { + "architecture": "amd64", + "bundle": "tensorrt-llm", + "platform": "cuda13", + "python_platform": "x86_64-manylinux_2_35", + "python_version": "3.12" + }, + "uv_version": "0.9.28" +} diff --git a/packages/sie_server/bundle-locks/cuda13-tensorrt-llm-amd64/pylock.toml b/packages/sie_server/bundle-locks/cuda13-tensorrt-llm-amd64/pylock.toml new file mode 100644 index 000000000..7c574907d --- /dev/null +++ b/packages/sie_server/bundle-locks/cuda13-tensorrt-llm-amd64/pylock.toml @@ -0,0 +1,1621 @@ +lock-version = "1.0" +created-by = "uv" +requires-python = ">=3.12" + +[[packages]] +name = "accelerate" +version = "1.15.0" +sdist = { url = "https://files.pythonhosted.org/packages/f5/b5/1d3ed029ac71d3f2961346829a268da923698e9fd63f218f78841f216bfd/accelerate-1.15.0.tar.gz", upload-time = 2026-09-09T13:04:49Z, size = 422615, hashes = { sha256 = "5654f8c5eaa0d4fa68b33e287a97765da6849bf6d51dcac874e73fbbddfb6134" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8a/4c/34f0450479d01195027260da68d8a3880683f1640c3ca5adf64acb3185f1/accelerate-1.15.0-py3-none-any.whl", upload-time = 2026-09-09T13:04:47Z, size = 394295, hashes = { sha256 = "97eacca0b73e45cb867dbf8c5d5d4dc32219544300e0c8992c7334dc2ef33cec" } }] + +[[packages]] +name = "aenum" +version = "3.1.17" +sdist = { url = "https://files.pythonhosted.org/packages/07/e9/8b283567c1fef7c24d1f390b37daede8b61593d8cdaffb8e95d571699e83/aenum-3.1.17.tar.gz", upload-time = 2026-03-20T20:43:29Z, size = 137648, hashes = { sha256 = "a969a4516b194895de72c875ece355f17c0d272146f7fda346ef74f93cf4d5ba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/48/8d/1fe30c6fd8999b9d462547c4a1bb6690bda24af38f2913c4bec7decb81f2/aenum-3.1.17-py3-none-any.whl", upload-time = 2026-03-20T20:43:27Z, size = 165560, hashes = { sha256 = "8b883a37a04e74cc838ac442bdd28c266eae5bbf13e1342c7ef123ed25230139" } }] + +[[packages]] +name = "aiohappyeyeballs" +version = "2.6.1" +sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", upload-time = 2025-03-12T01:42:48Z, size = 22760, hashes = { sha256 = "c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", upload-time = 2025-03-12T01:42:47Z, size = 15265, hashes = { sha256 = "f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8" } }] + +[[packages]] +name = "aiohttp" +version = "3.14.3" +sdist = { url = "https://files.pythonhosted.org/packages/58/d9/22ce5786ac0c1653ae8b6c23bded02c1686d11f0dbb45b31ce128e0df985/aiohttp-3.14.3.tar.gz", upload-time = 2026-07-23T01:57:27Z, size = 7971213, hashes = { sha256 = "9491196535a88924a60afd5b5f434b5b203b6cc616250878dbdb223a8f7844bc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/52/b7/7cd31f29d6055bd711ae6e669367fba6f5ae9de463910a793e30556a8db7/aiohttp-3.14.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-23T01:54:15Z, size = 1792122, hashes = { sha256 = "543906c127fb1d929b95076db19b83fa2d46751006ff1e23b093aa5ac4d8db42" } }] + +[[packages]] +name = "aiosignal" +version = "1.4.0" +sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", upload-time = 2025-07-03T22:54:43Z, size = 25007, hashes = { sha256 = "f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", upload-time = 2025-07-03T22:54:42Z, size = 7490, hashes = { sha256 = "053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e" } }] + +[[packages]] +name = "annotated-doc" +version = "0.0.4" +sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", upload-time = 2025-11-10T22:07:42Z, size = 7288, hashes = { sha256 = "fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", upload-time = 2025-11-10T22:07:40Z, size = 5303, hashes = { sha256 = "571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320" } }] + +[[packages]] +name = "annotated-types" +version = "0.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", upload-time = 2024-05-20T21:33:25Z, size = 16081, hashes = { sha256 = "aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", upload-time = 2024-05-20T21:33:24Z, size = 13643, hashes = { sha256 = "1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53" } }] + +[[packages]] +name = "antlr4-python3-runtime" +version = "4.9.3" +sdist = { url = "https://files.pythonhosted.org/packages/3e/38/7859ff46355f76f8d19459005ca000b6e7012f2f1ca597746cbcd1fbfe5e/antlr4-python3-runtime-4.9.3.tar.gz", upload-time = 2021-11-06T17:52:23Z, size = 117034, hashes = { sha256 = "f224469b4168294902bb1efa80a8bf7855f24c99aef99cbefc1bcd3cce77881b" } } + +[[packages]] +name = "anyio" +version = "4.14.2" +sdist = { url = "https://files.pythonhosted.org/packages/61/cc/a381afa6efea9f496eff839d4a6a1aed3bfafc7b3ab4b0d1b243a12573dd/anyio-4.14.2.tar.gz", upload-time = 2026-07-12T20:29:07Z, size = 260176, hashes = { sha256 = "cfa139f3ed1a23ee8f88a145ddb5ac7605b8bbfd8592baacd7ce3d8bb4313c7f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/da/35/f2287558c17e29fafc8ef3daf819bb9834061cfa43bff8014f7df7f63bdc/anyio-4.14.2-py3-none-any.whl", upload-time = 2026-07-12T20:29:05Z, size = 125813, hashes = { sha256 = "9f505dda5ac9f0c8309b5e8bd445a8c2bf7246f3ce950121e45ea15bc41d1494" } }] + +[[packages]] +name = "apache-tvm-ffi" +version = "0.1.6" +sdist = { url = "https://files.pythonhosted.org/packages/45/20/8da071821b2142bdeed757d2859dede4817e0b82a96e9a4d8cfbffd49006/apache_tvm_ffi-0.1.6.tar.gz", upload-time = 2025-12-16T19:00:33Z, size = 2387987, hashes = { sha256 = "53088126f7fce11823ddf0fb101e968a90298d79fd68829c0a981f25467a574c" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/91/fc43f155b4d4363e61707655c1f4bee75af1d6dd4a76680f4956dd9846fe/apache_tvm_ffi-0.1.6-cp312-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-12-16T19:00:02Z, size = 2013641, hashes = { sha256 = "6a2cdfa90860a80e3cfb2364ce3b66a559fa5748de8d593a203b2e5992d92bc1" } }, + { url = "https://files.pythonhosted.org/packages/7d/c5/e3ba08379127578bb3417605b61e9cd5e513184a6947ec7f3fac93d16355/apache_tvm_ffi-0.1.6-cp312-abi3-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-12-16T19:00:05Z, size = 1992886, hashes = { sha256 = "05cedb3ba7600dc9ae35c17b7325d44ecf02c56c3ba1b62668dca8390da7ec28" } }, +] + +[[packages]] +name = "argon2-cffi" +version = "25.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/0e/89/ce5af8a7d472a67cc819d5d998aa8c82c5d860608c4db9f46f1162d7dab9/argon2_cffi-25.1.0.tar.gz", upload-time = 2025-06-03T06:55:32Z, size = 45706, hashes = { sha256 = "694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/4f/d3/a8b22fa575b297cd6e3e3b0155c7e25db170edf1c74783d6a31a2490b8d9/argon2_cffi-25.1.0-py3-none-any.whl", upload-time = 2025-06-03T06:55:30Z, size = 14657, hashes = { sha256 = "fdc8b074db390fccb6eb4a3604ae7231f219aa669a2652e0f20e16ba513d5741" } }] + +[[packages]] +name = "argon2-cffi-bindings" +version = "26.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/0b/43/bb8b6e8708d49a5ab36781333af092d9f483b198a2710d01281204640055/argon2_cffi_bindings-26.1.0.tar.gz", upload-time = 2026-08-20T07:44:22Z, size = 1790807, hashes = { sha256 = "63505c71542a44b68b1e38060450fb006404170da375feb31af153e7f9c6205d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/6f/86/5363df11b86d02cf3662208e7406496327649cc90eb365bf6f4e8a54a41f/argon2_cffi_bindings-26.1.0-cp310-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-08-20T07:32:45Z, size = 26597, hashes = { sha256 = "27f1821903e2ceadcb88ec2b45ef190897b7682449c772f4d9b53e42c520cf29" } }] + +[[packages]] +name = "arrow" +version = "1.4.0" +sdist = { url = "https://files.pythonhosted.org/packages/b9/33/032cdc44182491aa708d06a68b62434140d8c50820a087fac7af37703357/arrow-1.4.0.tar.gz", upload-time = 2025-10-18T17:46:46Z, size = 152931, hashes = { sha256 = "ed0cc050e98001b8779e84d461b0098c4ac597e88704a655582b21d116e526d7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ed/c9/d7977eaacb9df673210491da99e6a247e93df98c715fc43fd136ce1d3d33/arrow-1.4.0-py3-none-any.whl", upload-time = 2025-10-18T17:46:45Z, size = 68797, hashes = { sha256 = "749f0769958ebdc79c173ff0b0670d59051a535fa26e8eba02953dc19eb43205" } }] + +[[packages]] +name = "asttokens" +version = "3.0.1" +sdist = { url = "https://files.pythonhosted.org/packages/be/a5/8e3f9b6771b0b408517c82d97aed8f2036509bc247d46114925e32fe33f0/asttokens-3.0.1.tar.gz", upload-time = 2025-11-15T16:43:48Z, size = 62308, hashes = { sha256 = "71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d2/39/e7eaf1799466a4aef85b6a4fe7bd175ad2b1c6345066aa33f1f58d4b18d0/asttokens-3.0.1-py3-none-any.whl", upload-time = 2025-11-15T16:43:16Z, size = 27047, hashes = { sha256 = "15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a" } }] + +[[packages]] +name = "async-lru" +version = "2.4.0" +sdist = { url = "https://files.pythonhosted.org/packages/8f/43/9d22679e8dd0ed965182cca990d32c68b150730cce8046ad61b3179b5b7a/async_lru-2.4.0.tar.gz", upload-time = 2026-10-12T18:12:54Z, size = 22927, hashes = { sha256 = "b0b0077d9b7596615b3c12d0aad4f6aeccaaa0ac75ceae472608ede89e764c08" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ec/0b/6a817103fb78faca4970c686a61065047da7226aba0d7cae6d4299b20c59/async_lru-2.4.0-py3-none-any.whl", upload-time = 2026-10-12T18:12:53Z, size = 10045, hashes = { sha256 = "1b46a96419ef91fe11431d58db98d792c9b4250001427191a40faf1031934212" } }] + +[[packages]] +name = "attrs" +version = "26.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", upload-time = 2026-03-19T14:22:25Z, size = 952055, hashes = { sha256 = "d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", upload-time = 2026-03-19T14:22:23Z, size = 67548, hashes = { sha256 = "c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309" } }] + +[[packages]] +name = "babel" +version = "2.18.0" +sdist = { url = "https://files.pythonhosted.org/packages/7d/b2/51899539b6ceeeb420d40ed3cd4b7a40519404f9baf3d4ac99dc413a834b/babel-2.18.0.tar.gz", upload-time = 2026-02-01T12:30:56Z, size = 9959554, hashes = { sha256 = "b80b99a14bd085fcacfa15c9165f651fbb3406e66cc603abf11c5750937c992d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/77/f5/21d2de20e8b8b0408f0681956ca2c69f1320a3848ac50e6e7f39c6159675/babel-2.18.0-py3-none-any.whl", upload-time = 2026-02-01T12:30:53Z, size = 10196845, hashes = { sha256 = "e2b422b277c2b9a9630c1d7903c2a00d0830c409c59ac8cae9081c92f1aeba35" } }] + +[[packages]] +name = "backoff" +version = "2.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/47/d7/5bbeb12c44d7c4f2fb5b56abce497eb5ed9f34d85701de869acedd602619/backoff-2.2.1.tar.gz", upload-time = 2022-10-05T19:19:32Z, size = 17001, hashes = { sha256 = "03f829f5bb1923180821643f8753b0502c3b682293992485b0eef2807afa5cba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/df/73/b6e24bd22e6720ca8ee9a85a0c4a2971af8497d8f3193fa05390cbd46e09/backoff-2.2.1-py3-none-any.whl", upload-time = 2022-10-05T19:19:30Z, size = 15148, hashes = { sha256 = "63579f9a0628e06278f7e47b7d7d5b6ce20dc65c5e96a6f3ca99a6adca0396e8" } }] + +[[packages]] +name = "beautifulsoup4" +version = "4.14.3" +sdist = { url = "https://files.pythonhosted.org/packages/c3/b0/1c6a16426d389813b48d95e26898aff79abbde42ad353958ad95cc8c9b21/beautifulsoup4-4.14.3.tar.gz", upload-time = 2025-11-30T15:08:26Z, size = 627737, hashes = { sha256 = "6292b1c5186d356bba669ef9f7f051757099565ad9ada5dd630bd9de5fa7fb86" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1a/39/47f9197bdd44df24d67ac8893641e16f386c984a0619ef2ee4c51fbbc019/beautifulsoup4-4.14.3-py3-none-any.whl", upload-time = 2025-11-30T15:08:24Z, size = 107721, hashes = { sha256 = "0918bfe44902e6ad8d57732ba310582e98da931428d231a5ecb9e7c703a735bb" } }] + +[[packages]] +name = "blake3" +version = "0.4.1" +sdist = { url = "https://files.pythonhosted.org/packages/b0/8d/43eafa8a785547c33b611068ffd6d914f5c5f96637d5b453abc556f095a0/blake3-0.4.1.tar.gz", upload-time = 2024-02-04T21:52:52Z, size = 117686, hashes = { sha256 = "0625c8679203d5a1d30f859696a3fd75b2f50587984690adab839ef112f4c043" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ec/c6/8f6717fbea55ec9eb21543aa6d8e1bd904d6d2dcc886b555aa3d3f450ba7/blake3-0.4.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2024-02-04T21:52:22Z, size = 1275086, hashes = { sha256 = "a51f48ec21706a22b4954fc17da72bd177d82d22ee434da0c5dc3aafeef5b8d3" } }] + +[[packages]] +name = "bleach" +version = "6.4.0" +sdist = { url = "https://files.pythonhosted.org/packages/48/3c/e12ac860709702bd5ebeb9b56a4fe334f1001246ee1b8f2b7ee28912df7d/bleach-6.4.0.tar.gz", upload-time = 2026-06-05T13:01:13Z, size = 204857, hashes = { sha256 = "4202482733d85cedd04e59fcb2f89f4e4c7c385a78d3c3c23c30446843a37452" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/58/9d/40b6267367182187139a4000b82a3b287d84d745bccd808e75d916920e9d/bleach-6.4.0-py3-none-any.whl", upload-time = 2026-06-05T13:01:12Z, size = 165109, hashes = { sha256 = "4b6b6a54fff2e69a3dde9d21cc6301220bee3c3cb792187d11403fd795031081" } }] + +[[packages]] +name = "blobfile" +version = "3.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/1d/34/22758967ffadf4006d999d292660f566c59fcc81fd6d54e8f67d0fe4d5ba/blobfile-3.3.0.tar.gz", upload-time = 2026-08-20T02:16:45Z, size = 78587, hashes = { sha256 = "98bd9fafed8d0175d315a5b605680f522949057e16cb4932b07ce5a5f67e8985" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/71/b4/285ce9101e85271a4b586874ceb9ab6f2b8a67375f21235d54353724103f/blobfile-3.3.0-py3-none-any.whl", upload-time = 2026-08-20T02:16:43Z, size = 76839, hashes = { sha256 = "b87b00a0448c6111683d7eef011d02c03e808bef0928149fde2b5fa3a22ba753" } }] + +[[packages]] +name = "build" +version = "1.4.4" +sdist = { url = "https://files.pythonhosted.org/packages/02/ec/bf5ae0a7e5ab57abe8aabdd0759c971883895d1a20c49ae99f8146840c3c/build-1.4.4.tar.gz", upload-time = 2026-04-22T20:53:44Z, size = 89220, hashes = { sha256 = "f832ae053061f3fb524af812dc94b8b84bac6880cd587630e3b5d91a6a9c1703" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/fa/88/6764e7a109dd84294850741501145da90d13cdeac9d4e614929464a37420/build-1.4.4-py3-none-any.whl", upload-time = 2026-04-22T20:53:43Z, size = 25921, hashes = { sha256 = "8c3f48a6090b39edec1a273d2d57949aaf13723b01e02f9d518396887519f64d" } }] + +[[packages]] +name = "cache-dit" +version = "1.5.3" +wheels = [{ url = "https://files.pythonhosted.org/packages/8c/51/1bc2d666558b160634b14952702d32c5371e98fcac7fadbe638367b15f2a/cache_dit-1.5.3-py3-none-any.whl", upload-time = 2026-10-15T06:13:08Z, size = 557951, hashes = { sha256 = "f4564e68b5f6206d25712b06b4d9e0321ef96aadcd00e0ed4645be92d3fd9e75" } }] + +[[packages]] +name = "certifi" +version = "2026.4.22" +sdist = { url = "https://files.pythonhosted.org/packages/25/ee/6caf7a40c36a1220410afe15a1cc64993a1f864871f698c0f93acb72842a/certifi-2026.4.22.tar.gz", upload-time = 2026-04-22T11:26:11Z, size = 137077, hashes = { sha256 = "8d455352a37b71bf76a79caa83a3d6c25afee4a385d632127b6afb3963f1c580" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/22/30/7cd8fdcdfbc5b869528b079bfb76dcdf6056b1a2097a662e5e8c04f42965/certifi-2026.4.22-py3-none-any.whl", upload-time = 2026-04-22T11:26:09Z, size = 135707, hashes = { sha256 = "3cb2210c8f88ba2318d29b0388d1023c8492ff72ecdde4ebdaddbb13a31b1c4a" } }] + +[[packages]] +name = "cffi" +version = "2.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", upload-time = 2025-09-08T23:24:04Z, size = 523588, hashes = { sha256 = "44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-09-08T23:22:52Z, size = 219572, hashes = { sha256 = "3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba" } }] + +[[packages]] +name = "charset-normalizer" +version = "3.4.7" +sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", upload-time = 2026-04-02T09:28:39Z, size = 144271, hashes = { sha256 = "ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4b/f8/d0118a2f5f23b02cd166fa385c60f9b0d4f9194f574e2b31cef350ad7223/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-02T09:26:29Z, size = 216589, hashes = { sha256 = "5649fd1c7bade02f320a462fdefd0b4bd3ce036065836d4f42e0de958038e116" } }, + { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", upload-time = 2026-04-02T09:28:37Z, size = 61958, hashes = { sha256 = "3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d" } }, +] + +[[packages]] +name = "click" +version = "8.3.3" +sdist = { url = "https://files.pythonhosted.org/packages/bb/63/f9e1ea081ce35720d8b92acde70daaedace594dc93b693c869e0d5910718/click-8.3.3.tar.gz", upload-time = 2026-04-22T15:11:27Z, size = 328061, hashes = { sha256 = "398329ad4837b2ff7cbe1dd166a4c0f8900c3ca3a218de04466f38f6497f18a2" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ae/44/c1221527f6a71a01ec6fbad7fa78f1d50dfa02217385cf0fa3eec7087d59/click-8.3.3-py3-none-any.whl", upload-time = 2026-04-22T15:11:25Z, size = 110502, hashes = { sha256 = "a2bf429bb3033c89fa4936ffb35d5cb471e3719e1f3c8a7c3fff0b8314305613" } }] + +[[packages]] +name = "click-option-group" +version = "0.5.9" +sdist = { url = "https://files.pythonhosted.org/packages/ef/ff/d291d66595b30b83d1cb9e314b2c9be7cfc7327d4a0d40a15da2416ea97b/click_option_group-0.5.9.tar.gz", upload-time = 2025-10-09T09:38:01Z, size = 22222, hashes = { sha256 = "f94ed2bc4cf69052e0f29592bd1e771a1789bd7bfc482dd0bc482134aff95823" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/75/45/54bb2d8d4138964a94bef6e9afe48b0be4705ba66ac442ae7d8a8dc4ffef/click_option_group-0.5.9-py3-none-any.whl", upload-time = 2025-10-09T09:38:00Z, size = 11553, hashes = { sha256 = "ad2599248bd373e2e19bec5407967c3eec1d0d4fc4a5e77b08a0481e75991080" } }] + +[[packages]] +name = "colored" +version = "2.3.2" +sdist = { url = "https://files.pythonhosted.org/packages/7a/b6/c07f766b24cc3c92e3e24339ccacbc949d004f0fde759cdf24727c5c02bd/colored-2.3.2.tar.gz", upload-time = 2026-03-28T14:54:19Z, size = 17066, hashes = { sha256 = "d6b7f0737a732c54c92b271f2932c91e386238c8b6ded49d4180eed44eb50684" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ee/93/2cfa674b84be707dc0b1653b00f7da9270c78a8fd43f7d80f0d8b1f5ead9/colored-2.3.2-py3-none-any.whl", upload-time = 2026-03-28T14:54:17Z, size = 20285, hashes = { sha256 = "f192e0545b7214f5479031495d14f4a46b29695650c46a50bf5bb8fb5cbd7893" } }] + +[[packages]] +name = "comm" +version = "0.2.3" +sdist = { url = "https://files.pythonhosted.org/packages/4c/13/7d740c5849255756bc17888787313b61fd38a0a8304fc4f073dfc46122aa/comm-0.2.3.tar.gz", upload-time = 2025-07-25T14:02:04Z, size = 6319, hashes = { sha256 = "2dc8048c10962d55d7ad693be1e7045d891b7ce8d999c97963a5e3e99c055971" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/60/97/891a0971e1e4a8c5d2b20bbe0e524dc04548d2307fee33cdeba148fd4fc7/comm-0.2.3-py3-none-any.whl", upload-time = 2025-07-25T14:02:02Z, size = 7294, hashes = { sha256 = "c615d91d75f7f04f095b30d1c1711babd43bdc6419c1be9886a85f2f4e489417" } }] + +[[packages]] +name = "contourpy" +version = "1.4.0" +sdist = { url = "https://files.pythonhosted.org/packages/83/5a/a55177dd22553a277388e8a1b3220e92de91bacb28356cdc73caa240121d/contourpy-1.4.0.tar.gz", upload-time = 2026-09-11T19:05:05Z, size = 13323726, hashes = { sha256 = "20156f5a1ac4f8ce02656e39a61e82164a3d359796dc8026f75b062783d500e1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/78/f9/b6831508960d559581c448532ba4df312217072975486dbf2b24fcc5b76f/contourpy-1.4.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-09-11T19:02:58Z, size = 383243, hashes = { sha256 = "875f42444c9cf48d56f724f2637e60d0f73b3b12c9041e1484580a233edf9591" } }] + +[[packages]] +name = "cpsat-logutils" +version = "1.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/f8/42/2c2c14746ce87ff2932c8e086efbcc264e05664f29e36934f176c4c8ca19/cpsat_logutils-1.0.0.tar.gz", upload-time = 2026-09-06T16:09:15Z, size = 200951, hashes = { sha256 = "db8e0b5bf16fae203e08692088e9f8a248846e03934242367f7da5dab10322ee" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/15/6e/2c65834041468bcabb956c5e4465ad240af7f312b2d8b54d7c9a51b26885/cpsat_logutils-1.0.0-py3-none-any.whl", upload-time = 2026-09-06T16:09:13Z, size = 37338, hashes = { sha256 = "02112cc460d30aeab3a591592bfa09cc5705fa3745d5d418a7339e8843c14e5d" } }] + +[[packages]] +name = "cryptography" +version = "50.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/de/41/6cbdcf9142d00fe82836fbb51e503e58088575cf7a0fe1dbff6695bf0840/cryptography-50.0.0.tar.gz", upload-time = 2026-07-31T14:25:10Z, size = 880201, hashes = { sha256 = "eeac2acb5a20ed25e0ad6d1df9891a520b78b404266b6d11778f25d5d691a6c9" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/41/029086c34d91052fc3b88bcc8056f709a7c915c7a23b235a54eb800b1c97/cryptography-50.0.0-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-07-31T14:23:37Z, size = 4702130, hashes = { sha256 = "06a32a980526a6ab9a4b9bf8f7385800791e2bb960903cb6b530e4817509a3b7" } }, + { url = "https://files.pythonhosted.org/packages/6b/72/a1116d683a6d7ece94590013882515de087edf9ef0e6292aae615a44df73/cryptography-50.0.0-cp311-abi3-manylinux_2_28_x86_64.whl", upload-time = 2026-07-31T14:23:43Z, size = 4734609, hashes = { sha256 = "b42a28c1844fd9de8f3f7d540e36b66f3a9c83fceac7170ebc7a6a19edd9dcae" } }, + { url = "https://files.pythonhosted.org/packages/da/3a/f05e32c99d440c9bb891ea0e36c9091891e36be5a9a87ab2ee6ea20729f6/cryptography-50.0.0-cp311-abi3-manylinux_2_34_x86_64.whl", upload-time = 2026-07-31T14:23:50Z, size = 4734462, hashes = { sha256 = "82148ec5bddac30b51a5b3c1945075f896fa022cb93f8e4a01e9f6ee95292c5f" } }, + { url = "https://files.pythonhosted.org/packages/85/4f/0fa8c2f4428198f15d9ff8d63400e27afbf94ce833f6108da1eb3753f945/cryptography-50.0.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-07-31T14:24:27Z, size = 4728939, hashes = { sha256 = "a91296cb61e8df6f86d0c19cc4068228da256bf59bf86049fbd821084565327f" } }, + { url = "https://files.pythonhosted.org/packages/46/c9/f60aed34c013f317f92817b6c171c2d22a78270fa41109bd4b08af26b194/cryptography-50.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", upload-time = 2026-07-31T14:24:34Z, size = 4762647, hashes = { sha256 = "105110f43a471dbd0060b9c9516cb8a6a79233631a04cc2ba16f28323ac6e025" } }, + { url = "https://files.pythonhosted.org/packages/9c/f8/d97f9603efda3888187bfdb893f26c41be4735c10631d05d284ee6b047c4/cryptography-50.0.0-cp39-abi3-manylinux_2_34_x86_64.whl", upload-time = 2026-07-31T14:24:43Z, size = 4762400, hashes = { sha256 = "37fdb0d0111f1e2ff07139dfb79f1b49531f8e213c46f1163dd7642979b58c47" } }, +] + +[[packages]] +name = "cuda-bindings" +version = "13.4.4" +wheels = [{ url = "https://files.pythonhosted.org/packages/c2/f8/332443cf969734551891cdbd93657eaeaf747ac2b7dd73feb3422701b02b/cuda_bindings-13.4.4-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-10-14T12:35:22Z, size = 7172184, hashes = { sha256 = "433efa31e33c2868621b5f6036bd3bf5de9c45c5546cb1361a5f6ff3415b8bb5" } }] + +[[packages]] +name = "cuda-core" +version = "1.2.2" +wheels = [{ url = "https://files.pythonhosted.org/packages/f2/1c/8e1f7d42984d6b164521a1dec587f3cf6d1fc585ff929f1420faa07da9d3/cuda_core-1.2.2-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-10-16T13:58:51Z, size = 6610599, hashes = { sha256 = "0b299eee52edece08b77428cfc22b33b29be1bc69c42878d2e6114031eac17e6" } }] + +[[packages]] +name = "cuda-pathfinder" +version = "1.7.0" +wheels = [{ url = "https://files.pythonhosted.org/packages/62/01/a7171c5e2e8755597bd8f1c1eb228a0876f502afdf25f936061f5dbe2880/cuda_pathfinder-1.7.0-py3-none-any.whl", upload-time = 2026-08-24T04:13:56Z, size = 63091, hashes = { sha256 = "e9d67e950f3d5992b854dfd25917c3719d0c21d3057b11abe86ba6feec526138" } }] + +[[packages]] +name = "cuda-python" +version = "13.4.4" +wheels = [{ url = "https://files.pythonhosted.org/packages/e1/2c/04c83864345051c6281396cd29d7190de1a23e2a533fa038c30b5552eb59/cuda_python-13.4.4-py3-none-any.whl", upload-time = 2026-10-14T12:49:47Z, size = 7594, hashes = { sha256 = "2a4a35c7f102e3c51b9e18e65b34a24b82d7363893b6e2f228978c18bafa1957" } }] + +[[packages]] +name = "cuda-tile" +version = "1.6.0rc8" +wheels = [{ url = "https://files.pythonhosted.org/packages/f2/92/d4f03cdd45b5a43088580371b0e40504e053c27dde61211791d6ee0adfb3/cuda_tile-1.6.0rc8-cp312-cp312-manylinux2014_x86_64.whl", upload-time = 2026-08-21T19:09:18Z, size = 371450, hashes = { sha256 = "c35825a5fa6d4757acbad3b50564015c32da7edaf1a7bb98c07871880d3cc3e5" } }] + +[[packages]] +name = "cuda-toolkit" +version = "13.0.2" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/57/b2/453099f5f3b698d7d0eab38916aac44c7f76229f451709e2eb9db6615dcd/cuda_toolkit-13.0.2-py2.py3-none-any.whl", upload-time = 2025-12-19T23:24:07Z, size = 2364, hashes = { sha256 = "b198824cf2f54003f50d64ada3a0f184b42ca0846c1c94192fa269ecd97a66eb" } }] + +[[packages]] +name = "cycler" +version = "0.12.1" +sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", upload-time = 2023-10-07T05:32:18Z, size = 7615, hashes = { sha256 = "88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", upload-time = 2023-10-07T05:32:16Z, size = 8321, hashes = { sha256 = "85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30" } }] + +[[packages]] +name = "datasets" +version = "3.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/a3/b2/25ef6d54dcb2d1412e5efec59449d1af92e7a6d969e27adfe9965e780c1f/datasets-3.1.0.tar.gz", upload-time = 2024-10-31T15:14:11Z, size = 558115, hashes = { sha256 = "c92cac049e0f9f85b0dd63739c68e564c657b1624bc2b66b1e13489062832e27" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ed/a5/33cf000137545a08b0a3a6ea76c8ccbd87917f78bb5d737f9f56f3b11ef6/datasets-3.1.0-py3-none-any.whl", upload-time = 2024-10-31T15:14:09Z, size = 480554, hashes = { sha256 = "dc8808a6d17838fe05e13b39aa7ac3ea0fd0806ed7004eaf4d4eb2c2a356bc61" } }] + +[[packages]] +name = "debugpy" +version = "1.8.22" +sdist = { url = "https://files.pythonhosted.org/packages/44/9d/3cb6693342acf96802dba89934a5b8da43c201d764ebd1f2c0514a3d42bd/debugpy-1.8.22.tar.gz", upload-time = 2026-09-15T21:44:02Z, size = 1710877, hashes = { sha256 = "e489c7268e1c7b41e13b438d9c533d2a7af73fb59bf8cd30fead8286c1c39c4e" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/ec/7389798843643ea5bc6a08480ba1b855377c70e2ed90189c0a03594e401e/debugpy-1.8.22-cp312-cp312-manylinux_2_34_x86_64.whl", upload-time = 2026-09-15T21:44:20Z, size = 4000941, hashes = { sha256 = "8a697acec45dbc70d17fb5d9f4f61989fc294d273c69de487fd10cb35fdd75eb" } }, + { url = "https://files.pythonhosted.org/packages/56/3d/c7dc9f35bc9e22cdb53679f844bee40fd5cff871862f60595869a433400d/debugpy-1.8.22-py2.py3-none-any.whl", upload-time = 2026-09-15T21:44:54Z, size = 5374857, hashes = { sha256 = "a9e9d3550e15ca479c59333e90845029190531f0cacfedab3b815a57bd913947" } }, +] + +[[packages]] +name = "decorator" +version = "5.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", upload-time = 2025-02-24T04:41:34Z, size = 56711, hashes = { sha256 = "65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", upload-time = 2025-02-24T04:41:32Z, size = 9190, hashes = { sha256 = "d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a" } }] + +[[packages]] +name = "defusedxml" +version = "0.7.1" +sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", upload-time = 2021-03-08T10:59:26Z, size = 75520, hashes = { sha256 = "1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", upload-time = 2021-03-08T10:59:24Z, size = 25604, hashes = { sha256 = "a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61" } }] + +[[packages]] +name = "diffusers" +version = "0.39.0" +sdist = { url = "https://files.pythonhosted.org/packages/1a/81/6095237b86a3116c4789f28c4435d5296c00c0fc74ffde99008fd6b3a36c/diffusers-0.39.0.tar.gz", upload-time = 2026-07-03T08:48:47Z, size = 4651240, hashes = { sha256 = "14bb1d98c85a0e463d734c99aaa73b480a7bc9bad22af30fbf730ef8f09c1d67" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3f/3f/7469c46e9d22307ea686bab687d70e6bf328722952f9d10339f5e913e608/diffusers-0.39.0-py3-none-any.whl", upload-time = 2026-07-03T08:48:45Z, size = 5631176, hashes = { sha256 = "912aca51b5787365110806e984d5555735bf8a461073bb8459029d0bca7870ef" } }] + +[[packages]] +name = "dill" +version = "0.3.8" +sdist = { url = "https://files.pythonhosted.org/packages/17/4d/ac7ffa80c69ea1df30a8aa11b3578692a5118e7cd1aa157e3ef73b092d15/dill-0.3.8.tar.gz", upload-time = 2024-01-27T23:42:16Z, size = 184847, hashes = { sha256 = "3ebe3c479ad625c4553aca177444d89b486b1d84982eeacded644afc0cf797ca" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c9/7a/cef76fd8438a42f96db64ddaa85280485a9c395e7df3db8158cfec1eee34/dill-0.3.8-py3-none-any.whl", upload-time = 2024-01-27T23:42:14Z, size = 116252, hashes = { sha256 = "c36ca9ffb54365bdd2f8eb3eff7d2a21237f8452b57ace88b1ac615b7e815bd7" } }] + +[[packages]] +name = "distro" +version = "1.9.0" +sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", upload-time = 2023-12-24T09:54:32Z, size = 60722, hashes = { sha256 = "2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", upload-time = 2023-12-24T09:54:30Z, size = 20277, hashes = { sha256 = "7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2" } }] + +[[packages]] +name = "einops" +version = "0.8.2" +sdist = { url = "https://files.pythonhosted.org/packages/2c/77/850bef8d72ffb9219f0b1aac23fbc1bf7d038ee6ea666f331fa273031aa2/einops-0.8.2.tar.gz", upload-time = 2026-01-26T04:13:17Z, size = 56261, hashes = { sha256 = "609da665570e5e265e27283aab09e7f279ade90c4f01bcfca111f3d3e13f2827" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/09/f8d8f8f31e4483c10a906437b4ce31bdf3d6d417b73fe33f1a8b59e34228/einops-0.8.2-py3-none-any.whl", upload-time = 2026-01-26T04:13:18Z, size = 65638, hashes = { sha256 = "54058201ac7087911181bfec4af6091bb59380360f069276601256a76af08193" } }] + +[[packages]] +name = "etcd-sdk-python" +version = "0.0.7" +sdist = { url = "https://files.pythonhosted.org/packages/42/b3/99c19e3d4e2d6b946e60ca4d7e6a2b260f444550406cf5cb6b78fff97024/etcd_sdk_python-0.0.7.tar.gz", upload-time = 2025-08-04T03:09:14Z, size = 169734, hashes = { sha256 = "3eae8b16328a458dce8a4d39a835db666f31bc6f369117f6168c71bcd559a85d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/34/57/64e3b980a1448254eb9160f69e22180f92563e4f030fc7595f7b64634e95/etcd_sdk_python-0.0.7-py3-none-any.whl", upload-time = 2025-08-04T03:09:13Z, size = 52829, hashes = { sha256 = "dc0eb417c06c6e4f94c370dd19c096309f7a10bc6c89730c4fd66edd53f3a62f" } }] + +[[packages]] +name = "evaluate" +version = "0.4.6" +sdist = { url = "https://files.pythonhosted.org/packages/ad/d0/0c17a8e6e8dc7245f22dea860557c32bae50fc4d287ae030cb0e8ab8720f/evaluate-0.4.6.tar.gz", upload-time = 2025-09-18T13:06:30Z, size = 65716, hashes = { sha256 = "e07036ca12b3c24331f83ab787f21cc2dbf3631813a1631e63e40897c69a3f21" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/3e/af/3e990d8d4002bbc9342adb4facd59506e653da93b2417de0fa6027cb86b1/evaluate-0.4.6-py3-none-any.whl", upload-time = 2025-09-18T13:06:29Z, size = 84069, hashes = { sha256 = "bca85bc294f338377b7ac2f861e21c308b11b2a285f510d7d5394d5df437db29" } }] + +[[packages]] +name = "executing" +version = "2.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", upload-time = 2025-09-01T09:48:10Z, size = 1129488, hashes = { sha256 = "3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", upload-time = 2025-09-01T09:48:08Z, size = 28317, hashes = { sha256 = "760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017" } }] + +[[packages]] +name = "fastapi" +version = "0.121.3" +sdist = { url = "https://files.pythonhosted.org/packages/80/f0/086c442c6516195786131b8ca70488c6ef11d2f2e33c9a893576b2b0d3f7/fastapi-0.121.3.tar.gz", upload-time = 2025-11-19T16:53:39Z, size = 344501, hashes = { sha256 = "0055bc24fe53e56a40e9e0ad1ae2baa81622c406e548e501e717634e2dfbc40b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/98/b6/4f620d7720fc0a754c8c1b7501d73777f6ba43b57c8ab99671f4d7441eb8/fastapi-0.121.3-py3-none-any.whl", upload-time = 2025-11-19T16:53:37Z, size = 109801, hashes = { sha256 = "0c78fc87587fcd910ca1bbf5bc8ba37b80e119b388a7206b39f0ecc95ebf53e9" } }] + +[[packages]] +name = "fastjsonschema" +version = "2.22.2" +sdist = { url = "https://files.pythonhosted.org/packages/33/a4/9473c7c3b87009d9c1d74034e4a0f6a35ff0d42dd0f9866d0c3ec4e9217b/fastjsonschema-2.22.2.tar.gz", upload-time = 2026-08-15T19:47:08Z, size = 385171, hashes = { sha256 = "72064e12356a7d6ef02165be2946b9abadbdf238536e07eb587e3dbaa33099cf" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/49/82/2755c7c982086f00d4dab85bc120ec35045a9fc2191893a6ce79afe94443/fastjsonschema-2.22.2-py3-none-any.whl", upload-time = 2026-08-15T19:47:04Z, size = 27413, hashes = { sha256 = "0fb3915616adac85ccfdd737d26be1089845d2019819505b42d39888458f74d4" } }] + +[[packages]] +name = "filelock" +version = "3.29.0" +sdist = { url = "https://files.pythonhosted.org/packages/b5/fe/997687a931ab51049acce6fa1f23e8f01216374ea81374ddee763c493db5/filelock-3.29.0.tar.gz", upload-time = 2026-04-19T15:39:10Z, size = 57571, hashes = { sha256 = "69974355e960702e789734cb4871f884ea6fe50bd8404051a3530bc07809cf90" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/81/47/dd9a212ef6e343a6857485ffe25bba537304f1913bdbed446a23f7f592e1/filelock-3.29.0-py3-none-any.whl", upload-time = 2026-04-19T15:39:08Z, size = 39812, hashes = { sha256 = "96f5f6344709aa1572bbf631c640e4ebeeb519e08da902c39a001882f30ac258" } }] + +[[packages]] +name = "flash-attn-4" +version = "4.0.0b11" +sdist = { url = "https://files.pythonhosted.org/packages/a4/04/c72568525a15cf7c9d3c8b99eb7a02134dbff2dd829f52e68d57b4ee2ac5/flash_attn_4-4.0.0b11.tar.gz", upload-time = 2026-04-29T08:53:33Z, size = 301577, hashes = { sha256 = "b2ceede17eea2dfe9c62e8ddef454566702b119421bd098f61faa9aab4cd5885" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/6f/d4/f0729540f5888a03668b6dba797286ad91e2286a9579fcfd06073ab17b12/flash_attn_4-4.0.0b11-py3-none-any.whl", upload-time = 2026-04-29T08:53:30Z, size = 324067, hashes = { sha256 = "f028871f46a63d466d05762876506a12957147374b17f66a52376beed4238dc5" } }] + +[[packages]] +name = "flashinfer-python" +version = "0.6.16" +sdist = { url = "https://files.pythonhosted.org/packages/79/25/e3f7b6073f8a7c8c15cfeee39821f05a7d90d668823b91427dbde772e3bd/flashinfer_python-0.6.16.tar.gz", upload-time = 2026-07-31T08:11:39Z, size = 11145638, hashes = { sha256 = "0c89970ee42b0640d3dfd65ea4770710e21101ce2b43a09eda3e29cd1874fe48" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5b/86/af6ac4615a12a76441f1598c88feb4a0ec8d60f9281ba5c035beb3280a92/flashinfer_python-0.6.16-py3-none-any.whl", upload-time = 2026-07-31T08:11:36Z, size = 15927412, hashes = { sha256 = "059d629cf352dae2d2e17c9b632f1be7c12fd7feb4979d71cdffd96104219e53" } }] + +[[packages]] +name = "fonttools" +version = "4.67.0" +sdist = { url = "https://files.pythonhosted.org/packages/94/36/102e180f8f5dbaee88b26595b01ca8aa80bf4e62128d9aa94265b3996c96/fonttools-4.67.0.tar.gz", upload-time = 2026-10-14T13:20:28Z, size = 3750028, hashes = { sha256 = "3cb57e6600ca77c0b1729cf8adc23bc0652633a37f18cfa934d9c7bc3de25519" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/e0/ec9e4cc868c514deb02233aa1047a6aeb9350d3ee012862f58eec10ef834/fonttools-4.67.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-10-14T13:18:46Z, size = 5408233, hashes = { sha256 = "eb3c98cac93aac4b9f6e3ce2008325340b234cc9b0338ca6b513f31962a1e278" } }, + { url = "https://files.pythonhosted.org/packages/3d/61/4161946319472aaa9b897bd18ad5108a5b10f5ebaa503d921a001ac4fff9/fonttools-4.67.0-py3-none-any.whl", upload-time = 2026-10-14T13:20:26Z, size = 1213142, hashes = { sha256 = "4304f03ed7f4ba000a8dcc941ad854bfa52e2f3b6112b8f099b6f431cf98e701" } }, +] + +[[packages]] +name = "fqdn" +version = "1.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/02/01/248d44fbda9e78fa1a7b5a475194bef4c4a3e285db286419f3bb42f2efdf/fqdn-1.6.0.tar.gz", upload-time = 2026-09-28T05:43:35Z, size = 130737, hashes = { sha256 = "e39bf62e2a9481aa2cb780554fdfd944dd8ee5f230eb831684d539cbafed8de2" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/15/d5/a8f9149b97cced9e1f4bff92ff0b6206120e2c853ae774d7020d6ecd8fa8/fqdn-1.6.0-py3-none-any.whl", upload-time = 2026-09-28T05:43:33Z, size = 12569, hashes = { sha256 = "6c793c312ccfa29981e1135b3ef5e1277ebe639731a6b0f7350d90e96e63f0b4" } }] + +[[packages]] +name = "frozenlist" +version = "1.8.0" +sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", upload-time = 2025-10-06T05:38:17Z, size = 45875, hashes = { sha256 = "3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2025-10-06T05:36:09Z, size = 242411, hashes = { sha256 = "494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383" } }, + { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", upload-time = 2025-10-06T05:38:16Z, size = 13409, hashes = { sha256 = "0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d" } }, +] + +[[packages]] +name = "fsspec" +version = "2024.9.0" +sdist = { url = "https://files.pythonhosted.org/packages/62/7c/12b0943011daaaa9c35c2a2e22e5eb929ac90002f08f1259d69aedad84de/fsspec-2024.9.0.tar.gz", upload-time = 2024-09-04T15:06:57Z, size = 286206, hashes = { sha256 = "4b0afb90c2f21832df142f292649035d80b421f60a9e1c027802e5a0da2b04e8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1d/a0/6aaea0c2fbea2f89bfd5db25fb1e3481896a423002ebe4e55288907a97a3/fsspec-2024.9.0-py3-none-any.whl", upload-time = 2024-09-04T15:06:55Z, size = 179253, hashes = { sha256 = "a0947d552d8a6efa72cc2c730b12c41d043509156966cca4fb157b0f2a0c574b" } }] + +[[packages]] +name = "ftfy" +version = "6.3.1" +sdist = { url = "https://files.pythonhosted.org/packages/a5/d3/8650919bc3c7c6e90ee3fa7fd618bf373cbbe55dff043bd67353dbb20cd8/ftfy-6.3.1.tar.gz", upload-time = 2024-10-26T00:50:35Z, size = 308927, hashes = { sha256 = "9b3c3d90f84fb267fe64d375a07b7f8912d817cf86009ae134aa03e1819506ec" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ab/6e/81d47999aebc1b155f81eca4477a616a70f238a2549848c38983f3c22a82/ftfy-6.3.1-py3-none-any.whl", upload-time = 2024-10-26T00:50:33Z, size = 44821, hashes = { sha256 = "7c70eb532015cd2f9adb53f101fb6c7945988d023a085d127d1573dc49dd0083" } }] + +[[packages]] +name = "gitdb" +version = "4.0.12" +sdist = { url = "https://files.pythonhosted.org/packages/72/94/63b0fc47eb32792c7ba1fe1b694daec9a63620db1e313033d18140c2320a/gitdb-4.0.12.tar.gz", upload-time = 2025-01-02T07:20:46Z, size = 394684, hashes = { sha256 = "5ef71f855d191a3326fcfbc0d5da835f26b13fbcba60c32c21091c349ffdb571" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a0/61/5c78b91c3143ed5c14207f463aecfc8f9dbb5092fb2869baf37c273b2705/gitdb-4.0.12-py3-none-any.whl", upload-time = 2025-01-02T07:20:43Z, size = 62794, hashes = { sha256 = "67073e15955400952c6565cc3e707c554a4eea2e428946f7a4c162fab9bd9bcf" } }] + +[[packages]] +name = "gitpython" +version = "3.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/c0/ff/fee293f1ec3e1b64db6eb270e00964f29c086d769201474cedb8d1608930/gitpython-3.2.1.tar.gz", upload-time = 2026-10-14T12:20:20Z, size = 241688, hashes = { sha256 = "0f1229ec5c057bdabdeeda8bda4f17bda679ab33dbccc00f24e6a480553c8613" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/6b/50/2a923c4dc02522ff9567f07c67ed1deca6d5fa9474f4708168b8088dfa37/gitpython-3.2.1-py3-none-any.whl", upload-time = 2026-10-14T12:20:18Z, size = 231548, hashes = { sha256 = "d66b0832aa8755c1a84892937282df0befb16c97e5a64aeebd68be9c5e323f53" } }] + +[[packages]] +name = "graphviz" +version = "0.21" +sdist = { url = "https://files.pythonhosted.org/packages/f8/b3/3ac91e9be6b761a4b30d66ff165e54439dcd48b83f4e20d644867215f6ca/graphviz-0.21.tar.gz", upload-time = 2025-06-15T09:35:05Z, size = 200434, hashes = { sha256 = "20743e7183be82aaaa8ad6c93f8893c923bd6658a04c32ee115edb3c8a835f78" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/91/4c/e0ce1ef95d4000ebc1c11801f9b944fa5910ecc15b5e351865763d8657f8/graphviz-0.21-py3-none-any.whl", upload-time = 2025-06-15T09:35:04Z, size = 47300, hashes = { sha256 = "54f33de9f4f911d7e84e4191749cac8cc5653f815b06738c54db9a15ab8b1e42" } }] + +[[packages]] +name = "grpcio" +version = "1.78.0" +sdist = { url = "https://files.pythonhosted.org/packages/06/8a/3d098f35c143a89520e568e6539cc098fcd294495910e359889ce8741c84/grpcio-1.78.0.tar.gz", upload-time = 2026-02-06T09:57:18Z, size = 12852416, hashes = { sha256 = "7382b95189546f375c174f53a5fa873cef91c4b8005faa05cc5b3beea9c4f1c5" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/54/bf/f4a3b9693e35d25b24b0b39fa46d7d8a3c439e0a3036c3451764678fec20/grpcio-1.78.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-02-06T09:55:36Z, size = 6690766, hashes = { sha256 = "12a771591ae40bc65ba67048fa52ef4f0e6db8279e595fd349f9dfddeef571f9" } }] + +[[packages]] +name = "h11" +version = "0.16.0" +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", upload-time = 2025-04-24T03:35:25Z, size = 101250, hashes = { sha256 = "4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", upload-time = 2025-04-24T03:35:24Z, size = 37515, hashes = { sha256 = "63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86" } }] + +[[packages]] +name = "h5py" +version = "3.12.1" +sdist = { url = "https://files.pythonhosted.org/packages/cc/0c/5c2b0a88158682aeafb10c1c2b735df5bc31f165bfe192f2ee9f2a23b5f1/h5py-3.12.1.tar.gz", upload-time = 2024-09-26T16:41:39Z, size = 411457, hashes = { sha256 = "326d70b53d31baa61f00b8aa5f95c2fcb9621a3ee8365d770c551a13dbbcbfdf" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/fa/63/eeaacff417b393491beebabb8a3dc5342950409eb6d7b39d437289abdbae/h5py-3.12.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2024-09-26T16:40:39Z, size = 5413256, hashes = { sha256 = "5c4b41d1019322a5afc5082864dfd6359f8935ecd37c11ac0029be78c5d112c9" } }] + +[[packages]] +name = "hf-xet" +version = "1.4.3" +marker = "platform_machine == 'AMD64' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" +sdist = { url = "https://files.pythonhosted.org/packages/53/92/ec9ad04d0b5728dca387a45af7bc98fbb0d73b2118759f5f6038b61a57e8/hf_xet-1.4.3.tar.gz", upload-time = 2026-03-31T22:40:07Z, size = 670477, hashes = { sha256 = "8ddedb73c8c08928c793df2f3401ec26f95be7f7e516a7bee2fbb546f6676113" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/df/9a/a24b26dc8a65f0ecc0fe5be981a19e61e7ca963b85e062c083f3a9100529/hf_xet-1.4.3-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-03-31T22:39:42Z, size = 4212320, hashes = { sha256 = "fc360b70c815bf340ed56c7b8c63aacf11762a4b099b2fe2c9bd6d6068668c08" } }] + +[[packages]] +name = "httpcore" +version = "1.0.9" +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", upload-time = 2025-04-24T22:06:22Z, size = 85484, hashes = { sha256 = "6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", upload-time = 2025-04-24T22:06:20Z, size = 78784, hashes = { sha256 = "2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55" } }] + +[[packages]] +name = "httpx" +version = "0.28.1" +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", upload-time = 2024-12-06T15:37:23Z, size = 141406, hashes = { sha256 = "75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", upload-time = 2024-12-06T15:37:21Z, size = 73517, hashes = { sha256 = "d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad" } }] + +[[packages]] +name = "httpx-sse" +version = "0.4.3" +sdist = { url = "https://files.pythonhosted.org/packages/0f/4c/751061ffa58615a32c31b2d82e8482be8dd4a89154f003147acee90f2be9/httpx_sse-0.4.3.tar.gz", upload-time = 2025-10-10T21:48:22Z, size = 15943, hashes = { sha256 = "9b1ed0127459a66014aec3c56bebd93da3c1bc8bb6618c8082039a44889a755d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d2/fd/6668e5aec43ab844de6fc74927e155a3b37bf40d7c3790e49fc0406b6578/httpx_sse-0.4.3-py3-none-any.whl", upload-time = 2025-10-10T21:48:21Z, size = 8960, hashes = { sha256 = "0ac1c9fe3c0afad2e0ebb25a934a59f4c7823b60792691f779fad2c5568830fc" } }] + +[[packages]] +name = "huggingface-hub" +version = "1.16.1" +sdist = { url = "https://files.pythonhosted.org/packages/48/0f/ed994dbade67a54407c28cab96ef845e0e6d25500be56aca6394f8bfc9dd/huggingface_hub-1.16.1.tar.gz", upload-time = 2026-05-21T18:40:00Z, size = 792534, hashes = { sha256 = "7f1dc4c5ec21aed69be630ad0c3378616be16f3de1a47b141c0e812965d9c832" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/49/79/621a7dbb80c70974f73a597275351ebe03ce5bc65cb5f8f4acb5859252bc/huggingface_hub-1.16.1-py3-none-any.whl", upload-time = 2026-05-21T18:39:58Z, size = 668176, hashes = { sha256 = "64340de934b9ce37857ef85a82de72f5629e8a270f9119eabb12bf495eb53c22" } }] + +[[packages]] +name = "idna" +version = "3.17" +sdist = { url = "https://files.pythonhosted.org/packages/b9/28/99c51f664567218d824af024c0251650fb27e4ca066df188dab0769c5b91/idna-3.17.tar.gz", upload-time = 2026-05-28T14:32:38Z, size = 196048, hashes = { sha256 = "5eb0cb53bc467c12eadcf6de83163ad8527cec9416f44b9b61b19caedad2b87f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/de/a7/f76514cc40ad6234098ecdebda08732d75964776c51a42845b7da10649e2/idna-3.17-py3-none-any.whl", upload-time = 2026-05-28T14:32:37Z, size = 65316, hashes = { sha256 = "466e48829084efe2548012b855df21540b96f2e20e51bd124c851536556a592c" } }] + +[[packages]] +name = "immutabledict" +version = "4.3.1" +sdist = { url = "https://files.pythonhosted.org/packages/1d/e6/718471048fea0366c3e3d1df3acfd914ca66d571cdffcf6d37bbcd725708/immutabledict-4.3.1.tar.gz", upload-time = 2026-02-15T10:32:34Z, size = 7806, hashes = { sha256 = "f844a669106cfdc73f47b1a9da003782fb17dc955a54c80972e0d93d1c63c514" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a3/ce/f9018bf69ae91b273b6391a095e7c93fa5e1617f25b6ba81ad4b20c9df10/immutabledict-4.3.1-py3-none-any.whl", upload-time = 2026-02-15T10:32:33Z, size = 5000, hashes = { sha256 = "c9facdc0ff30fdb8e35bd16532026cac472a549e182c94fa201b51b25e4bf7bf" } }] + +[[packages]] +name = "importlib-metadata" +version = "8.5.0" +sdist = { url = "https://files.pythonhosted.org/packages/cd/12/33e59336dca5be0c398a7482335911a33aa0e20776128f038019f1a95f1b/importlib_metadata-8.5.0.tar.gz", upload-time = 2024-09-11T14:56:08Z, size = 55304, hashes = { sha256 = "71522656f0abace1d072b9e5481a48f07c138e00f079c38c8f883823f9c26bd7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a0/d9/a1e041c5e7caa9a05c925f4bdbdfb7f006d1f74996af53467bc394c97be7/importlib_metadata-8.5.0-py3-none-any.whl", upload-time = 2024-09-11T14:56:07Z, size = 26514, hashes = { sha256 = "45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b" } }] + +[[packages]] +name = "ipykernel" +version = "7.4.0" +sdist = { url = "https://files.pythonhosted.org/packages/7a/05/e5499c8b762387d83926bf0389e8fff888c9bf6e7af30566a8527bc12f4a/ipykernel-7.4.0.tar.gz", upload-time = 2026-09-29T16:33:11Z, size = 192731, hashes = { sha256 = "4330114d22b9b33575b2c7c68753fc8faabbbcfbc60b0cdff9f14dd4ce63742f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a5/f8/8b5c10c7f36ab5a3b5c4703669e5b14e44e98782b58e535dd30670e8799a/ipykernel-7.4.0-py3-none-any.whl", upload-time = 2026-09-29T16:33:09Z, size = 123184, hashes = { sha256 = "a6757f790ddc5a6006b813d82da1a9dbb65b3a00f2b6607df776418c6566ec1c" } }] + +[[packages]] +name = "ipython" +version = "9.13.0" +sdist = { url = "https://files.pythonhosted.org/packages/cd/c4/87cda5842cf5c31837c06ddb588e11c3c35d8ece89b7a0108c06b8c9b00a/ipython-9.13.0.tar.gz", upload-time = 2026-04-24T12:24:55Z, size = 4430549, hashes = { sha256 = "7e834b6afc99f020e3f05966ced34792f40267d64cb1ea9043886dab0dde5967" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b9/86/3060e8029b7cc505cce9a0137431dda81d0a3fde93a8f0f50ee0bf37a795/ipython-9.13.0-py3-none-any.whl", upload-time = 2026-04-24T12:24:53Z, size = 627274, hashes = { sha256 = "57f9d4639e20818d328d287c7b549af3d05f12486ea8f2e7f73e52a36ec4d201" } }] + +[[packages]] +name = "ipython-pygments-lexers" +version = "1.1.1" +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", upload-time = 2025-01-17T11:24:34Z, size = 8393, hashes = { sha256 = "09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", upload-time = 2025-01-17T11:24:33Z, size = 8074, hashes = { sha256 = "a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c" } }] + +[[packages]] +name = "isoduration" +version = "20.11.0" +sdist = { url = "https://files.pythonhosted.org/packages/7c/1a/3c8edc664e06e6bd06cce40c6b22da5f1429aa4224d0c590f3be21c91ead/isoduration-20.11.0.tar.gz", upload-time = 2020-11-01T11:00:00Z, size = 11649, hashes = { sha256 = "ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7b/55/e5326141505c5d5e34c5e0935d2908a74e4561eca44108fbfb9c13d2911a/isoduration-20.11.0-py3-none-any.whl", upload-time = 2020-11-01T10:59:58Z, size = 11321, hashes = { sha256 = "b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042" } }] + +[[packages]] +name = "jedi" +version = "0.19.2" +sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", upload-time = 2024-11-11T01:41:42Z, size = 1231287, hashes = { sha256 = "4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", upload-time = 2024-11-11T01:41:40Z, size = 1572278, hashes = { sha256 = "a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9" } }] + +[[packages]] +name = "jinja2" +version = "3.1.6" +wheels = [{ url = "https://download.pytorch.org/whl/jinja2-3.1.6-py3-none-any.whl", upload-time = 2025-10-14T18:38:59Z, hashes = { sha256 = "85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67" } }] + +[[packages]] +name = "jiter" +version = "0.13.0" +sdist = { url = "https://files.pythonhosted.org/packages/0d/5e/4ec91646aee381d01cdb9974e30882c9cd3b8c5d1079d6b5ff4af522439a/jiter-0.13.0.tar.gz", upload-time = 2026-02-02T12:37:56Z, size = 164847, hashes = { sha256 = "f2839f9c2c7e2dffc1bc5929a510e14ce0a946be9365fd1219e7ef342dae14f4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f8/4c/09b93e30e984a187bc8aaa3510e1ec8dcbdcd71ca05d2f56aac0492453aa/jiter-0.13.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-02-02T12:36:06Z, size = 360735, hashes = { sha256 = "bdaba7d87e66f26a2c45d8cbadcbfc4bf7884182317907baf39cfe9775bb4d93" } }] + +[[packages]] +name = "joblib" +version = "1.5.3" +sdist = { url = "https://files.pythonhosted.org/packages/41/f2/d34e8b3a08a9cc79a50b2208a93dce981fe615b64d5a4d4abee421d898df/joblib-1.5.3.tar.gz", upload-time = 2025-12-15T08:41:46Z, size = 331603, hashes = { sha256 = "8561a3269e6801106863fd0d6d84bb737be9e7631e33aaed3fb9ce5953688da3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7b/91/984aca2ec129e2757d1e4e3c81c3fcda9d0f85b74670a094cc443d9ee949/joblib-1.5.3-py3-none-any.whl", upload-time = 2025-12-15T08:41:44Z, size = 309071, hashes = { sha256 = "5fc3c5039fc5ca8c0276333a188bbd59d6b7ab37fe6632daa76bc7f9ec18e713" } }] + +[[packages]] +name = "json5" +version = "0.17.3" +sdist = { url = "https://files.pythonhosted.org/packages/16/1f/58a4d7ee466f81bc3c7337036380fc6d49de3afb7855d74f8121b1e89b32/json5-0.17.3.tar.gz", upload-time = 2026-10-09T21:19:28Z, size = 54234, hashes = { sha256 = "8d0278ad34ebaa9c3af76d9519274811830224a2d1cd5af156dbd067f461b8a4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ae/39/e689b616c4279a821d5842a8a85c1874540f8d58e35028df93f2182120c2/json5-0.17.3-py3-none-any.whl", upload-time = 2026-10-09T21:19:27Z, size = 34809, hashes = { sha256 = "2c8b22a893c35cd6a3c5ccbf1dd1c7d02c25dc1b5897fea658f9bf08c2e05f9a" } }] + +[[packages]] +name = "jsonpointer" +version = "3.1.1" +sdist = { url = "https://files.pythonhosted.org/packages/18/c7/af399a2e7a67fd18d63c40c5e62d3af4e67b836a2107468b6a5ea24c4304/jsonpointer-3.1.1.tar.gz", upload-time = 2026-03-23T22:32:32Z, size = 9068, hashes = { sha256 = "0b801c7db33a904024f6004d526dcc53bbb8a4a0f4e32bfd10beadf60adf1900" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9e/6a/a83720e953b1682d2d109d3c2dbb0bc9bf28cc1cbc205be4ef4be5da709d/jsonpointer-3.1.1-py3-none-any.whl", upload-time = 2026-03-23T22:32:31Z, size = 7659, hashes = { sha256 = "8ff8b95779d071ba472cf5bc913028df06031797532f08a7d5b602d8b2a488ca" } }] + +[[packages]] +name = "jsonschema" +version = "4.23.0" +sdist = { url = "https://files.pythonhosted.org/packages/38/2e/03362ee4034a4c917f697890ccd4aec0800ccf9ded7f511971c75451deec/jsonschema-4.23.0.tar.gz", upload-time = 2024-07-08T18:40:05Z, size = 325778, hashes = { sha256 = "d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/69/4a/4f9dbeb84e8850557c02365a0eee0649abe5eb1d84af92a25731c6c0f922/jsonschema-4.23.0-py3-none-any.whl", upload-time = 2024-07-08T18:40:00Z, size = 88462, hashes = { sha256 = "fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566" } }] + +[[packages]] +name = "jsonschema-specifications" +version = "2025.9.1" +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", upload-time = 2025-09-08T01:34:59Z, size = 32855, hashes = { sha256 = "b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", upload-time = 2025-09-08T01:34:57Z, size = 18437, hashes = { sha256 = "98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe" } }] + +[[packages]] +name = "jupyter-builder" +version = "1.2.3" +sdist = { url = "https://files.pythonhosted.org/packages/75/3e/56f593e6a664cd14d441724654ce8243f3cac7d3e45867cf084749c8bc75/jupyter_builder-1.2.3.tar.gz", upload-time = 2026-09-04T18:54:09Z, size = 1024218, hashes = { sha256 = "01aba6794eb9b19e0e29ae21137ca60ba4135c70347d4b9f664a586822b8c809" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/84/aa/be79e87c50698673f196d0633fc1664607da2289f9688d1de7a1c9db9e71/jupyter_builder-1.2.3-py3-none-any.whl", upload-time = 2026-09-04T18:54:07Z, size = 947541, hashes = { sha256 = "c5ea5a7190c2a7b082494abade98eece1b2b5bd5dbd7d610606cbcd10a1d08b3" } }] + +[[packages]] +name = "jupyter-client" +version = "8.10.0" +sdist = { url = "https://files.pythonhosted.org/packages/c5/2a/906772148a06e48885039e0250c340b770a55bbf37b08d6ee0449df369c3/jupyter_client-8.10.0.tar.gz", upload-time = 2026-08-28T12:17:10Z, size = 360653, hashes = { sha256 = "9f7116294dca55f1785be880057d44544db9b1567718d92cb33c58886afb9497" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0f/88/7c548de1f6c2ade7c931a3282da73f9274fa6a1531091be682f89c85efb9/jupyter_client-8.10.0-py3-none-any.whl", upload-time = 2026-08-28T12:17:09Z, size = 110184, hashes = { sha256 = "5f73f24f22fa25192cfff6b23c051932a2473a797b05734aff495b392103e14e" } }] + +[[packages]] +name = "jupyter-core" +version = "5.9.1" +sdist = { url = "https://files.pythonhosted.org/packages/02/49/9d1284d0dc65e2c757b74c6687b6d319b02f822ad039e5c512df9194d9dd/jupyter_core-5.9.1.tar.gz", upload-time = 2025-10-16T19:19:18Z, size = 89814, hashes = { sha256 = "4d09aaff303b9566c3ce657f580bd089ff5c91f5f89cf7d8846c3cdf465b5508" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e7/e7/80988e32bf6f73919a113473a604f5a8f09094de312b9d52b79c2df7612b/jupyter_core-5.9.1-py3-none-any.whl", upload-time = 2025-10-16T19:19:16Z, size = 29032, hashes = { sha256 = "ebf87fdc6073d142e114c72c9e29a9d7ca03fad818c5d300ce2adc1fb0743407" } }] + +[[packages]] +name = "jupyter-events" +version = "0.12.1" +sdist = { url = "https://files.pythonhosted.org/packages/18/f8/475c4241b2b75af0deaae453ed003c6c851766dbc44d332d8baf245dc931/jupyter_events-0.12.1.tar.gz", upload-time = 2026-04-20T23:17:50Z, size = 62854, hashes = { sha256 = "faff25f77218335752f35f23c5fe6e4a392a7bd99a5939ccb9b8fbf594636cf3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/eb/6c/6fcde0c8f616ed360ffd3587f7db9e225a7e62b583a04494d2f069cf64ea/jupyter_events-0.12.1-py3-none-any.whl", upload-time = 2026-04-20T23:17:48Z, size = 19512, hashes = { sha256 = "c366585253f537a627da52fa7ca7410c5b5301fe893f511e7b077c2d93ec8bcf" } }] + +[[packages]] +name = "jupyter-lsp" +version = "2.3.1" +sdist = { url = "https://files.pythonhosted.org/packages/36/ff/1e4a61f5170a9a1d978f3ac3872449de6c01fc71eaf89657824c878b1549/jupyter_lsp-2.3.1.tar.gz", upload-time = 2026-04-02T08:10:06Z, size = 55677, hashes = { sha256 = "fdf8a4aa7d85813976d6e29e95e6a2c8f752701f926f2715305249a3829805a6" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/23/e8/9d61dcbd1dce8ef418f06befd4ac084b4720429c26b0b1222bc218685eff/jupyter_lsp-2.3.1-py3-none-any.whl", upload-time = 2026-04-02T08:10:01Z, size = 77513, hashes = { sha256 = "71b954d834e85ff3096400554f2eefaf7fe37053036f9a782b0f7c5e42dadb81" } }] + +[[packages]] +name = "jupyter-server" +version = "2.21.1" +sdist = { url = "https://files.pythonhosted.org/packages/65/3d/3c9f8bce5d5448107bd285cd80185e76c9c871d076b580dfd90997e52904/jupyter_server-2.21.1.tar.gz", upload-time = 2026-09-15T16:00:07Z, size = 761651, hashes = { sha256 = "a8960aa29263f6041283e97d4756b099fb49b767baab6371891ecb1bd40a63df" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1d/39/91bc08650cc8e3efeb7a83c25e20ebddcc9b70d28b4eb6f51a4fb55da7a4/jupyter_server-2.21.1-py3-none-any.whl", upload-time = 2026-09-15T16:00:05Z, size = 394641, hashes = { sha256 = "2a6467606af7dbae2e7e31640030025969e15db6a649eae334af90415dc71dca" } }] + +[[packages]] +name = "jupyter-server-terminals" +version = "0.5.4" +sdist = { url = "https://files.pythonhosted.org/packages/f4/a7/bcd0a9b0cbba88986fe944aaaf91bfda603e5a50bda8ed15123f381a3b2f/jupyter_server_terminals-0.5.4.tar.gz", upload-time = 2026-01-14T16:53:20Z, size = 31770, hashes = { sha256 = "bbda128ed41d0be9020349f9f1f2a4ab9952a73ed5f5ac9f1419794761fb87f5" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d1/2d/6674563f71c6320841fc300911a55143925112a72a883e2ca71fba4c618d/jupyter_server_terminals-0.5.4-py3-none-any.whl", upload-time = 2026-01-14T16:53:18Z, size = 13704, hashes = { sha256 = "55be353fc74a80bc7f3b20e6be50a55a61cd525626f578dcb66a5708e2007d14" } }] + +[[packages]] +name = "jupyterlab" +version = "4.7.0a2" +sdist = { url = "https://files.pythonhosted.org/packages/71/4f/ec5adb412b43b755497659c4e831a705c86a92b1085daca60ea0cffb686e/jupyterlab-4.7.0a2.tar.gz", upload-time = 2026-09-21T16:59:16Z, size = 28575066, hashes = { sha256 = "1e79f8a46b97fe27946fa7b3149bb0369622bcee687e2c753717c6ccecfae7d1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e5/6f/870f5ab69cd3f51cbb014bdd47af5764f244d77ef9aedba33a2bd6c44e59/jupyterlab-4.7.0a2-py3-none-any.whl", upload-time = 2026-09-21T16:59:12Z, size = 17500759, hashes = { sha256 = "1cc31e669cc0cf07766bb222f5e7ebb77e0dc3431c3167b96ec33454ec56748b" } }] + +[[packages]] +name = "jupyterlab-pygments" +version = "0.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/90/51/9187be60d989df97f5f0aba133fa54e7300f17616e065d1ada7d7646b6d6/jupyterlab_pygments-0.3.0.tar.gz", upload-time = 2023-11-23T09:26:37Z, size = 512900, hashes = { sha256 = "721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b1/dd/ead9d8ea85bf202d90cc513b533f9c363121c7792674f78e0d8a854b63b4/jupyterlab_pygments-0.3.0-py3-none-any.whl", upload-time = 2023-11-23T09:26:34Z, size = 15884, hashes = { sha256 = "841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780" } }] + +[[packages]] +name = "jupyterlab-server" +version = "2.28.1" +sdist = { url = "https://files.pythonhosted.org/packages/16/c5/08946a10b81bd64408d8b78cb352e17fe52d3ee11c2aef00a0f06e506938/jupyterlab_server-2.28.1.tar.gz", upload-time = 2026-09-15T19:22:09Z, size = 78141, hashes = { sha256 = "0c3c2418d51021ce280916e63dfe4cba8386b4e2787be5c25433c98f560ddb31" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/23/d3/996332fe24f3c2458b9c353b998570dfa2631763e9a8674ba3f94c0877d0/jupyterlab_server-2.28.1-py3-none-any.whl", upload-time = 2026-09-15T19:22:08Z, size = 60197, hashes = { sha256 = "4bd36c7c11d872e15cefa4951e12380a47e6901687165332dd50a007cb367ad9" } }] + +[[packages]] +name = "kiwisolver" +version = "1.5.1" +sdist = { url = "https://files.pythonhosted.org/packages/ba/07/bd78e6a8fae171ea041ef5bba3ed21a003522fa088834b069b1909981f30/kiwisolver-1.5.1.tar.gz", upload-time = 2026-08-28T10:28:27Z, size = 104395, hashes = { sha256 = "f1303ef2eec81262a4b708c3e858afe58d7c75ad91c1c05266eda7673369859a" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/fc/f4/dadfec469313c7f428efa7e84b4aba9732f813c13ea7131a24b7b008ef57/kiwisolver-1.5.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-08-28T10:25:31Z, size = 1477929, hashes = { sha256 = "34633ecf50d16187ab8e5528b7a2530f2feb4e23f300db4672538b51cfc5cd38" } }] + +[[packages]] +name = "lark" +version = "1.3.1" +sdist = { url = "https://files.pythonhosted.org/packages/da/34/28fff3ab31ccff1fd4f6c7c7b0ceb2b6968d8ea4950663eadcb5720591a0/lark-1.3.1.tar.gz", upload-time = 2025-10-27T18:25:56Z, size = 382732, hashes = { sha256 = "b426a7a6d6d53189d318f2b6236ab5d6429eaf09259f1ca33eb716eed10d2905" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl", upload-time = 2025-10-27T18:25:54Z, size = 113151, hashes = { sha256 = "c629b661023a014c37da873b4ff58a817398d12635d3bbb2c5a03be7fe5d1e12" } }] + +[[packages]] +name = "lazy-loader" +version = "0.6" +sdist = { url = "https://files.pythonhosted.org/packages/19/8c/0f2ff2a8b7513e68871a74740c17a504b0488c679b379e6445ebb7bd78dc/lazy_loader-0.6.tar.gz", upload-time = 2026-09-21T21:31:32Z, size = 18438, hashes = { sha256 = "2f4b7824d6401958639008a0cae20c776b61dff619accd6890693e2de8260167" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/23/93/4e45e37f26c820216704b36b8e67cc55c490a7abd287a78a26a2c0e21386/lazy_loader-0.6-py3-none-any.whl", upload-time = 2026-09-21T21:31:31Z, size = 8791, hashes = { sha256 = "77253be3391b06124a0e16105bd663b6c54470af1a9ca8e1cf026f38d58ed056" } }] + +[[packages]] +name = "librosa" +version = "1.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/8e/c1/ce66b20953b7370421dd13d22b4e04e401346c824ceacb9f4e722eec84dc/librosa-1.0.0.tar.gz", upload-time = 2026-08-11T15:37:37Z, size = 377965, hashes = { sha256 = "73ed480d4022e436e85dfa6f6b06ff38a259b9210039ac99939cd64854b61a57" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/96/14/0b2e4cc8017796dc8f69de740708601832c1e8d5377166eedb4db0a92264/librosa-1.0.0-py3-none-any.whl", upload-time = 2026-08-11T15:37:35Z, size = 294628, hashes = { sha256 = "5910a6c0e1b2e494b92758c1615a7acbd0515a2315e138927ba2982f2af88857" } }] + +[[packages]] +name = "llguidance" +version = "0.7.29" +sdist = { url = "https://files.pythonhosted.org/packages/fb/3b/c3ced46dd10cffa49fad941e84118a1e8279cd3261769b2238eafc4df3c1/llguidance-0.7.29.tar.gz", upload-time = 2025-06-06T01:32:41Z, size = 1041807, hashes = { sha256 = "d1aa68a54f9496d36750018e7edad3bf624ee2fbcf671a7483883790d798c4fe" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9f/c8/59504a4e9ba60243261708f345c85af9d5b4c46220334b575f6f744c4622/llguidance-0.7.29-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-06-06T01:32:35Z, size = 15045686, hashes = { sha256 = "17fd439957d6ca5f459d0dec755a2d040c2dc946ed7e3c332b469ef6861292f8" } }] + +[[packages]] +name = "llist" +version = "0.7.1" +sdist = { url = "https://files.pythonhosted.org/packages/fe/27/74fd16961c183bee40ba510d42b1b2c90f627713d26bdda09e8d7594ef37/llist-0.7.1.tar.gz", upload-time = 2021-04-26T23:37:00Z, size = 42979, hashes = { sha256 = "6f73a120136897a0bce61c202188f4f3891d9f70aa906d21fc1ee1cf43659eca" } } + +[[packages]] +name = "llvmlite" +version = "0.50.0" +sdist = { url = "https://files.pythonhosted.org/packages/11/c5/907cec40688a34eb489cded74d555e1ee4af8cf49d83e03dba2c2d4cfe27/llvmlite-0.50.0.tar.gz", upload-time = 2026-09-29T18:44:46Z, size = 194522, hashes = { sha256 = "f2a2cd6ec9ffcc1b7147dea0d7a49efebf17a2b434e0c2844fe175999d571eb4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/4c/72/22b6449e15bec4cc86c62b659e6c625ab777d01e87aaec717ecef440f87a/llvmlite-0.50.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-09-29T18:43:04Z, size = 59696588, hashes = { sha256 = "d501e5103076b9a14be885d2574dc2f6793171aa54a853d1244e011d476f1399" } }] + +[[packages]] +name = "lxml" +version = "6.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/28/30/9abc9e34c657c33834eaf6cd02124c61bdf5944d802aa48e69be8da3585d/lxml-6.1.0.tar.gz", upload-time = 2026-04-18T04:32:51Z, size = 4197006, hashes = { sha256 = "bfd57d8008c4965709a919c3e9a98f76c2c7cb319086b3d26858250620023b13" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/7c/e08a970727d556caa040a44773c7b7e3ad0f0d73dedc863543e9a8b931f2/lxml-6.1.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-04-18T04:32:58Z, size = 5093820, hashes = { sha256 = "9147d8e386ec3b82c3b15d88927f734f565b0aaadef7def562b853adca45784a" } }, + { url = "https://files.pythonhosted.org/packages/31/ba/3c13d3fc24b7cacf675f808a3a1baabf43a30d0cd24c98f94548e9aa58eb/lxml-6.1.0-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-18T04:33:06Z, size = 5240445, hashes = { sha256 = "bc783ee3147e60a25aa0445ea82b3e8aabb83b240f2b95d32cb75587ff781814" } }, +] + +[[packages]] +name = "markdown-it-py" +version = "4.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", upload-time = 2025-08-11T12:57:52Z, size = 73070, hashes = { sha256 = "cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", upload-time = 2025-08-11T12:57:51Z, size = 87321, hashes = { sha256 = "87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147" } }] + +[[packages]] +name = "markupsafe" +version = "3.0.3" +wheels = [{ url = "https://download.pytorch.org/whl/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-27T13:54:35Z, hashes = { sha256 = "d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d" } }] + +[[packages]] +name = "matplotlib" +version = "3.11.2" +sdist = { url = "https://files.pythonhosted.org/packages/e7/c8/9aa712a0afb882649424dd8de8ad9aa6235e796e84c6052e8f6dc1598d0d/matplotlib-3.11.2.tar.gz", upload-time = 2026-09-11T19:05:31Z, size = 32660610, hashes = { sha256 = "cec596316640f2b394b8f0daa0ea61a8eae82d017b620b9f202befb972a59ea4" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b8/90/2b3fd67ee273163faeda6d514be70b5596eaa0fd77b60ffc294ad0b34f5f/matplotlib-3.11.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-09-11T19:03:25Z, size = 9860353, hashes = { sha256 = "df4f7784aca81a94f254c0a2767d592ee25f407e488f5fa7203e51093fb6ca27" } }] + +[[packages]] +name = "matplotlib-inline" +version = "0.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/c7/74/97e72a36efd4ae2bccb3463284300f8953f199b5ffbc04cbbb0ec78f74b1/matplotlib_inline-0.2.1.tar.gz", upload-time = 2025-10-23T09:00:22Z, size = 8110, hashes = { sha256 = "e1ee949c340d771fc39e241ea75683deb94762c8fa5f2927ec57c83c4dffa9fe" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/af/33/ee4519fa02ed11a94aef9559552f3b17bb863f2ecfe1a35dc7f548cde231/matplotlib_inline-0.2.1-py3-none-any.whl", upload-time = 2025-10-23T09:00:20Z, size = 9516, hashes = { sha256 = "d56ce5156ba6085e00a9d54fead6ed29a9c47e215cd1bba2e976ef39f5710a76" } }] + +[[packages]] +name = "mcp" +version = "1.28.1" +sdist = { url = "https://files.pythonhosted.org/packages/6e/77/9450b8f251a13affb6281997d0523c4615f8a8b35d0b21ff30db3a5aac9d/mcp-1.28.1.tar.gz", upload-time = 2026-06-26T12:57:29Z, size = 638501, hashes = { sha256 = "d51e36a5f5644faea4f85ea649bfffa6bc6c26770d42798ad6a3de3d2ba69683" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e2/5e/d118fce19f87a2e7d8101c35c8ae0ec289098a4df0ff244cec23e415aca0/mcp-1.28.1-py3-none-any.whl", upload-time = 2026-06-26T12:57:27Z, size = 222620, hashes = { sha256 = "2726bca5e7193f61c5dde8b12500a6de2d9acf6d1a1c0be9e8c2e706437991df" } }] + +[[packages]] +name = "mdurl" +version = "0.1.2" +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", upload-time = 2022-08-14T12:40:10Z, size = 8729, hashes = { sha256 = "bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", upload-time = 2022-08-14T12:40:09Z, size = 9979, hashes = { sha256 = "84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8" } }] + +[[packages]] +name = "meson" +version = "1.12.1" +sdist = { url = "https://files.pythonhosted.org/packages/f9/c9/8c9983f4f3d9c4e22fd76bcf8cd053e4472aefae45fd044669b6daa34b53/meson-1.12.1.tar.gz", upload-time = 2026-09-22T22:58:28Z, size = 2524665, hashes = { sha256 = "ab0a6ca09f8ef70c564c8241fb5a23957886a0b53fb58412b5e07eaf07dba743" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/57/99/36cd25f9598eef70db97577440a70a360af505f6f01c2338a18d1556079c/meson-1.12.1-py3-none-any.whl", upload-time = 2026-09-22T22:58:26Z, size = 1108668, hashes = { sha256 = "930bc7542cbd9f57009e182fd014eba48cf1a0180a7b9006d2d32d8f168d8b02" } }] + +[[packages]] +name = "mistral-common" +version = "1.12.0" +sdist = { url = "https://files.pythonhosted.org/packages/45/ee/e7860b0c9919a74fe43664f0bf19508df15243a27825aebc500b6c516d3b/mistral_common-1.12.0.tar.gz", upload-time = 2026-09-22T15:17:56Z, size = 6416138, hashes = { sha256 = "d0f150926733cf422d4750ca19b47568df1f714557c9054a432b866f1f30bf52" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c0/78/2881bae14f5d79c6d4626439e74f1bc1591d0f10a9eb7eea5a408ecdb877/mistral_common-1.12.0-py3-none-any.whl", upload-time = 2026-09-22T15:17:53Z, size = 6580267, hashes = { sha256 = "fa4504b66c30c0201ae4578c0340c5ee2abd22151c271532f62e373b985a53cf" } }] + +[[packages]] +name = "mistune" +version = "3.3.4" +sdist = { url = "https://files.pythonhosted.org/packages/7b/92/328a294a6de83bacb95bed01f04e0eaff4e3616ee359fc821a5dfc539b02/mistune-3.3.4.tar.gz", upload-time = 2026-07-22T05:22:30Z, size = 121426, hashes = { sha256 = "58b5c96d6fcb61190dfe5fae498d2b2065f99cf61e9649418fd54cf1ada86dfe" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/77/e4/288365afae98953bc01de09f686f40d8ee84578135aa7767d5d4e60b5278/mistune-3.3.4-py3-none-any.whl", upload-time = 2026-07-22T05:22:29Z, size = 66862, hashes = { sha256 = "ee015381e955e370962968befe1d729ab60fafb6a715ac6751763fbce38c8d4a" } }] + +[[packages]] +name = "mpi4py" +version = "4.1.2" +sdist = { url = "https://files.pythonhosted.org/packages/75/83/231445bbcf7ef10864746c244ff2d82000011449b79275642c5d4ed8c8f4/mpi4py-4.1.2.tar.gz", upload-time = 2026-05-16T10:35:23Z, size = 501709, hashes = { sha256 = "56860286dc45f20e8821e93cb06669e30462348bf866f685553fa4b712d58d02" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/0a/1da7f403e0d8ce0e26d541f7538302cec00cf5b0a98a7a52b929f938a25c/mpi4py-4.1.2-cp310-abi3-manylinux1_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2026-05-16T10:34:00Z, size = 1327130, hashes = { sha256 = "2ef63b2e3083e6062fd90e4de8c4e3acbf81e0772406e0226eb8dde6a48cab8e" } }, + { url = "https://files.pythonhosted.org/packages/9f/2b/1e48c4c5f9acbdca8dd28beeba9123dde140cd2ca520f8e3a3cf22faeeaa/mpi4py-4.1.2-cp312-cp312-manylinux1_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2026-05-16T10:34:28Z, size = 1358844, hashes = { sha256 = "00f4cce8999d19f35243c3442ea22debbe3336f69c309cd5d3176df4e51c717a" } }, +] + +[[packages]] +name = "mpmath" +version = "1.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", upload-time = 2023-03-07T16:47:11Z, size = 508106, hashes = { sha256 = "7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", upload-time = 2023-03-07T16:47:09Z, size = 536198, hashes = { sha256 = "a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c" } }] + +[[packages]] +name = "msgpack" +version = "1.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/31/f9/c0a1c127f9049db9155afc316952ea571720dd01833ff5e4d7e8e6352dbb/msgpack-1.2.1.tar.gz", upload-time = 2026-06-18T16:13:52Z, size = 183960, hashes = { sha256 = "04c721c2c7448767e9e3f2520a475663d8ee0f09c31890f6d2bd70fd636a9647" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/6a/fd/6adabd4f6d5e686f97dd02ce7fce3fe4cf672cbac36b8f67ff4040e8ad8b/msgpack-1.2.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-06-18T16:13:01Z, size = 419989, hashes = { sha256 = "020e881a764b20d8d7ca1a54fc01b8175519d108e3c3f194fddc200bda95951a" } }] + +[[packages]] +name = "msgspec" +version = "0.21.1" +sdist = { url = "https://files.pythonhosted.org/packages/e3/60/f79b9b013a16fa3a58350c9295ddc6789f2e335f36ea61ed10a21b215364/msgspec-0.21.1.tar.gz", upload-time = 2026-04-12T21:44:50Z, size = 319193, hashes = { sha256 = "2313508e394b0d208f8f56892ca9b2799e2561329de9763b19619595a6c0f72c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b5/d1/d4cd9fe89c7d400d7a18f86ccc94daa3f0927f53558846fcb60791dce5d6/msgspec-0.21.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-12T21:44:11Z, size = 225025, hashes = { sha256 = "21995e74b5c598c2e004110ad66ec7f1b8c20bf2bcf3b2de8fd9a3094422d3ff" } }] + +[[packages]] +name = "multidict" +version = "6.7.1" +sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", upload-time = 2026-01-26T02:46:45Z, size = 102010, hashes = { sha256 = "ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-01-26T02:44:03Z, size = 256322, hashes = { sha256 = "bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961" } }, + { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", upload-time = 2026-01-26T02:46:44Z, size = 12319, hashes = { sha256 = "55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56" } }, +] + +[[packages]] +name = "multiprocess" +version = "0.70.16" +sdist = { url = "https://files.pythonhosted.org/packages/b5/ae/04f39c5d0d0def03247c2893d6f2b83c136bf3320a2154d7b8858f2ba72d/multiprocess-0.70.16.tar.gz", upload-time = 2024-01-28T18:52:34Z, size = 1772603, hashes = { sha256 = "161af703d4652a0e1410be6abccecde4a7ddffd19341be0a7011b94aeb171ac1" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bc/f7/7ec7fddc92e50714ea3745631f79bd9c96424cb2702632521028e57d3a36/multiprocess-0.70.16-py310-none-any.whl", upload-time = 2024-01-28T18:52:26Z, size = 134824, hashes = { sha256 = "c4a9944c67bd49f823687463660a2d6daae94c289adff97e0f9d696ba6371d02" } }, + { url = "https://files.pythonhosted.org/packages/50/15/b56e50e8debaf439f44befec5b2af11db85f6e0f344c3113ae0be0593a91/multiprocess-0.70.16-py311-none-any.whl", upload-time = 2024-01-28T18:52:28Z, size = 143519, hashes = { sha256 = "af4cabb0dac72abfb1e794fa7855c325fd2b55a10a44628a3c1ad3311c04127a" } }, + { url = "https://files.pythonhosted.org/packages/0a/7d/a988f258104dcd2ccf1ed40fdc97e26c4ac351eeaf81d76e266c52d84e2f/multiprocess-0.70.16-py312-none-any.whl", upload-time = 2024-01-28T18:52:29Z, size = 146741, hashes = { sha256 = "fc0544c531920dde3b00c29863377f87e1632601092ea2daca74e4beb40faa2e" } }, + { url = "https://files.pythonhosted.org/packages/ea/89/38df130f2c799090c978b366cfdf5b96d08de5b29a4a293df7f7429fa50b/multiprocess-0.70.16-py38-none-any.whl", upload-time = 2024-01-28T18:52:30Z, size = 132628, hashes = { sha256 = "a71d82033454891091a226dfc319d0cfa8019a4e888ef9ca910372a446de4435" } }, + { url = "https://files.pythonhosted.org/packages/da/d9/f7f9379981e39b8c2511c9e0326d212accacb82f12fbfdc1aa2ce2a7b2b6/multiprocess-0.70.16-py39-none-any.whl", upload-time = 2024-01-28T18:52:31Z, size = 133351, hashes = { sha256 = "a0bafd3ae1b732eac64be2e72038231c1ba97724b60b09400d68f229fcc2fbf3" } }, +] + +[[packages]] +name = "narwhals" +version = "2.27.1" +sdist = { url = "https://files.pythonhosted.org/packages/bf/21/f64d6b2dbea7bf3f8c38cdc786dcc6ef012ca3d173ad208c782c9a7bedf6/narwhals-2.27.1.tar.gz", upload-time = 2026-10-10T06:52:18Z, size = 735013, hashes = { sha256 = "aed93076a3ea42d9c32c88e4eb5ea422a21937011cbe1f480f9572a523c82094" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d1/89/5d4c86da1130d9059681e5b6cd7645df5c10279a6a079c5c37dcb2cc6f3f/narwhals-2.27.1-py3-none-any.whl", upload-time = 2026-10-10T06:52:16Z, size = 483211, hashes = { sha256 = "d057df13f5852b8e157596e82eb5e955fad267425df5e420e0ee9863da483b31" } }] + +[[packages]] +name = "nbclient" +version = "0.11.0" +sdist = { url = "https://files.pythonhosted.org/packages/28/a5/b3bae4b590c0cbcada2c63a34f7580024e834a8ba213e949a2f906705787/nbclient-0.11.0.tar.gz", upload-time = 2026-06-05T07:52:41Z, size = 62535, hashes = { sha256 = "04a134a5b087f2c5887f228aca155db50169b8cd9334dee6942c8e927e56081a" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/36/c9/94d73e5a01c5b926c3fa2496e97d7a8dc28ed5a77c0b2ed712f1a62e6694/nbclient-0.11.0-py3-none-any.whl", upload-time = 2026-06-05T07:52:40Z, size = 25288, hashes = { sha256 = "ef7fa0d59d6e1d41103933d8a445a18d5de860ca6b613b87b8574accdb3c2895" } }] + +[[packages]] +name = "nbconvert" +version = "7.17.2" +sdist = { url = "https://files.pythonhosted.org/packages/53/6a/252c7620305a9661205aed7a2a4b3592f5207bfca56ad11b7dea2c5ec2f6/nbconvert-7.17.2.tar.gz", upload-time = 2026-10-12T09:11:19Z, size = 865989, hashes = { sha256 = "344a218e8595117ce37396ed025d994f146d076226ebac59255a2fa085ab24d8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/81/fd/a8d457af68848a8e5c12dd1d84ff35c415db471af78280e0703db4efbb12/nbconvert-7.17.2-py3-none-any.whl", upload-time = 2026-10-12T09:11:17Z, size = 262094, hashes = { sha256 = "6a143c11c00bf831604da4b1be4347d36ea52367057eb920135d69bc2862fed2" } }] + +[[packages]] +name = "nbformat" +version = "5.11.1" +sdist = { url = "https://files.pythonhosted.org/packages/31/72/b3446efab8756e7df4b8ec587f8e611cb5a7249e4323db480802f1d3be04/nbformat-5.11.1.tar.gz", upload-time = 2026-08-17T08:10:51Z, size = 147775, hashes = { sha256 = "32d4521c68c6e7d5b29c76defaeed9f42ea733142b9b19f88277ce10390b9c4d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1a/69/ee613f74085ca7103f79cd08d579c4f3177d1d26e5d3d9528d2d6536a707/nbformat-5.11.1-py3-none-any.whl", upload-time = 2026-08-17T08:10:50Z, size = 79849, hashes = { sha256 = "cc6698fa75f4fab8755ead786317815f13a6fee3b53311c0abb1a8b51d52f7ec" } }] + +[[packages]] +name = "nccl4py" +version = "0.3.1.post1" +wheels = [{ url = "https://files.pythonhosted.org/packages/a9/aa/df11bc013c36c1efda535ac2b542ac92f879940a6089bcbac54a779791b3/nccl4py-0.3.1.post1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-09-03T16:50:02Z, size = 11283409, hashes = { sha256 = "5d6f2d543a080867e0df9ddc5580755f511a34797b6a78626ca6ad25a2ca08a2" } }] + +[[packages]] +name = "nest-asyncio2" +version = "1.7.4" +sdist = { url = "https://files.pythonhosted.org/packages/32/2c/70e3b6bb2189cfd260280b7e1042bd622949a258663f95e887fada4ac1e6/nest_asyncio2-1.7.4.tar.gz", upload-time = 2026-10-07T22:31:50Z, size = 16891, hashes = { sha256 = "995b1409d926ec55e0876ea39a69bffdd8852cf1db3652c177e8c8ffdbcaf3cc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/09/ed/559d2915dce85794bc0c36064043da170da50cd98746dcbddd85d5932017/nest_asyncio2-1.7.4-py3-none-any.whl", upload-time = 2026-10-07T22:31:49Z, size = 8543, hashes = { sha256 = "86e77b52c3d1496b294af3c944b44213b9b82a12a5ee590c0acc4ca4692ef6c7" } }] + +[[packages]] +name = "networkx" +version = "3.6.1" +sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", upload-time = 2025-12-08T17:02:39Z, size = 2517025, hashes = { sha256 = "26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", upload-time = 2025-12-08T17:02:38Z, size = 2068504, hashes = { sha256 = "d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762" } }] + +[[packages]] +name = "ninja" +version = "1.13.2" +sdist = { url = "https://files.pythonhosted.org/packages/ac/92/410b7917d16ab54c04b05cc32b9284803671d91cf79d33be6009c28d4ea8/ninja-1.13.2.tar.gz", upload-time = 2026-08-30T15:49:51Z, size = 243739, hashes = { sha256 = "525bfa3fc88aa30a4467df270fd5be6f9fcae8061d54d4df74ea1dc5abd5a975" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/6e/53/ebfed7b689c338dd8ebeec9c0730c8d56821292f14e2536e5f3ef1a05744/ninja-1.13.2-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-08-30T15:49:34Z, size = 183365, hashes = { sha256 = "65a24341b5ac09fcadcc37082660be40a94174e51a937fabf6e2cae26225fa2c" } }] + +[[packages]] +name = "notebook" +version = "7.7.0a2" +sdist = { url = "https://files.pythonhosted.org/packages/01/a6/524f59386308696852284ea6b15651d6f919e71fd7dbc4a15c74fbfdea55/notebook-7.7.0a2.tar.gz", upload-time = 2026-09-23T13:53:42Z, size = 5602832, hashes = { sha256 = "07e3b2c770d965f7a820bcc18cd3c2753a5e79298785547db41a75690401bec0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a2/f6/364640ecd9aad8d73c3c73ffeb7c7b836dd7363044e33a9da8b1607641ea/notebook-7.7.0a2-py3-none-any.whl", upload-time = 2026-09-23T13:53:39Z, size = 5642093, hashes = { sha256 = "cf4077f263df750e0805071119576449d06ed7a6bce6900bd926cbfa133e3e35" } }] + +[[packages]] +name = "notebook-shim" +version = "0.2.4" +sdist = { url = "https://files.pythonhosted.org/packages/54/d2/92fa3243712b9a3e8bafaf60aac366da1cada3639ca767ff4b5b3654ec28/notebook_shim-0.2.4.tar.gz", upload-time = 2024-02-14T23:35:18Z, size = 13167, hashes = { sha256 = "b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f9/33/bd5b9137445ea4b680023eb0469b2bb969d61303dedb2aac6560ff3d14a1/notebook_shim-0.2.4-py3-none-any.whl", upload-time = 2024-02-14T23:35:16Z, size = 13307, hashes = { sha256 = "411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef" } }] + +[[packages]] +name = "numba" +version = "0.68.1rc2" +sdist = { url = "https://files.pythonhosted.org/packages/4a/d9/50d92b8e10f21dcd8dcfbf155135cc679130df6d6fb318b7c82e21199480/numba-0.68.1rc2.tar.gz", upload-time = 2026-10-15T17:26:08Z, size = 2859792, hashes = { sha256 = "6f6b3c8d7dc0e718ec2c5bbe825d65cac9d4a3f41b6a2a1017f84d098d06f2b3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0b/b9/8c8f7bf821a2df569be7f32d0d77db3ba1639825b28f2b8999ca882a7fbe/numba-0.68.1rc2-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-10-15T17:25:32Z, size = 3890056, hashes = { sha256 = "d577b97478e2cec8773c660f0711840f185cc977620ad45e4dba7afdc35b6b31" } }] + +[[packages]] +name = "numexpr" +version = "2.14.2" +sdist = { url = "https://files.pythonhosted.org/packages/79/c4/27ea7849eb4a7e3b51db446b0414254326dba8c6bdee09b9f2abf963e55d/numexpr-2.14.2.tar.gz", upload-time = 2026-07-18T10:52:43Z, size = 121744, hashes = { sha256 = "e7144e83ea9e581f2273e0304f15836736c4e470e2bd2e378ce617662a1ca278" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ea/11/e8953226d658ae67e3e002abaa60a101c693f9c57d74974001729afab5ef/numexpr-2.14.2-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-18T10:51:52Z, size = 445187, hashes = { sha256 = "d6a5d8fc7016bf6f6e1808b011510aa7c3bd75ec1407f7650874ec591db59f5e" } }] + +[[packages]] +name = "numpy" +version = "2.3.5" +sdist = { url = "https://files.pythonhosted.org/packages/76/65/21b3bc86aac7b8f2862db1e808f1ea22b028e30a225a34a5ede9bf8678f2/numpy-2.3.5.tar.gz", upload-time = 2025-11-16T22:52:42Z, size = 20584950, hashes = { sha256 = "784db1dcdab56bf0517743e746dfb0f885fc68d948aba86eeec2cba234bdf1c0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b6/23/2a1b231b8ff672b4c450dac27164a8b2ca7d9b7144f9c02d2396518352eb/numpy-2.3.5-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-11-16T22:50:02Z, size = 16606086, hashes = { sha256 = "0d8163f43acde9a73c2a33605353a4f1bc4798745a8b1d73183b28e5b435ae28" } }] + +[[packages]] +name = "nvidia-cublas" +version = "13.1.0.3" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/e7/44/423ac00af4dd95a5aeb27207e2c0d9b7118702149bf4704c3ddb55bb7429/nvidia_cublas-13.1.0.3-py3-none-manylinux_2_27_x86_64.whl", upload-time = 2025-10-09T08:59:32Z, size = 423133236, hashes = { sha256 = "ee8722c1f0145ab246bccb9e452153b5e0515fd094c3678df50b2a0888b8b171" } }] + +[[packages]] +name = "nvidia-cuda-cupti" +version = "13.0.85" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/33/6d/737d164b4837a9bbd202f5ae3078975f0525a55730fe871d8ed4e3b952b0/nvidia_cuda_cupti-13.0.85-py3-none-manylinux_2_25_x86_64.whl", upload-time = 2025-09-04T08:26:51Z, size = 10715597, hashes = { sha256 = "4eb01c08e859bf924d222250d2e8f8b8ff6d3db4721288cf35d14252a4d933c8" } }] + +[[packages]] +name = "nvidia-cuda-nvrtc" +version = "13.0.88" +wheels = [{ url = "https://files.pythonhosted.org/packages/c3/68/483a78f5e8f31b08fb1bb671559968c0ca3a065ac7acabfc7cee55214fd6/nvidia_cuda_nvrtc-13.0.88-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", upload-time = 2025-09-04T08:28:44Z, size = 90215200, hashes = { sha256 = "ad9b6d2ead2435f11cbb6868809d2adeeee302e9bb94bcf0539c7a40d80e8575" } }] + +[[packages]] +name = "nvidia-cuda-runtime" +version = "13.0.96" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/2e/24/d1558f3b68b1d26e706813b1d10aa1d785e4698c425af8db8edc3dced472/nvidia_cuda_runtime-13.0.96-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-10-09T08:55:36Z, size = 2243632, hashes = { sha256 = "7f82250d7782aa23b6cfe765ecc7db554bd3c2870c43f3d1821f1d18aebf0548" } }] + +[[packages]] +name = "nvidia-cuda-tileiras" +version = "13.1.80" +wheels = [{ url = "https://files.pythonhosted.org/packages/e6/41/b06f55714deaadd20ce4c860d3c6ea243e649d7922c5623cc20c86da18e5/nvidia_cuda_tileiras-13.1.80-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-12-05T17:39:07Z, size = 35796685, hashes = { sha256 = "dbf5ab15e8ad70fad28ce3cc2398e71bda55ce90dae32fe92c09f07d84ce2e02" } }] + +[[packages]] +name = "nvidia-cudnn-cu13" +version = "9.19.0.56" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/a3/22/0b4b932655d17a6da1b92fa92ab12844b053bb2ac2475e179ba6f043da1e/nvidia_cudnn_cu13-9.19.0.56-py3-none-manylinux_2_27_x86_64.whl", upload-time = 2026-02-03T20:44:52Z, size = 366066321, hashes = { sha256 = "d20e1734305e9d68889a96e3f35094d733ff1f83932ebe462753973e53a572bf" } }] + +[[packages]] +name = "nvidia-cudnn-frontend" +version = "1.28.0" +wheels = [{ url = "https://files.pythonhosted.org/packages/fd/0d/b6670b5d2d193322e0765d01889998df11d7f57522f210dc808b456530d9/nvidia_cudnn_frontend-1.28.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-09-02T06:07:31Z, size = 5677342, hashes = { sha256 = "335c916be758a8d5533104e04fc4a15f9c30a419b103ecd2b6fd0d23e1d532e4" } }] + +[[packages]] +name = "nvidia-cufft" +version = "12.0.0.61" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/a8/2f/7b57e29836ea8714f81e9898409196f47d772d5ddedddf1592eadb8ab743/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-09-04T08:31:56Z, size = 214085489, hashes = { sha256 = "6c44f692dce8fd5ffd3e3df134b6cdb9c2f72d99cf40b62c32dde45eea9ddad3" } }] + +[[packages]] +name = "nvidia-cufile" +version = "1.15.1.6" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/3f/70/4f193de89a48b71714e74602ee14d04e4019ad36a5a9f20c425776e72cd6/nvidia_cufile-1.15.1.6-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-09-04T08:32:22Z, size = 1223672, hashes = { sha256 = "08a3ecefae5a01c7f5117351c64f17c7c62efa5fffdbe24fc7d298da19cd0b44" } }] + +[[packages]] +name = "nvidia-curand" +version = "10.4.0.35" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/a5/9f/be0a41ca4a4917abf5cb9ae0daff1a6060cc5de950aec0396de9f3b52bc5/nvidia_curand-10.4.0.35-py3-none-manylinux_2_27_x86_64.whl", upload-time = 2025-08-04T10:22:03Z, size = 59544258, hashes = { sha256 = "1aee33a5da6e1db083fe2b90082def8915f30f3248d5896bcec36a579d941bfc" } }] + +[[packages]] +name = "nvidia-cusolver" +version = "12.0.4.66" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/5f/67/cba3777620cdacb99102da4042883709c41c709f4b6323c10781a9c3aa34/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_x86_64.whl", upload-time = 2025-09-04T08:33:22Z, size = 200941980, hashes = { sha256 = "0a759da5dea5c0ea10fd307de75cdeb59e7ea4fcb8add0924859b944babf1112" } }] + +[[packages]] +name = "nvidia-cusparse" +version = "12.6.3.3" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/fa/18/623c77619c31d62efd55302939756966f3ecc8d724a14dab2b75f1508850/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-09-04T08:33:58Z, size = 145942937, hashes = { sha256 = "2b3c89c88d01ee0e477cb7f82ef60a11a4bcd57b6b87c33f789350b59759360b" } }] + +[[packages]] +name = "nvidia-cusparselt-cu13" +version = "0.8.0" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/fd/53/43b0d71f4e702fa9733f8b4571fdca50a8813f1e450b656c239beff12315/nvidia_cusparselt_cu13-0.8.0-py3-none-manylinux2014_x86_64.whl", upload-time = 2025-08-13T19:23:41Z, size = 169884119, hashes = { sha256 = "25e30a8a7323935d4ad0340b95a0b69926eee755767e8e0b1cf8dd85b197d3fd" } }] + +[[packages]] +name = "nvidia-cutlass-dsl" +version = "4.5.0" +wheels = [{ url = "https://files.pythonhosted.org/packages/71/a3/46fdf77d373b06bc65a0eda6c921c746985fb3e496c90a09be476291ea80/nvidia_cutlass_dsl-4.5.0-py3-none-any.whl", upload-time = 2026-05-06T01:17:33Z, size = 10178, hashes = { sha256 = "3b051fe02ca69422ab840e64d9865667aba288a3984a7ca4ccd038a82aef1344" } }] + +[[packages]] +name = "nvidia-cutlass-dsl-libs-base" +version = "4.5.0" +wheels = [{ url = "https://files.pythonhosted.org/packages/c3/8b/2c187400d85f7d2acb328f20499b7b05745dca8485cf6ad247d5f2b434cf/nvidia_cutlass_dsl_libs_base-4.5.0-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-05-06T01:26:52Z, size = 74505487, hashes = { sha256 = "bd18322d9247f8c033a10ed4e519c4985ca6b4fb578ade382e5a264422ebd915" } }] + +[[packages]] +name = "nvidia-cutlass-dsl-libs-cu13" +version = "4.5.0" +marker = "python_full_version >= '3.10'" +wheels = [{ url = "https://files.pythonhosted.org/packages/cd/f2/2c976759dff8836e41a8ff3716db4fc72b01969ea6ee062ae22877008030/nvidia_cutlass_dsl_libs_cu13-4.5.0-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-05-06T06:58:30Z, size = 78787917, hashes = { sha256 = "fc0b5a81ff591db72489134ca206ae886f0cce43f20863010a7f30fcfe484a7b" } }] + +[[packages]] +name = "nvidia-matmul-heuristics" +version = "0.1.0.27" +wheels = [{ url = "https://files.pythonhosted.org/packages/cf/94/99b7b5a7465bf3ced3b76e608465d04ab671ed4e382e37bc7e65cb087ac9/nvidia_matmul_heuristics-0.1.0.27-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-08-25T22:06:12Z, size = 2015285, hashes = { sha256 = "4107ae54308d9262a6b14c30982c45c720b9c5f4196bf93dac64f6739ed8f8d9" } }] + +[[packages]] +name = "nvidia-ml-py" +version = "13.595.45" +sdist = { url = "https://files.pythonhosted.org/packages/ce/49/c29f6e30d8662d2e94fef17739ea7309cc76aba269922ae999e4cc07f268/nvidia_ml_py-13.595.45.tar.gz", upload-time = 2026-03-19T16:59:44Z, size = 50780, hashes = { sha256 = "c9f34897fe0441ff35bc8f35baf80f830a20b0f4e6ce71e0a325bc0e66acf079" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8a/24/fc256107d23597fa33d319505ce77160fa1a2349c096d01901ffc7cb7fc4/nvidia_ml_py-13.595.45-py3-none-any.whl", upload-time = 2026-03-19T16:59:43Z, size = 51776, hashes = { sha256 = "b65a7977f503d56154b14d683710125ef93594adb63fbf7e559336e3318f1376" } }] + +[[packages]] +name = "nvidia-nccl-cu13" +version = "2.28.9" +wheels = [{ url = "https://files.pythonhosted.org/packages/b0/b4/878fefaad5b2bcc6fcf8d474a25e3e3774bc5133e4b58adff4d0bca238bc/nvidia_nccl_cu13-2.28.9-py3-none-manylinux_2_18_x86_64.whl", upload-time = 2025-11-18T05:49:17Z, size = 196493177, hashes = { sha256 = "e4553a30f34195f3fa1da02a6da3d6337d28f2003943aa0a3d247bbc25fefc42" } }] + +[[packages]] +name = "nvidia-nvjitlink" +version = "13.0.88" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/56/7a/123e033aaff487c77107195fa5a2b8686795ca537935a24efae476c41f05/nvidia_nvjitlink-13.0.88-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", upload-time = 2025-09-04T08:35:43Z, size = 40713933, hashes = { sha256 = "13a74f429e23b921c1109976abefacc69835f2f433ebd323d3946e11d804e47b" } }] + +[[packages]] +name = "nvidia-nvshmem-cu13" +version = "3.4.5" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/3c/35/a9bf80a609e74e3b000fef598933235c908fcefcef9026042b8e6dfde2a9/nvidia_nvshmem_cu13-3.4.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2025-09-06T00:32:41Z, size = 60412546, hashes = { sha256 = "290f0a2ee94c9f3687a02502f3b9299a9f9fe826e6d0287ee18482e78d495b80" } }] + +[[packages]] +name = "nvidia-nvtx" +version = "13.0.85" +marker = "sys_platform == 'linux'" +wheels = [{ url = "https://files.pythonhosted.org/packages/c2/f3/d86c845465a2723ad7e1e5c36dcd75ddb82898b3f53be47ebd429fb2fa5d/nvidia_nvtx-13.0.85-py3-none-manylinux1_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2025-09-04T08:29:01Z, size = 148047, hashes = { sha256 = "4936d1d6780fbe68db454f5e72a42ff64d1fd6397df9f363ae786930fd5c1cd4" } }] + +[[packages]] +name = "nvtx" +version = "0.2.16" +sdist = { url = "https://files.pythonhosted.org/packages/7d/0b/7e9571ea963fd54bc0ac05184e735df7c4672c1a93cbb50d4fe3e7fa9f99/nvtx-0.2.16.tar.gz", upload-time = 2026-08-12T17:45:47Z, size = 193099, hashes = { sha256 = "252fdb870308be4a2beecb3ed174b1d59099eeb63c883f269944a765ce5f7720" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5f/09/adb32c8c6926d14c90eafc023d6a4c16ac22ca279f70c406bb9590b0e708/nvtx-0.2.16-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-08-12T17:52:52Z, size = 2849502, hashes = { sha256 = "b6230be4ee35edcfe00411c6f71d48de5d50147146c4efc06b710d2516086031" } }] + +[[packages]] +name = "omegaconf" +version = "2.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/09/48/6388f1bb9da707110532cb70ec4d2822858ddfb44f1cdf1233c20a80ea4b/omegaconf-2.3.0.tar.gz", upload-time = 2022-12-08T20:59:22Z, size = 3298120, hashes = { sha256 = "d5d4b6d29955cc50ad50c46dc269bcd92c6e00f5f90d23ab5fee7bfca4ba4cc7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e3/94/1843518e420fa3ed6919835845df698c7e27e183cb997394e4a670973a65/omegaconf-2.3.0-py3-none-any.whl", upload-time = 2022-12-08T20:59:19Z, size = 79500, hashes = { sha256 = "7b4df175cdb08ba400f45cae3bdcae7ba8365db4d165fc65fd04b050ab63b46b" } }] + +[[packages]] +name = "openai" +version = "2.30.0" +sdist = { url = "https://files.pythonhosted.org/packages/88/15/52580c8fbc16d0675d516e8749806eda679b16de1e4434ea06fb6feaa610/openai-2.30.0.tar.gz", upload-time = 2026-03-25T22:08:59Z, size = 676084, hashes = { sha256 = "92f7661c990bda4b22a941806c83eabe4896c3094465030dd882a71abe80c885" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/9e/5bfa2270f902d5b92ab7d41ce0475b8630572e71e349b2a4996d14bdda93/openai-2.30.0-py3-none-any.whl", upload-time = 2026-03-25T22:08:58Z, size = 1146656, hashes = { sha256 = "9a5ae616888eb2748ec5e0c5b955a51592e0b201a11f4262db920f2a78c5231d" } }] + +[[packages]] +name = "openai-harmony" +version = "0.0.4" +sdist = { url = "https://files.pythonhosted.org/packages/92/94/01509d510bebf6606614e51113e5a415ced15b8f34aa98a8bf2539314650/openai_harmony-0.0.4.tar.gz", upload-time = 2025-08-09T01:43:24Z, size = 279848, hashes = { sha256 = "5c67ac6df349236fb7b64f57c3dbb0273efcdca24314daa108f2a482c427106c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1f/ec/dcdcace0ffcf3a532cca910e0c351b62d3a7decf0b091ea8cf856d2a67a6/openai_harmony-0.0.4-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-08-09T01:43:11Z, size = 3049306, hashes = { sha256 = "31e9bcac0902a309e2fc688e52f247eec7fffcd00d17e958b9a83a8fea6519c2" } }] + +[[packages]] +name = "optimum" +version = "2.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/d9/76/e4ac0c4b398ed3fe2d41e0058002d276896b9a15a54be16889d8e0d3ee92/optimum-2.3.0.tar.gz", upload-time = 2026-08-04T15:35:18Z, size = 124929, hashes = { sha256 = "aa96ad535a5cec68d12c6372574125452284632fe13699633a61e8bbfb09c4df" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8c/f9/a16609b4e4fc592653d9f2a0413689da686a94d0040f3a2fabfff5b5894c/optimum-2.3.0-py3-none-any.whl", upload-time = 2026-08-04T15:35:17Z, size = 160922, hashes = { sha256 = "3e9b217b4ab21fd4cf894a987002ee7d3626114e009592babf084c2f1a0f3b5f" } }] + +[[packages]] +name = "ordered-set" +version = "4.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/4c/ca/bfac8bc689799bcca4157e0e0ced07e70ce125193fc2e166d2e685b7e2fe/ordered-set-4.1.0.tar.gz", upload-time = 2022-01-26T14:38:56Z, size = 12826, hashes = { sha256 = "694a8e44c87657c59292ede72891eb91d34131f6531463aab3009191c77364a8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/33/55/af02708f230eb77084a299d7b08175cff006dea4f2721074b92cdb0296c0/ordered_set-4.1.0-py3-none-any.whl", upload-time = 2022-01-26T14:38:48Z, size = 7634, hashes = { sha256 = "046e1132c71fcf3330438a539928932caf51ddbc582496833e23de611de14562" } }] + +[[packages]] +name = "orloge" +version = "1.0.0" +sdist = { url = "https://files.pythonhosted.org/packages/e6/6a/5496be734109def41e692abd2ad2fd975d9d2633dbab6fecc889307f4908/orloge-1.0.0.tar.gz", upload-time = 2026-09-17T07:58:22Z, size = 20976, hashes = { sha256 = "6c0bf7d2867fe22e60ef6425d7e99599938c0b1611d513a0baf972fa91b71c88" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ac/b5/3861058b70d624330ac2c42f8555580cd8e5244a89a3033713cfd1ce6ce8/orloge-1.0.0-py3-none-any.whl", upload-time = 2026-09-17T07:58:22Z, size = 16695, hashes = { sha256 = "e58cc1e15c7939fb8dc0b6ea6839c3c35805d31bbd7d3721dfc88ddc77f4b8e3" } }] + +[[packages]] +name = "packaging" +version = "24.2" +sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", upload-time = 2024-11-08T09:47:47Z, size = 163950, hashes = { sha256 = "c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", upload-time = 2024-11-08T09:47:44Z, size = 65451, hashes = { sha256 = "09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759" } }] + +[[packages]] +name = "pandas" +version = "2.3.3" +sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", upload-time = 2025-09-29T23:34:51Z, size = 4495223, hashes = { sha256 = "e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e5/63/cd7d615331b328e287d8233ba9fdf191a9c2d11b6af0c7a59cfcec23de68/pandas-2.3.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-09-29T23:20:14Z, size = 12362693, hashes = { sha256 = "b3d11d2fda7eb164ef27ffc14b4fcab16a80e1ce67e9f57e19ec0afaf715ba89" } }] + +[[packages]] +name = "pandocfilters" +version = "1.5.1" +sdist = { url = "https://files.pythonhosted.org/packages/70/6f/3dd4940bbe001c06a65f88e36bad298bc7a0de5036115639926b0c5c0458/pandocfilters-1.5.1.tar.gz", upload-time = 2024-01-18T20:08:13Z, size = 8454, hashes = { sha256 = "002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl", upload-time = 2024-01-18T20:08:11Z, size = 8663, hashes = { sha256 = "93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc" } }] + +[[packages]] +name = "parso" +version = "0.8.6" +sdist = { url = "https://files.pythonhosted.org/packages/81/76/a1e769043c0c0c9fe391b702539d594731a4362334cdf4dc25d0c09761e7/parso-0.8.6.tar.gz", upload-time = 2026-02-09T15:45:24Z, size = 401621, hashes = { sha256 = "2b9a0332696df97d454fa67b81618fd69c35a7b90327cbe6ba5c92d2c68a7bfd" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b6/61/fae042894f4296ec49e3f193aff5d7c18440da9e48102c3315e1bc4519a7/parso-0.8.6-py2.py3-none-any.whl", upload-time = 2026-02-09T15:45:21Z, size = 106894, hashes = { sha256 = "2c549f800b70a5c4952197248825584cb00f033b29c692671d3bf08bf380baff" } }] + +[[packages]] +name = "partial-json-parser" +version = "0.2.1.1.post7" +sdist = { url = "https://files.pythonhosted.org/packages/6a/6d/eed37d7ebc1e0bcd27b831c0cf1fe94881934316187c4b30d23f29ea0bd4/partial_json_parser-0.2.1.1.post7.tar.gz", upload-time = 2025-11-17T07:27:41Z, size = 10296, hashes = { sha256 = "86590e1ba6bcb6739a2dfc17d2323f028cb5884f4c6ce23db376999132c9a922" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/42/32/658973117bf0fd82a24abbfb94fe73a5e86216e49342985e10acce54775a/partial_json_parser-0.2.1.1.post7-py3-none-any.whl", upload-time = 2025-11-17T07:27:40Z, size = 10877, hashes = { sha256 = "145119e5eabcf80cbb13844a6b50a85c68bf99d376f8ed771e2a3c3b03e653ae" } }] + +[[packages]] +name = "patchelf" +version = "0.19.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/5a/0b/691b49b40201a80cb09dbf2003eef0e36270ae07b00de99baa915df1d274/patchelf-0.19.1.0.tar.gz", upload-time = 2026-08-08T05:07:29Z, size = 371787, hashes = { sha256 = "8976fbdef7d3e461d623e703024b70db6b6e3308f7e389930f39a71a1e347a2c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e7/03/afd9bdd2ba5f96997196109f25dadbe5141bc6e70dffd85f3f84cc85d69c/patchelf-0.19.1.0-py3-none-manylinux1_x86_64.manylinux_2_5_x86_64.musllinux_1_1_x86_64.whl", upload-time = 2026-08-08T05:07:21Z, size = 549422, hashes = { sha256 = "a8f6331ccf40c345507279f755f4a38c2cb00b9efda746fd43c17713cce0aba4" } }] + +[[packages]] +name = "peft" +version = "0.18.1" +sdist = { url = "https://files.pythonhosted.org/packages/d8/48/147b3ea999560b40a34fd78724c7777aa9d18409c2250bdcaf9c4f2db7fc/peft-0.18.1.tar.gz", upload-time = 2026-01-09T13:08:01Z, size = 635030, hashes = { sha256 = "2dd0d6bfce936d1850e48aaddbd250941c5c02fc8ef3237cd8fd5aac35e0bae2" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b3/14/b4e3f574acf349ae6f61f9c000a77f97a3b315b4bb6ad03791e79ae4a568/peft-0.18.1-py3-none-any.whl", upload-time = 2026-01-09T13:07:55Z, size = 556960, hashes = { sha256 = "0bf06847a3551e3019fc58c440cffc9a6b73e6e2962c95b52e224f77bbdb50f1" } }] + +[[packages]] +name = "pexpect" +version = "4.9.0" +marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", upload-time = 2023-11-25T09:07:26Z, size = 166450, hashes = { sha256 = "ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", upload-time = 2023-11-25T06:56:14Z, size = 63772, hashes = { sha256 = "7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523" } }] + +[[packages]] +name = "pillow" +version = "12.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/1c/3d/bb7fca845737cf9d7dbde16ed1843984665ff2e0a518f5db43e77ec540b9/pillow-12.3.0.tar.gz", upload-time = 2026-07-01T11:56:38Z, size = 47025035, hashes = { sha256 = "3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/84/21/a35af28dcc61f37ed850a2d64c65c701321dfbf25085e469d5559360cbbf/pillow-12.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-01T11:54:13Z, size = 6940830, hashes = { sha256 = "78cb2c6865a35ab8ff8b75fd122f6033b92a62c82801110e48ddd6c936a45d91" } }] + +[[packages]] +name = "platformdirs" +version = "4.9.6" +sdist = { url = "https://files.pythonhosted.org/packages/9f/4a/0883b8e3802965322523f0b200ecf33d31f10991d0401162f4b23c698b42/platformdirs-4.9.6.tar.gz", upload-time = 2026-04-09T00:04:10Z, size = 29400, hashes = { sha256 = "3bfa75b0ad0db84096ae777218481852c0ebc6c727b3168c1b9e0118e458cf0a" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/75/a6/a0a304dc33b49145b21f4808d763822111e67d1c3a32b524a1baf947b6e1/platformdirs-4.9.6-py3-none-any.whl", upload-time = 2026-04-09T00:04:09Z, size = 21348, hashes = { sha256 = "e61adb1d5e5cb3441b4b7710bea7e4c12250ca49439228cc1021c00dcfac0917" } }] + +[[packages]] +name = "plotly" +version = "7.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/49/c3/72b369f5ed7701b04ab0ea3dcf83e9bbce71c0b3bc6f07f87568550d09ea/plotly-7.1.0.tar.gz", upload-time = 2026-09-15T19:21:21Z, size = 6689315, hashes = { sha256 = "f860166a4a3d78c69cb1f4a15f28a5c8283eade98a282a698f3bb853a449ace5" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e5/7d/905a3a3d51087515719058c94cfbda2ff0fc14417c20d557ae3e82d8b250/plotly-7.1.0-py3-none-any.whl", upload-time = 2026-09-15T19:21:18Z, size = 9692368, hashes = { sha256 = "dbb7fa18afce40d0a8e80d1bf162eceb3faa0ce5a77fe741ad09a74cf78f53f3" } }] + +[[packages]] +name = "polygraphy" +version = "0.53.6" +wheels = [{ url = "https://files.pythonhosted.org/packages/8b/16/a3069a489c36e855d3a792a532a96e6434e1a454a21248effd3a26da2a7b/polygraphy-0.53.6-py3-none-any.whl", upload-time = 2026-09-22T20:04:07Z, size = 485433, hashes = { sha256 = "539095f64054823aabac5d4c8d64875b5a1542b71ca76443e218a01fdc1a4e03" } }] + +[[packages]] +name = "pooch" +version = "1.9.0" +sdist = { url = "https://files.pythonhosted.org/packages/83/43/85ef45e8b36c6a48546af7b266592dc32d7f67837a6514d111bced6d7d75/pooch-1.9.0.tar.gz", upload-time = 2026-01-30T19:15:09Z, size = 61788, hashes = { sha256 = "de46729579b9857ffd3e741987a2f6d5e0e03219892c167c6578c0091fb511ed" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2a/2d/d4bf65e47cea8ff2c794a600c4fd1273a7902f268757c531e0ee9f18aa58/pooch-1.9.0-py3-none-any.whl", upload-time = 2026-01-30T19:15:08Z, size = 67175, hashes = { sha256 = "f265597baa9f760d25ceb29d0beb8186c243d6607b0f60b83ecf14078dbc703b" } }] + +[[packages]] +name = "prometheus-client" +version = "0.26.0" +sdist = { url = "https://files.pythonhosted.org/packages/52/73/f1334c29c2af4cd9dba6c7817e61b611bd0215e2eb5565c6064a4de18802/prometheus_client-0.26.0.tar.gz", upload-time = 2026-07-24T19:36:41Z, size = 92910, hashes = { sha256 = "04a91bcf94e2cf74a44a1a874d651a2e853ed354b6e822f3b7487751465d5c2b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/eb/a3/b69efbf4143b5b9859b977770bbbabcc2796b702fa69dc40271e45cd5a56/prometheus_client-0.26.0-py3-none-any.whl", upload-time = 2026-07-24T19:36:40Z, size = 64494, hashes = { sha256 = "fa93d06737aa02bacd05794768508bb97d2fbee28cb3bca04eaae92f0ca953d6" } }] + +[[packages]] +name = "prometheus-fastapi-instrumentator" +version = "7.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/69/6d/24d53033cf93826aa7857699a4450c1c67e5b9c710e925b1ed2b320c04df/prometheus_fastapi_instrumentator-7.1.0.tar.gz", upload-time = 2025-03-19T19:35:05Z, size = 20220, hashes = { sha256 = "be7cd61eeea4e5912aeccb4261c6631b3f227d8924542d79eaf5af3f439cbe5e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/27/72/0824c18f3bc75810f55dacc2dd933f6ec829771180245ae3cc976195dec0/prometheus_fastapi_instrumentator-7.1.0-py3-none-any.whl", upload-time = 2025-03-19T19:35:04Z, size = 19296, hashes = { sha256 = "978130f3c0bb7b8ebcc90d35516a6fe13e02d2eb358c8f83887cdef7020c31e9" } }] + +[[packages]] +name = "prompt-toolkit" +version = "3.0.52" +sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", upload-time = 2025-08-27T15:24:02Z, size = 434198, hashes = { sha256 = "28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", upload-time = 2025-08-27T15:23:59Z, size = 391431, hashes = { sha256 = "9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955" } }] + +[[packages]] +name = "propcache" +version = "0.4.1" +sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", upload-time = 2025-10-08T19:49:02Z, size = 46442, hashes = { sha256 = "f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/46/4b/3aae6835b8e5f44ea6a68348ad90f78134047b503765087be2f9912140ea/propcache-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-10-08T19:46:54Z, size = 221575, hashes = { sha256 = "15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf" } }, + { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", upload-time = 2025-10-08T19:49:00Z, size = 13305, hashes = { sha256 = "af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237" } }, +] + +[[packages]] +name = "protobuf" +version = "6.33.6" +sdist = { url = "https://files.pythonhosted.org/packages/66/70/e908e9c5e52ef7c3a6c7902c9dfbb34c7e29c25d2f81ade3856445fd5c94/protobuf-6.33.6.tar.gz", upload-time = 2026-03-18T19:05:00Z, size = 444531, hashes = { sha256 = "a6768d25248312c297558af96a9f9c929e8c4cee0659cb07e780731095f38135" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/16/92/d1e32e3e0d894fe00b15ce28ad4944ab692713f2e7f0a99787405e43533a/protobuf-6.33.6-cp39-abi3-manylinux2014_x86_64.whl", upload-time = 2026-03-18T19:04:55Z, size = 323436, hashes = { sha256 = "e9db7e292e0ab79dd108d7f1a94fe31601ce1ee3f7b79e0692043423020b0593" } }, + { url = "https://files.pythonhosted.org/packages/c4/72/02445137af02769918a93807b2b7890047c32bfb9f90371cbc12688819eb/protobuf-6.33.6-py3-none-any.whl", upload-time = 2026-03-18T19:04:59Z, size = 170656, hashes = { sha256 = "77179e006c476e69bf8e8ce866640091ec42e1beb80b213c3900006ecfba6901" } }, +] + +[[packages]] +name = "psutil" +version = "7.2.2" +sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", upload-time = 2026-01-28T18:14:54Z, size = 493740, hashes = { sha256 = "0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-01-28T18:15:25Z, size = 155560, hashes = { sha256 = "076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9" } }] + +[[packages]] +name = "ptyprocess" +version = "0.7.0" +marker = "os_name != 'nt' or (sys_platform != 'emscripten' and sys_platform != 'win32')" +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", upload-time = 2020-12-28T15:15:30Z, size = 70762, hashes = { sha256 = "5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", upload-time = 2020-12-28T15:15:28Z, size = 13993, hashes = { sha256 = "4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35" } }] + +[[packages]] +name = "pulp" +version = "4.0.1" +sdist = { url = "https://files.pythonhosted.org/packages/6c/96/a303e7e43c66402fed1d401615eae48eda2fe5bb9da62f28c55b108b7041/pulp-4.0.1.tar.gz", upload-time = 2026-10-14T08:08:22Z, size = 165276, hashes = { sha256 = "976f1184a69ab2aceb12e7c14e375775f184bddb8e66ee611ebaccbcad537f8c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f7/8b/388d2c394514fd9fdaa5f15ebd3a059859e8a587127428242d5d91ba2fe5/pulp-4.0.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-10-14T08:07:07Z, size = 695708, hashes = { sha256 = "6d37d92314b49dd80ea9e294a5ed560ef92bcb19d761aa1538f6bde9ee1f7f6b" } }] + +[[packages]] +name = "pure-eval" +version = "0.2.3" +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", upload-time = 2024-07-21T12:58:21Z, size = 19752, hashes = { sha256 = "5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", upload-time = 2024-07-21T12:58:20Z, size = 11842, hashes = { sha256 = "1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0" } }] + +[[packages]] +name = "pyarrow" +version = "23.0.1" +sdist = { url = "https://files.pythonhosted.org/packages/88/22/134986a4cc224d593c1afde5494d18ff629393d74cc2eddb176669f234a4/pyarrow-23.0.1.tar.gz", upload-time = 2026-02-16T10:14:12Z, size = 1167336, hashes = { sha256 = "b8c5873e33440b2bc2f4a79d2b47017a89c5a24116c055625e6f2ee50523f019" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2c/a5/da83046273d990f256cb79796a190bbf7ec999269705ddc609403f8c6b06/pyarrow-23.0.1-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-02-16T10:10:17Z, size = 47586063, hashes = { sha256 = "813d99f31275919c383aab17f0f455a04f5a429c261cc411b1e9a8f5e4aaaa05" } }] + +[[packages]] +name = "pycountry" +version = "26.2.16" +sdist = { url = "https://files.pythonhosted.org/packages/de/1d/061b9e7a48b85cfd69f33c33d2ef784a531c359399ad764243399673c8f5/pycountry-26.2.16.tar.gz", upload-time = 2026-02-17T03:42:52Z, size = 7711342, hashes = { sha256 = "5b6027d453fcd6060112b951dd010f01f168b51b4bf8a1f1fc8c95c8d94a0801" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9c/42/7703bd45b62fecd44cd7d3495423097e2f7d28bc2e99e7c1af68892ab157/pycountry-26.2.16-py3-none-any.whl", upload-time = 2026-02-17T03:42:49Z, size = 8044600, hashes = { sha256 = "115c4baf7cceaa30f59a4694d79483c9167dbce7a9de4d3d571c5f3ea77c305a" } }] + +[[packages]] +name = "pycparser" +version = "3.0" +marker = "implementation_name != 'PyPy'" +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", upload-time = 2026-01-21T14:26:51Z, size = 103492, hashes = { sha256 = "600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", upload-time = 2026-01-21T14:26:50Z, size = 48172, hashes = { sha256 = "b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992" } }] + +[[packages]] +name = "pycryptodomex" +version = "3.24.1" +sdist = { url = "https://files.pythonhosted.org/packages/f4/e7/50e72301e32acb73a314e663c2014e1ddefc019d5f434ff14ec89861d664/pycryptodomex-3.24.1.tar.gz", upload-time = 2026-10-11T19:26:49Z, size = 4934627, hashes = { sha256 = "09081666ffc599976c0b8b29caf2cf82212c0f05bed233c8f8ed53e4f6e1d356" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/cf/93/a954b7a8746980e31648943e29772aca0311d0d8a407a3adf5788083b693/pycryptodomex-3.24.1-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-10-11T19:26:17Z, size = 2280275, hashes = { sha256 = "9b94a8c647c1f80b4c82c7ac9642dda94a71abbb4efa29ad652c410ad7a39879" } }] + +[[packages]] +name = "pydantic" +version = "2.12.5" +sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", upload-time = 2025-11-26T15:11:46Z, size = 821591, hashes = { sha256 = "4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", upload-time = 2025-11-26T15:11:44Z, size = 463580, hashes = { sha256 = "e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d" } }] + +[[packages]] +name = "pydantic-core" +version = "2.41.5" +sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", upload-time = 2025-11-04T13:43:49Z, size = 460952, hashes = { sha256 = "08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-04T13:40:09Z, size = 2075366, hashes = { sha256 = "eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c" } }] + +[[packages]] +name = "pydantic-extra-types" +version = "2.11.1" +sdist = { url = "https://files.pythonhosted.org/packages/66/71/dba38ee2651f84f7842206adbd2233d8bbdb59fb85e9fa14232486a8c471/pydantic_extra_types-2.11.1.tar.gz", upload-time = 2026-03-16T08:08:03Z, size = 172002, hashes = { sha256 = "46792d2307383859e923d8fcefa82108b1a141f8a9c0198982b3832ab5ef1049" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/17/c1/3226e6d7f5a4f736f38ac11a6fbb262d701889802595cdb0f53a885ac2e0/pydantic_extra_types-2.11.1-py3-none-any.whl", upload-time = 2026-03-16T08:08:02Z, size = 79526, hashes = { sha256 = "1722ea2bddae5628ace25f2aa685b69978ef533123e5638cfbddb999e0100ec1" } }] + +[[packages]] +name = "pydantic-settings" +version = "2.14.2" +sdist = { url = "https://files.pythonhosted.org/packages/5c/b5/8f48e906c3e0205276e8bd8cb7512217a87b2685304d64be27cad5b3019f/pydantic_settings-2.14.2.tar.gz", upload-time = 2026-06-19T13:44:56Z, size = 237700, hashes = { sha256 = "c19dd64b19097f1de80184f0cc7b0272a13ae6e170cbf240a3e27e381ed14a5f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/77/c1/6e422f34e569cf8e18df68d1939c81c099d2b61e4f7d9621c8a77560799c/pydantic_settings-2.14.2-py3-none-any.whl", upload-time = 2026-06-19T13:44:55Z, size = 61715, hashes = { sha256 = "a20c97b37910b6550d5ea50fbcc2d4187defe58cd57070b73863d069419c9440" } }] + +[[packages]] +name = "pygments" +version = "2.20.0" +sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", upload-time = 2026-03-29T13:29:33Z, size = 4955991, hashes = { sha256 = "6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", upload-time = 2026-03-29T13:29:30Z, size = 1231151, hashes = { sha256 = "81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176" } }] + +[[packages]] +name = "pyjwt" +version = "2.13.0" +sdist = { url = "https://files.pythonhosted.org/packages/3b/81/58d0ac84e1ef3a3843791d6954d94c0b33d526c75eeb1efbce9d0a4c4077/pyjwt-2.13.0.tar.gz", upload-time = 2026-05-21T19:54:36Z, size = 107515, hashes = { sha256 = "41571c89ca91598c79e8ef18a2d07367d4810fbbd6f637794879baf1b7703423" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a3/5e/ecf12fdb62546d64385c158514e9b2b671f7832108ef2ecd2020ce0af2d1/pyjwt-2.13.0-py3-none-any.whl", upload-time = 2026-05-21T19:54:35Z, size = 31274, hashes = { sha256 = "66adcc2aff09b3f1bbd95fc1e1577df8ac8723c978552fd43304c8a290ac5728" } }] + +[[packages]] +name = "pynvvideocodec" +version = "2.1.0" +wheels = [{ url = "https://files.pythonhosted.org/packages/67/dd/99ab1d310aaadc7e20d434cf27b387a5a0878f1dfbb3788c365905647c7b/pynvvideocodec-2.1.0-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-01-30T12:03:06Z, size = 36745131, hashes = { sha256 = "c317fbad725b1b81936b863edcd98920bc4be423b9965719657030359d7afe29" } }] + +[[packages]] +name = "pyparsing" +version = "3.3.3" +sdist = { url = "https://files.pythonhosted.org/packages/e4/11/b213bebff182584360cb8d17c72c1677fec5c5c228de439e63bcf8ab1c8f/pyparsing-3.3.3.tar.gz", upload-time = 2026-09-20T20:59:05Z, size = 1050487, hashes = { sha256 = "928ae7e20211f3b6f3915a72f06a0cfd29ab9d24279dd6346b6b1a7146397d36" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/38/bb/d215ee7c73b61497b28a5503f9f53523f294fcc936762b7caf90e0c1c2b5/pyparsing-3.3.3-py3-none-any.whl", upload-time = 2026-09-20T20:59:04Z, size = 126420, hashes = { sha256 = "ece8c00a69cf01b45d0b1dedabb469c90d8caf996d4fda40f147627a122849a4" } }] + +[[packages]] +name = "pyproject-hooks" +version = "1.2.0" +sdist = { url = "https://files.pythonhosted.org/packages/e7/82/28175b2414effca1cdac8dc99f76d660e7a4fb0ceefa4b4ab8f5f6742925/pyproject_hooks-1.2.0.tar.gz", upload-time = 2024-09-29T09:24:13Z, size = 19228, hashes = { sha256 = "1e859bd5c40fae9448642dd871adf459e5e2084186e8d2c2a79a824c970da1f8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/bd/24/12818598c362d7f300f18e74db45963dbcb85150324092410c8b49405e42/pyproject_hooks-1.2.0-py3-none-any.whl", upload-time = 2024-09-29T09:24:11Z, size = 10216, hashes = { sha256 = "9e5c6bfa8dcc30091c74b0cf803c81fdd29d94f01992a7707bc97babb1141913" } }] + +[[packages]] +name = "python-dateutil" +version = "2.9.0.post0" +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", upload-time = 2024-03-01T18:36:20Z, size = 342432, hashes = { sha256 = "37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", upload-time = 2024-03-01T18:36:18Z, size = 229892, hashes = { sha256 = "a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427" } }] + +[[packages]] +name = "python-dotenv" +version = "1.2.2" +sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", upload-time = 2026-03-01T16:00:26Z, size = 50135, hashes = { sha256 = "2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", upload-time = 2026-03-01T16:00:25Z, size = 22101, hashes = { sha256 = "1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a" } }] + +[[packages]] +name = "python-json-logger" +version = "4.2.0" +sdist = { url = "https://files.pythonhosted.org/packages/21/25/5473e46b179f8e8b4ad3aeeb36773d1701b7770eaf5e5bc2025c7303b598/python_json_logger-4.2.0.tar.gz", upload-time = 2026-08-15T11:36:38Z, size = 18211, hashes = { sha256 = "e371ebe22ec01e289850102091a2b1f6fc9e655c7f1f5f29073936756c290afa" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/dc/55/6467fde553886cb293e41538f3a8b4e4fd4688c6df242cf982162d8367fb/python_json_logger-4.2.0-py3-none-any.whl", upload-time = 2026-08-15T11:36:36Z, size = 14988, hashes = { sha256 = "158a52126fcd6869e09574d2b66272666f3dc8f468c62637ef9a1fa883719cb9" } }] + +[[packages]] +name = "python-multipart" +version = "0.0.32" +sdist = { url = "https://files.pythonhosted.org/packages/5b/42/55c32bb9b12693c092ad250a0e82edb5b31ddeda6eb772de5f308b3804ad/python_multipart-0.0.32.tar.gz", upload-time = 2026-06-04T16:18:58Z, size = 46881, hashes = { sha256 = "be54b7f3fa167bb83e4fcd936b887b708f4e57fe75911c02aebf53efaf8d938e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e1/04/e8135ebd1ad02c56ec633277529b2602ff99ff634be76cdba5744cf554fd/python_multipart-0.0.32-py3-none-any.whl", upload-time = 2026-06-04T16:18:57Z, size = 30042, hashes = { sha256 = "ff6d3f776f16878c894e52e107296ffc890e913c611b1a4ec6c44e2821fe2e23" } }] + +[[packages]] +name = "pytz" +version = "2026.1.post1" +sdist = { url = "https://files.pythonhosted.org/packages/56/db/b8721d71d945e6a8ac63c0fc900b2067181dbb50805958d4d4661cf7d277/pytz-2026.1.post1.tar.gz", upload-time = 2026-03-03T07:47:50Z, size = 321088, hashes = { sha256 = "3378dde6a0c3d26719182142c56e60c7f9af7e968076f31aae569d72a0358ee1" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/10/99/781fe0c827be2742bcc775efefccb3b048a3a9c6ce9aec0cbf4a101677e5/pytz-2026.1.post1-py2.py3-none-any.whl", upload-time = 2026-03-03T07:47:49Z, size = 510489, hashes = { sha256 = "f2fd16142fda348286a75e1a524be810bb05d444e5a081f37f7affc635035f7a" } }] + +[[packages]] +name = "pyyaml" +version = "6.0.3" +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", upload-time = 2025-09-25T21:33:16Z, size = 130960, hashes = { sha256 = "d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-09-25T21:32:16Z, size = 807870, hashes = { sha256 = "ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc" } }] + +[[packages]] +name = "pyzmq" +version = "27.2.0" +sdist = { url = "https://files.pythonhosted.org/packages/e7/8d/5b3d5631c2f4b4b8862f64cd0c9eb777b5710eeb5125b4be8dd0a200a4c0/pyzmq-27.2.0.tar.gz", upload-time = 2026-08-20T19:08:21Z, size = 292316, hashes = { sha256 = "54d4259d1bfae24ecdb5ca79f7acc2eac6c286a02d6a0ae617797cb45f0726d3" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/62/2c/d5828306f795e8d34676d266823b74e2101e0ad3760d12083de3e02abbb2/pyzmq-27.2.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-08-20T19:06:44Z, size = 872258, hashes = { sha256 = "dea74fd65f1fc5f7fe167916a473ebe6ed6174e5e5d9de11ea6583661be6cf43" } }] + +[[packages]] +name = "quack-kernels" +version = "0.4.1" +sdist = { url = "https://files.pythonhosted.org/packages/2a/58/58b82e91b236539f424ff5681e7095b1f2860ddfb7778fe0be14d8fb58de/quack_kernels-0.4.1.tar.gz", upload-time = 2026-04-30T14:37:55Z, size = 274766, hashes = { sha256 = "9d7d6ba412bc0c8a9b1331c52a73db76280adb9dc2f2750df4851ddabef1466b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/38/e4/a6c3bbbe3d4242fa412454b8e8069a079e500be331aecf8f2aa666164e9c/quack_kernels-0.4.1-py3-none-any.whl", upload-time = 2026-04-30T14:37:54Z, size = 260827, hashes = { sha256 = "c1c8df2935bf5156ec47d2c5384ac08b411fd0ee702d80ae916dbf6d6f5ae813" } }] + +[[packages]] +name = "referencing" +version = "0.37.0" +sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", upload-time = 2025-10-13T15:30:48Z, size = 78036, hashes = { sha256 = "44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", upload-time = 2025-10-13T15:30:47Z, size = 26766, hashes = { sha256 = "381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231" } }] + +[[packages]] +name = "regex" +version = "2026.4.4" +sdist = { url = "https://files.pythonhosted.org/packages/cb/0e/3a246dbf05666918bd3664d9d787f84a9108f6f43cc953a077e4a7dfdb7e/regex-2026.4.4.tar.gz", upload-time = 2026-04-03T20:56:28Z, size = 416000, hashes = { sha256 = "e08270659717f6973523ce3afbafa53515c4dc5dcad637dc215b6fd50f689423" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/11/0e/a9f6f81013e0deaf559b25711623864970fe6a098314e374ccb1540a4152/regex-2026.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-03T20:53:51Z, size = 801126, hashes = { sha256 = "993f657a7c1c6ec51b5e0ba97c9817d06b84ea5fa8d82e43b9405de0defdc2b9" } }] + +[[packages]] +name = "requests" +version = "2.33.1" +sdist = { url = "https://files.pythonhosted.org/packages/5f/a4/98b9c7c6428a668bf7e42ebb7c79d576a1c3c1e3ae2d47e674b468388871/requests-2.33.1.tar.gz", upload-time = 2026-03-30T16:09:15Z, size = 134120, hashes = { sha256 = "18817f8c57c6263968bc123d237e3b8b08ac046f5456bd1e307ee8f4250d3517" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", upload-time = 2026-03-30T16:09:13Z, size = 64947, hashes = { sha256 = "4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a" } }] + +[[packages]] +name = "rfc3339-validator" +version = "0.1.4" +sdist = { url = "https://files.pythonhosted.org/packages/28/ea/a9387748e2d111c3c2b275ba970b735e04e15cdb1eb30693b6b5708c4dbd/rfc3339_validator-0.1.4.tar.gz", upload-time = 2021-05-12T16:37:54Z, size = 5513, hashes = { sha256 = "138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7b/44/4e421b96b67b2daff264473f7465db72fbdf36a07e05494f50300cc7b0c6/rfc3339_validator-0.1.4-py2.py3-none-any.whl", upload-time = 2021-05-12T16:37:52Z, size = 3490, hashes = { sha256 = "24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa" } }] + +[[packages]] +name = "rfc3986-validator" +version = "0.1.1" +sdist = { url = "https://files.pythonhosted.org/packages/da/88/f270de456dd7d11dcc808abfa291ecdd3f45ff44e3b549ffa01b126464d0/rfc3986_validator-0.1.1.tar.gz", upload-time = 2019-10-28T16:00:19Z, size = 6760, hashes = { sha256 = "3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/9e/51/17023c0f8f1869d8806b979a2bffa3f861f26a3f1a66b094288323fba52f/rfc3986_validator-0.1.1-py2.py3-none-any.whl", upload-time = 2019-10-28T16:00:13Z, size = 4242, hashes = { sha256 = "2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9" } }] + +[[packages]] +name = "rich" +version = "13.9.4" +sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", upload-time = 2024-11-01T16:43:57Z, size = 223149, hashes = { sha256 = "439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", upload-time = 2024-11-01T16:43:55Z, size = 242424, hashes = { sha256 = "6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90" } }] + +[[packages]] +name = "rpds-py" +version = "0.30.0" +sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", upload-time = 2025-11-30T20:24:38Z, size = 69469, hashes = { sha256 = "dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/60/1b/6f8f29f3f995c7ffdde46a626ddccd7c63aefc0efae881dc13b6e5d5bb16/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-30T20:22:27Z, size = 394080, hashes = { sha256 = "47f236970bccb2233267d89173d3ad2703cd36a0e2a6e92d0560d333871a3d23" } }] + +[[packages]] +name = "safetensors" +version = "0.9.0rc1" +sdist = { url = "https://files.pythonhosted.org/packages/60/82/5c68745e51b3e7432c5932c7d4f87a9b134dfe4fb81026aa70558ffeb1c1/safetensors-0.9.0rc1.tar.gz", upload-time = 2026-09-24T17:24:36Z, size = 354903, hashes = { sha256 = "8a70d139a45d71557e116339f5115afe88af2d80b08701c31ce0478d5bfc8d93" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a3/f7/93bacf08b48582f1a8837fb9af9a7a9096e0c26cc001c56d78373240259a/safetensors-0.9.0rc1-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-09-24T17:24:13Z, size = 594109, hashes = { sha256 = "d5109939a6f11d502c1656c927e3b9413f8d48dba635204c2f21cdc465e5035a" } }] + +[[packages]] +name = "scikit-learn" +version = "1.8.0" +sdist = { url = "https://files.pythonhosted.org/packages/0e/d4/40988bf3b8e34feec1d0e6a051446b1f66225f8529b9309becaeef62b6c4/scikit_learn-1.8.0.tar.gz", upload-time = 2025-12-10T07:08:53Z, size = 7335585, hashes = { sha256 = "9bccbb3b40e3de10351f8f5068e105d0f4083b1a65fa07b6634fbc401a6287fd" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/97/74/b7a304feb2b49df9fafa9382d4d09061a96ee9a9449a7cbea7988dda0828/scikit_learn-1.8.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-12-10T07:07:57Z, size = 8931904, hashes = { sha256 = "a0bcfe4d0d14aec44921545fd2af2338c7471de9cb701f1da4c9d85906ab847a" } }] + +[[packages]] +name = "scipy" +version = "1.17.1" +sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", upload-time = 2026-02-23T00:26:24Z, size = 30573822, hashes = { sha256 = "95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/01/8e/1e35281b8ab6d5d72ebe9911edcdffa3f36b04ed9d51dec6dd140396e220/scipy-1.17.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-02-23T00:18:49Z, size = 35235890, hashes = { sha256 = "02ae3b274fde71c5e92ac4d54bc06c42d80e399fec704383dcd99b301df37458" } }] + +[[packages]] +name = "send2trash" +version = "2.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/c5/f0/184b4b5f8d00f2a92cf96eec8967a3d550b52cf94362dad1100df9e48d57/send2trash-2.1.0.tar.gz", upload-time = 2026-01-14T06:27:36Z, size = 17255, hashes = { sha256 = "1c72b39f09457db3c05ce1d19158c2cbef4c32b8bedd02c155e49282b7ea7459" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/1c/78/504fdd027da3b84ff1aecd9f6957e65f35134534ccc6da8628eb71e76d3f/send2trash-2.1.0-py3-none-any.whl", upload-time = 2026-01-14T06:27:35Z, size = 17610, hashes = { sha256 = "0da2f112e6d6bb22de6aa6daa7e144831a4febf2a87261451c4ad849fe9a873c" } }] + +[[packages]] +name = "sentencepiece" +version = "0.2.1" +sdist = { url = "https://files.pythonhosted.org/packages/15/15/2e7a025fc62d764b151ae6d0f2a92f8081755ebe8d4a64099accc6f77ba6/sentencepiece-0.2.1.tar.gz", upload-time = 2025-08-12T07:00:51Z, size = 3228515, hashes = { sha256 = "8138cec27c2f2282f4a34d9a016e3374cd40e5c6e9cb335063db66a0a3b71fad" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/04/88/14f2f4a2b922d8b39be45bf63d79e6cd3a9b2f248b2fcb98a69b12af12f5/sentencepiece-0.2.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-08-12T06:59:46Z, size = 1387881, hashes = { sha256 = "0cdfecef430d985f1c2bcbfff3defd1d95dae876fbd0173376012d2d7d24044b" } }] + +[[packages]] +name = "setuptools" +version = "79.0.1" +sdist = { url = "https://files.pythonhosted.org/packages/bb/71/b6365e6325b3290e14957b2c3a804a529968c77a049b2ed40c095f749707/setuptools-79.0.1.tar.gz", upload-time = 2025-04-23T22:20:59Z, size = 1367909, hashes = { sha256 = "128ce7b8f33c3079fd1b067ecbb4051a66e8526e7b65f6cec075dfc650ddfa88" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/0d/6d/b4752b044bf94cb802d88a888dc7d288baaf77d7910b7dedda74b5ceea0c/setuptools-79.0.1-py3-none-any.whl", upload-time = 2025-04-23T22:20:56Z, size = 1256281, hashes = { sha256 = "e147c0549f27767ba362f9da434eab9c5dc0045d5304feb602a0af001089fc51" } }] + +[[packages]] +name = "shellingham" +version = "1.5.4" +sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", upload-time = 2023-10-24T04:13:40Z, size = 10310, hashes = { sha256 = "8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", upload-time = 2023-10-24T04:13:38Z, size = 9755, hashes = { sha256 = "7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686" } }] + +[[packages]] +name = "six" +version = "1.17.0" +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", upload-time = 2024-12-04T17:35:28Z, size = 34031, hashes = { sha256 = "ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", upload-time = 2024-12-04T17:35:26Z, size = 11050, hashes = { sha256 = "4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274" } }] + +[[packages]] +name = "smg-grpc-proto" +version = "0.4.10" +sdist = { url = "https://files.pythonhosted.org/packages/70/c4/e7fd91bf161fcaeb9c19e5fba73e54f7501bd310078d644700e627c4d7f9/smg_grpc_proto-0.4.10.tar.gz", upload-time = 2026-06-11T16:10:05Z, size = 19304, hashes = { sha256 = "5415618d252e5a2b43d1dbbd2c1eae305760070dd24735308140aed06a7486be" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/67/0d/d2f57ac38d2ecc9593ade6ee99953c2b2ea27e10e9532f69e3c47d2528dc/smg_grpc_proto-0.4.10-py3-none-any.whl", upload-time = 2026-06-11T16:10:04Z, size = 81122, hashes = { sha256 = "cf62b930b541ea117696d0decc2f3bd9f1f8811d066a37340e53adce3a535ccc" } }] + +[[packages]] +name = "smmap" +version = "5.0.3" +sdist = { url = "https://files.pythonhosted.org/packages/1f/ea/49c993d6dfdd7338c9b1000a0f36817ed7ec84577ae2e52f890d1a4ff909/smmap-5.0.3.tar.gz", upload-time = 2026-03-09T03:43:26Z, size = 22506, hashes = { sha256 = "4d9debb8b99007ae47165abc08670bd74cb74b5227dda7f643eccc4e9eb5642c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/c1/d4/59e74daffcb57a07668852eeeb6035af9f32cbfd7a1d2511f17d2fe6a738/smmap-5.0.3-py3-none-any.whl", upload-time = 2026-03-09T03:43:24Z, size = 24390, hashes = { sha256 = "c106e05d5a61449cf6ba9a1e650227ecfb141590d2a98412103ff35d89fc7b2f" } }] + +[[packages]] +name = "sniffio" +version = "1.3.1" +sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", upload-time = 2024-02-25T23:20:04Z, size = 20372, hashes = { sha256 = "f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", upload-time = 2024-02-25T23:20:01Z, size = 10235, hashes = { sha256 = "2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2" } }] + +[[packages]] +name = "soundfile" +version = "0.14.0" +sdist = { url = "https://files.pythonhosted.org/packages/d2/db/949331952a6fb1c5b12e9de80fd08747966c2039d1a61db4764fbd3981c2/soundfile-0.14.0.tar.gz", upload-time = 2026-06-06T08:58:47Z, size = 47842, hashes = { sha256 = "ba1c1a2d618bca5c406647c83b89f07cc8810fa506a50622a6993ba130c1de11" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/d1/5e338af9ca6ed0786cd5bb03f6d60de1c325728c1189014f3b59aae7403c/soundfile-0.14.0-py2.py3-none-any.whl", upload-time = 2026-06-06T08:58:33Z, size = 26799, hashes = { sha256 = "8ba81ae3a89fd5ab3bef8a8eb481fbbe794e806309675a89b4df48b8d31908a8" } }, + { url = "https://files.pythonhosted.org/packages/7b/a2/70fd4432b924684c372df8b0a45708c36c057ef3596c9eb53e0a806b980b/soundfile-0.14.0-py2.py3-none-manylinux_2_28_x86_64.whl", upload-time = 2026-06-06T08:58:41Z, size = 1315963, hashes = { sha256 = "1e38bac1853412871318e82a1ba69a8be677619b56025bbfcccdb41b6cafe82d" } }, +] + +[[packages]] +name = "soupsieve" +version = "2.9" +sdist = { url = "https://files.pythonhosted.org/packages/80/f1/93422647dd7e461f23d254e6b2bfa687a85b53aeb4903fcdbb74474d4584/soupsieve-2.9.tar.gz", upload-time = 2026-07-19T01:35:18Z, size = 122122, hashes = { sha256 = "acee8417325c5653e1377dc31eccad59eb82cbc65942afe6174c53b3aaad63fc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7b/d6/3185ab5ad1280319b31986898f3206dd7227cd75e293d4dba2a5e6bf27a0/soupsieve-2.9-py3-none-any.whl", upload-time = 2026-07-19T01:35:17Z, size = 37387, hashes = { sha256 = "a2b2c76d67df2382d245409fd71e321a571717e58463efa32ace87dcadac2c12" } }] + +[[packages]] +name = "soxr" +version = "1.1.0" +sdist = { url = "https://files.pythonhosted.org/packages/ed/11/27cebce4a108f77afea7c80545115536b45e3f11ebfb914f638fdd9ba847/soxr-1.1.0.tar.gz", upload-time = 2026-05-03T00:15:18Z, size = 173067, hashes = { sha256 = "9f228ae21c78fa9359ca98d8a5e8e91f30639e438e574133dace62c5b5309e44" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5c/f1/0e55195893228609c9a08c3b13b7a83a46c3a992cd00d3304f0f320cfb07/soxr-1.1.0-cp312-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-05-03T00:14:59Z, size = 240413, hashes = { sha256 = "3b033078e86f3c4a658e5697fac8995764fad9e799563616b630136b613167f1" } }] + +[[packages]] +name = "sse-starlette" +version = "3.4.4" +sdist = { url = "https://files.pythonhosted.org/packages/f7/2b/58abc2d1fd397e7dde08e947e05c884d8ef2f78d5e2588c17a12d42d6994/sse_starlette-3.4.4.tar.gz", upload-time = 2026-05-12T17:37:17Z, size = 31819, hashes = { sha256 = "07e0fa0460138baf25cdd5fb28683472c3995dc1642225191b3832d62526bcb0" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/dc/67/805710444ea8cc75fbf70b920ed431a560c4bf9c57f7d5a3117213189399/sse_starlette-3.4.4-py3-none-any.whl", upload-time = 2026-05-12T17:37:15Z, size = 16514, hashes = { sha256 = "3f4dd50d8aed2771a091f3a83000323fc3844541c16b4fe585ae2420cc6df973" } }] + +[[packages]] +name = "stack-data" +version = "0.6.3" +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", upload-time = 2023-09-30T13:58:05Z, size = 44707, hashes = { sha256 = "836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", upload-time = 2023-09-30T13:58:03Z, size = 24521, hashes = { sha256 = "d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695" } }] + +[[packages]] +name = "starlette" +version = "0.50.0" +sdist = { url = "https://files.pythonhosted.org/packages/ba/b8/73a0e6a6e079a9d9cfa64113d771e421640b6f679a52eeb9b32f72d871a1/starlette-0.50.0.tar.gz", upload-time = 2025-11-01T15:25:27Z, size = 2646985, hashes = { sha256 = "a2a17b22203254bcbc2e1f926d2d55f3f9497f769416b3190768befe598fa3ca" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/d9/52/1064f510b141bd54025f9b55105e26d1fa970b9be67ad766380a3c9b74b0/starlette-0.50.0-py3-none-any.whl", upload-time = 2025-11-01T15:25:25Z, size = 74033, hashes = { sha256 = "9e5391843ec9b6e472eed1365a78c8098cfceb7a74bfd4d6b1c0c0095efb3bca" } }] + +[[packages]] +name = "strenum" +version = "0.4.15" +sdist = { url = "https://files.pythonhosted.org/packages/85/ad/430fb60d90e1d112a62ff57bdd1f286ec73a2a0331272febfddd21f330e1/StrEnum-0.4.15.tar.gz", upload-time = 2023-06-29T22:02:58Z, size = 23384, hashes = { sha256 = "878fb5ab705442070e4dd1929bb5e2249511c0bcf2b0eeacf3bcd80875c82eff" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/81/69/297302c5f5f59c862faa31e6cb9a4cd74721cd1e052b38e464c5b402df8b/StrEnum-0.4.15-py3-none-any.whl", upload-time = 2023-06-29T22:02:56Z, size = 8851, hashes = { sha256 = "a30cda4af7cc6b5bf52c8055bc4bf4b2b6b14a93b574626da33df53cf7740659" } }] + +[[packages]] +name = "sympy" +version = "1.14.0" +sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", upload-time = 2025-04-27T18:05:01Z, size = 7793921, hashes = { sha256 = "d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", upload-time = 2025-04-27T18:04:59Z, size = 6299353, hashes = { sha256 = "e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5" } }] + +[[packages]] +name = "tabulate" +version = "0.10.0" +sdist = { url = "https://files.pythonhosted.org/packages/46/58/8c37dea7bbf769b20d58e7ace7e5edfe65b849442b00ffcdd56be88697c6/tabulate-0.10.0.tar.gz", upload-time = 2026-03-04T18:55:34Z, size = 91754, hashes = { sha256 = "e2cfde8f79420f6deeffdeda9aaec3b6bc5abce947655d17ac662b126e48a60d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/99/55/db07de81b5c630da5cbf5c7df646580ca26dfaefa593667fc6f2fe016d2e/tabulate-0.10.0-py3-none-any.whl", upload-time = 2026-03-04T18:55:31Z, size = 39814, hashes = { sha256 = "f0b0622e567335c8fabaaa659f1b33bcb6ddfe2e496071b743aa113f8774f2d3" } }] + +[[packages]] +name = "tensorrt-llm" +version = "1.3.0rc24" +sdist = { url = "https://files.pythonhosted.org/packages/35/e1/f6805f2d90490117e55c1ea5ef3a1c3587d5067a9a4e7725b178b57e0543/tensorrt_llm-1.3.0rc24.tar.gz", upload-time = 2026-08-10T16:24:48Z, size = 208449, hashes = { sha256 = "40672c4e1930d7a4dc25b08b2eb9027e0a83156473b849bf641ce1ff0b931c51" } } + +[[packages]] +name = "terminado" +version = "0.18.1" +sdist = { url = "https://files.pythonhosted.org/packages/8a/11/965c6fd8e5cc254f1fe142d547387da17a8ebfd75a3455f637c663fb38a0/terminado-0.18.1.tar.gz", upload-time = 2024-03-12T14:34:39Z, size = 32701, hashes = { sha256 = "de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/6a/9e/2064975477fdc887e47ad42157e214526dcad8f317a948dee17e1659a62f/terminado-0.18.1-py3-none-any.whl", upload-time = 2024-03-12T14:34:36Z, size = 14154, hashes = { sha256 = "a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0" } }] + +[[packages]] +name = "threadpoolctl" +version = "3.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/b7/4d/08c89e34946fce2aec4fbb45c9016efd5f4d7f24af8e5d93296e935631d8/threadpoolctl-3.6.0.tar.gz", upload-time = 2025-03-13T13:49:23Z, size = 21274, hashes = { sha256 = "8ab8b4aa3491d812b623328249fab5302a68d2d71745c8a4c719a2fcaba9f44e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", upload-time = 2025-03-13T13:49:21Z, size = 18638, hashes = { sha256 = "43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb" } }] + +[[packages]] +name = "tiktoken" +version = "0.12.0" +sdist = { url = "https://files.pythonhosted.org/packages/7d/ab/4d017d0f76ec3171d469d80fc03dfbb4e48a4bcaddaa831b31d526f05edc/tiktoken-0.12.0.tar.gz", upload-time = 2025-10-06T20:22:45Z, size = 37806, hashes = { sha256 = "b18ba7ee2b093863978fcb14f74b3707cdc8d4d4d3836853ce7ec60772139931" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/f4/90/3dae6cc5436137ebd38944d396b5849e167896fc2073da643a49f372dc4f/tiktoken-0.12.0-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2025-10-06T20:21:56Z, size = 1152665, hashes = { sha256 = "edde1ec917dfd21c1f2f8046b86348b0f54a2c0547f68149d8600859598769ad" } }] + +[[packages]] +name = "tinycss2" +version = "1.5.1" +sdist = { url = "https://files.pythonhosted.org/packages/a3/ae/2ca4913e5c0f09781d75482874c3a95db9105462a92ddd303c7d285d3df2/tinycss2-1.5.1.tar.gz", upload-time = 2025-11-23T10:29:10Z, size = 88195, hashes = { sha256 = "d339d2b616ba90ccce58da8495a78f46e55d4d25f9fd71dfd526f07e7d53f957" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/60/45/c7b5c3168458db837e8ceab06dc77824e18202679d0463f0e8f002143a97/tinycss2-1.5.1-py3-none-any.whl", upload-time = 2025-11-23T10:29:08Z, size = 28404, hashes = { sha256 = "3415ba0f5839c062696996998176c4a3751d18b7edaaeeb658c9ce21ec150661" } }] + +[[packages]] +name = "tokenizers" +version = "0.22.2" +sdist = { url = "https://files.pythonhosted.org/packages/73/6f/f80cfef4a312e1fb34baf7d85c72d4411afde10978d4657f8cdd811d3ccc/tokenizers-0.22.2.tar.gz", upload-time = 2026-01-05T10:45:15Z, size = 372115, hashes = { sha256 = "473b83b915e547aa366d1eee11806deaf419e17be16310ac0a14077f1e28f917" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2e/76/932be4b50ef6ccedf9d3c6639b056a967a86258c6d9200643f01269211ca/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-01-05T10:40:58Z, size = 3274982, hashes = { sha256 = "369cc9fc8cc10cb24143873a0d95438bb8ee257bb80c71989e3ee290e8d72c67" } }] + +[[packages]] +name = "torch" +version = "2.11.0+cu130" +wheels = [{ url = "https://download-r2.pytorch.org/whl/cu130/torch-2.11.0%2Bcu130-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-04-27T20:02:14Z, hashes = { sha256 = "96911323dcfcd42028c7e8edde7bdf25bb187753234e8775f0f3f112e86a22db" } }] + +[[packages]] +name = "torch-c-dlpack-ext" +version = "0.1.3" +sdist = { url = "https://files.pythonhosted.org/packages/34/1a/adafdc49546ffe0041f52471da51c084243094382b99332b5706e90ba26a/torch_c_dlpack_ext-0.1.3.tar.gz", upload-time = 2025-11-22T03:50:48Z, size = 3334, hashes = { sha256 = "4b5da66432af7224dcf02aad4f13cc416eeef5331cd153588b7e081a193f4972" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/64/5f/b572c13b131280e4abcb97712fee0bf40a87bfa7c1f93d263fe3c0ec0a5a/torch_c_dlpack_ext-0.1.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-11-22T03:50:34Z, size = 888188, hashes = { sha256 = "8ebf732b5079912e0b85f32a75bae6932f021fbc13c2dff1c9f7cea437b71345" } }] + +[[packages]] +name = "torchao" +version = "0.15.0+cu130" +wheels = [{ url = "https://download.pytorch.org/whl/cu130/torchao-0.15.0%2Bcu130-cp310-abi3-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-12-18T23:11:01Z, hashes = { sha256 = "2d743a43f1f345fd7a6369e37901c5a7a0a929c0f7c8acc52e717f1d70d19155" } }] + +[[packages]] +name = "torchvision" +version = "0.26.0+cu130" +wheels = [{ url = "https://download-r2.pytorch.org/whl/cu130/torchvision-0.26.0%2Bcu130-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = 2026-03-23T15:36:26Z, hashes = { sha256 = "0f030a9bd8ada1a31b7111ea1589c1ecb5fa0884fee700a203e731b4cf378a98" } }] + +[[packages]] +name = "tornado" +version = "6.6rc1" +sdist = { url = "https://files.pythonhosted.org/packages/58/9a/77d0dc2c12e4153ef89aafe2ef5e32527f86231a94080091924ed11431a7/tornado-6.6rc1.tar.gz", upload-time = 2026-10-14T17:21:07Z, size = 586938, hashes = { sha256 = "11dc9f4cb4992e7282553cbf1d9e51a4aeff0fd9c4c3779df9088f06e1f9a8f7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/95/63/a301516526a34a2d7f7993f87021c43133136a93ddf81ec43646b84a167f/tornado-6.6rc1-cp311-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", upload-time = 2026-10-14T17:20:05Z, size = 497807, hashes = { sha256 = "1e1dfedfb7b378b77bf5898e8f7f80e0047ecc194f7166faa0e1d7eed781a8b6" } }] + +[[packages]] +name = "tqdm" +version = "4.67.3" +sdist = { url = "https://files.pythonhosted.org/packages/09/a9/6ba95a270c6f1fbcd8dac228323f2777d886cb206987444e4bce66338dd4/tqdm-4.67.3.tar.gz", upload-time = 2026-02-03T17:35:53Z, size = 169598, hashes = { sha256 = "7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", upload-time = 2026-02-03T17:35:50Z, size = 78374, hashes = { sha256 = "ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf" } }] + +[[packages]] +name = "traitlets" +version = "5.14.3" +sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", upload-time = 2024-04-19T11:11:49Z, size = 161621, hashes = { sha256 = "9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", upload-time = 2024-04-19T11:11:46Z, size = 85359, hashes = { sha256 = "b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f" } }] + +[[packages]] +name = "transformers" +version = "5.5.4" +sdist = { url = "https://files.pythonhosted.org/packages/a5/1e/1e244ab2ab50a863e6b52cc55761910567fa532b69a6740f6e99c5fdbd98/transformers-5.5.4.tar.gz", upload-time = 2026-04-13T16:55:55Z, size = 8227649, hashes = { sha256 = "2e67cadba81fc7608cc07c4dd54f524820bc3d95b1cabd0ef3db7733c4f8b82e" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/29/fb/162a66789c65e5afa3b051309240c26bf37fbc8fea285b4546ae747995a2/transformers-5.5.4-py3-none-any.whl", upload-time = 2026-04-13T16:55:51Z, size = 10236696, hashes = { sha256 = "0bd6281b82966fe5a7a16f553ea517a9db1dee6284d7cb224dfd88fc0dd1c167" } }] + +[[packages]] +name = "triton" +version = "3.6.0" +wheels = [{ url = "https://download-r2.pytorch.org/whl/triton-3.6.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-01-22T23:13:42Z, hashes = { sha256 = "6f5928e6d44c34a97bbe164cceddc0ef2007121c89ebcfba5415cf452de7ee9f" } }] + +[[packages]] +name = "typer" +version = "0.21.2" +sdist = { url = "https://files.pythonhosted.org/packages/f2/1e/a27cc02a0cd715118c71fa2aef2c687fdefc3c28d90fd0dd789c5118154c/typer-0.21.2.tar.gz", upload-time = 2026-02-10T19:33:46Z, size = 120426, hashes = { sha256 = "1abd95a3b675e17ff61b0838ac637fe9478d446d62ad17fa4bb81ea57cc54028" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b8/cc/d59f893fbdfb5f58770c05febfc4086a46875f1084453621c35605cec946/typer-0.21.2-py3-none-any.whl", upload-time = 2026-02-10T19:33:48Z, size = 56728, hashes = { sha256 = "c3d8de54d00347ef90b82131ca946274f017cffb46683ae3883c360fa958f55c" } }] + +[[packages]] +name = "typing-extensions" +version = "4.15.0" +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", upload-time = 2025-08-25T13:49:26Z, size = 109391, hashes = { sha256 = "0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", upload-time = 2025-08-25T13:49:24Z, size = 44614, hashes = { sha256 = "f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548" } }] + +[[packages]] +name = "typing-inspection" +version = "0.4.2" +sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", upload-time = 2025-10-01T02:14:41Z, size = 75949, hashes = { sha256 = "ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", upload-time = 2025-10-01T02:14:40Z, size = 14611, hashes = { sha256 = "4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7" } }] + +[[packages]] +name = "tzdata" +version = "2026.2" +sdist = { url = "https://files.pythonhosted.org/packages/ba/19/1b9b0e29f30c6d35cb345486df41110984ea67ae69dddbc0e8a100999493/tzdata-2026.2.tar.gz", upload-time = 2026-04-24T15:22:08Z, size = 198254, hashes = { sha256 = "9173fde7d80d9018e02a662e168e5a2d04f87c41ea174b139fbef642eda62d10" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/ce/e4/dccd7f47c4b64213ac01ef921a1337ee6e30e8c6466046018326977efd95/tzdata-2026.2-py2.py3-none-any.whl", upload-time = 2026-04-24T15:22:05Z, size = 349321, hashes = { sha256 = "bbe9af844f658da81a5f95019480da3a89415801f6cc966806612cc7169bffe7" } }] + +[[packages]] +name = "uri-template" +version = "1.3.0" +sdist = { url = "https://files.pythonhosted.org/packages/31/c7/0336f2bd0bcbada6ccef7aaa25e443c118a704f828a0620c6fa0207c1b64/uri-template-1.3.0.tar.gz", upload-time = 2023-06-21T01:49:05Z, size = 21678, hashes = { sha256 = "0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e7/00/3fca040d7cf8a32776d3d81a00c8ee7457e00f80c649f1e4a863c8321ae9/uri_template-1.3.0-py3-none-any.whl", upload-time = 2023-06-21T01:49:03Z, size = 11140, hashes = { sha256 = "a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363" } }] + +[[packages]] +name = "urllib3" +version = "2.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", upload-time = 2026-05-07T16:13:18Z, size = 433602, hashes = { sha256 = "231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", upload-time = 2026-05-07T16:13:17Z, size = 131087, hashes = { sha256 = "9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897" } }] + +[[packages]] +name = "uvicorn" +version = "0.46.0" +sdist = { url = "https://files.pythonhosted.org/packages/1f/93/041fca8274050e40e6791f267d82e0e2e27dd165627bd640d3e0e378d877/uvicorn-0.46.0.tar.gz", upload-time = 2026-04-23T07:16:00Z, size = 88758, hashes = { sha256 = "fb9da0926999cc6cb22dc7cd71a94a632f078e6ae47ff683c5c420750fb7413d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/31/a3/5b1562db76a5a488274b2332a97199b32d0442aca0ed193697fd47786316/uvicorn-0.46.0-py3-none-any.whl", upload-time = 2026-04-23T07:15:58Z, size = 70926, hashes = { sha256 = "bbebbcbed972d162afca128605223022bedd345b7bc7855ce66deb31487a9048" } }] + +[[packages]] +name = "uvloop" +version = "0.22.1" +sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", upload-time = 2025-10-16T22:17:19Z, size = 2443250, hashes = { sha256 = "6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2025-10-16T22:16:32Z, size = 4426307, hashes = { sha256 = "7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4" } }] + +[[packages]] +name = "wcwidth" +version = "0.6.0" +sdist = { url = "https://files.pythonhosted.org/packages/35/a2/8e3becb46433538a38726c948d3399905a4c7cabd0df578ede5dc51f0ec2/wcwidth-0.6.0.tar.gz", upload-time = 2026-02-06T19:19:40Z, size = 159684, hashes = { sha256 = "cdc4e4262d6ef9a1a57e018384cbeb1208d8abbc64176027e2c2455c81313159" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/68/5a/199c59e0a824a3db2b89c5d2dade7ab5f9624dbf6448dc291b46d5ec94d3/wcwidth-0.6.0-py3-none-any.whl", upload-time = 2026-02-06T19:19:39Z, size = 94189, hashes = { sha256 = "1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad" } }] + +[[packages]] +name = "webcolors" +version = "25.10.0" +sdist = { url = "https://files.pythonhosted.org/packages/1d/7a/eb316761ec35664ea5174709a68bbd3389de60d4a1ebab8808bfc264ed67/webcolors-25.10.0.tar.gz", upload-time = 2025-10-31T07:51:03Z, size = 53491, hashes = { sha256 = "62abae86504f66d0f6364c2a8520de4a0c47b80c03fc3a5f1815fedbef7c19bf" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/e2/cc/e097523dd85c9cf5d354f78310927f1656c422bd7b2613b2db3e3f9a0f2c/webcolors-25.10.0-py3-none-any.whl", upload-time = 2025-10-31T07:51:01Z, size = 14905, hashes = { sha256 = "032c727334856fc0b968f63daa252a1ac93d33db2f5267756623c210e57a4f1d" } }] + +[[packages]] +name = "webencodings" +version = "0.6.1" +sdist = { url = "https://files.pythonhosted.org/packages/d5/a0/8fd707bcb776a7be556bad06a2ea5fb9bd519df78ef8e26f70ccf0f38bff/webencodings-0.6.1.tar.gz", upload-time = 2026-08-15T14:22:57Z, size = 15001, hashes = { sha256 = "565f9ad031c702dae404e27a099e3e09186a3ab1b9520f06d215502b651fd910" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/77/c6/040cbc72480d789a5f40d63fb484d3106554c4dfa2d2b70ad5022057750f/webencodings-0.6.1-py3-none-any.whl", upload-time = 2026-08-15T14:22:56Z, size = 8745, hashes = { sha256 = "7fab6269c8bf237c657876b52058ccb182e861518d1c695c1a9aaa8c1c105d5b" } }] + +[[packages]] +name = "websocket-client" +version = "1.9.0" +sdist = { url = "https://files.pythonhosted.org/packages/2c/41/aa4bf9664e4cda14c3b39865b12251e8e7d239f4cd0e3cc1b6c2ccde25c1/websocket_client-1.9.0.tar.gz", upload-time = 2025-10-07T21:16:36Z, size = 70576, hashes = { sha256 = "9e813624b6eb619999a97dc7958469217c3176312b3a16a4bd1bc7e08a46ec98" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/34/db/b10e48aa8fff7407e67470363eac595018441cf32d5e1001567a7aeba5d2/websocket_client-1.9.0-py3-none-any.whl", upload-time = 2025-10-07T21:16:34Z, size = 82616, hashes = { sha256 = "af248a825037ef591efbf6ed20cc5faa03d3b47b9e5a2230a529eeee1c1fc3ef" } }] + +[[packages]] +name = "xdsl" +version = "0.73.0" +sdist = { url = "https://files.pythonhosted.org/packages/bd/02/917e3d1b603110b2a9dbccbfa9b877941da5f62678a988b35c31f9ff1b61/xdsl-0.73.0.tar.gz", upload-time = 2026-10-09T19:54:26Z, size = 4302176, hashes = { sha256 = "a65edcca3a649a315e4826c43343fcbff070b60e0099b74de18a17a89f5ffdb2" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b4/d5/62438ecc0e8b3d0ddfc6894385137c0354f8daa503f4a7fa968ea04b4ab5/xdsl-0.73.0-py3-none-any.whl", upload-time = 2026-10-09T19:54:24Z, size = 4579150, hashes = { sha256 = "6e32458c1ad31a65ea047d9696fe65b998943b211f0c1eedabf17e1e2ecc5b5c" } }] + +[[packages]] +name = "xgrammar" +version = "0.1.32" +sdist = { url = "https://files.pythonhosted.org/packages/99/6a/d51b44fc0b43e2d4adae42b6a17fe9ee49e177d6d768be739ed7dec7b57e/xgrammar-0.1.32.tar.gz", upload-time = 2026-03-04T12:01:52Z, size = 2365047, hashes = { sha256 = "5d424d52779ca2d3ccaf72f2289d6519efe308e933d0d3fc3c292c780825bb12" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/69/62/65e664d861cdadf2d788c03dd8fe67f1faaa7bd4bd2317a2ab850aebee20/xgrammar-0.1.32-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-04T12:00:50Z, size = 37711100, hashes = { sha256 = "f96c7a4fcbd68e18b13cb3b6ed5d24b5326b256933f476bdaf2cc8e609c228db" } }] + +[[packages]] +name = "xxhash" +version = "3.7.0" +sdist = { url = "https://files.pythonhosted.org/packages/24/2f/e183a1b407002f5af81822bee18b61cdb94b8670208ef34734d8d2b8ebe9/xxhash-3.7.0.tar.gz", upload-time = 2026-04-25T11:10:32Z, size = 82022, hashes = { sha256 = "6cc4eefbb542a5d6ffd6d70ea9c502957c925e800f998c5630ecc809d6702bae" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/40/37/558f5a90c0672fc9b4402dc25d87ac5b7406616e8969430c9ca4e52ee74d/xxhash-3.7.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-04-25T11:06:31Z, size = 193932, hashes = { sha256 = "13805f0461cba0a857924e70ff91ae6d52d2598f79a884e788db80532614a4a1" } }] + +[[packages]] +name = "yarl" +version = "1.23.0" +sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", upload-time = 2026-03-01T22:07:53Z, size = 194676, hashes = { sha256 = "53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-03-01T22:05:23Z, size = 100132, hashes = { sha256 = "a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51" } }, + { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", upload-time = 2026-03-01T22:07:51Z, size = 48288, hashes = { sha256 = "a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f" } }, +] + +[[packages]] +name = "zipp" +version = "3.23.1" +sdist = { url = "https://files.pythonhosted.org/packages/30/21/093488dfc7cc8964ded15ab726fad40f25fd3d788fd741cc1c5a17d78ee8/zipp-3.23.1.tar.gz", upload-time = 2026-04-13T23:21:46Z, size = 25965, hashes = { sha256 = "32120e378d32cd9714ad503c1d024619063ec28aad2248dc6672ad13edfa5110" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/08/8a/0861bec20485572fbddf3dfba2910e38fe249796cb73ecdeb74e07eeb8d3/zipp-3.23.1-py3-none-any.whl", upload-time = 2026-04-13T23:21:45Z, size = 10378, hashes = { sha256 = "0b3596c50a5c700c9cb40ba8d86d9f2cc4807e9bedb06bcdf7fac85633e444dc" } }] diff --git a/packages/sie_server/bundle-locks/exceptions.json b/packages/sie_server/bundle-locks/exceptions.json new file mode 100644 index 000000000..e4ee6707d --- /dev/null +++ b/packages/sie_server/bundle-locks/exceptions.json @@ -0,0 +1,723 @@ +{ + "schema_version": 1, + "scope": "Exact version and artifact-source departures for the bundle-libs overlay only. Root-compatible overlaps remain pinned.", + "targets": { + "cpu-ctranslate2-amd64": {}, + "cpu-ctranslate2-arm64": {}, + "cpu-default-amd64": { + "jinja2": { + "artifacts_sha256": "e96bf6559614ddf31a67929e5839cdc59a172438780be978dcf32c576c1dae0e", + "reason": "Existing platform index selects a public mirror URL; downloaded SHA256 exactly equals the root-lock artifact. Record the exact URL as well as the unchanged version/bytes.", + "version": "3.1.6" + }, + "markupsafe": { + "artifacts_sha256": "51d898edcbb8ebae8046549245c206b7be9d9325e46d7af2ed7d068ac6036b56", + "reason": "Existing platform index selects a public mirror URL; downloaded SHA256 exactly equals the root-lock artifact. Record the exact URL as well as the unchanged version/bytes.", + "version": "3.0.3" + }, + "opencv-python": { + "artifacts_sha256": "ad482f49c18b6052e6b860597ebbccbd47a5e4541acea25b3e0e848398b52b09", + "reason": "Root lock records this version but no distribution artifact; the complete target closure now fixes its exact public-index artifact URLs and SHA256.", + "version": "4.13.0.92" + }, + "torch": { + "artifacts_sha256": "e77b4094acdf1ce8b83aacf2a886326faae571e3f51796cc9c1a9f3cb9834eaa", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "2.9.1+cpu" + }, + "torchvision": { + "artifacts_sha256": "1878eceaefe63d2b46088da7e14d020b0768f4b3281c7a173a037ce2f332526c", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "0.24.1+cpu" + } + }, + "cpu-default-arm64": { + "jinja2": { + "artifacts_sha256": "e96bf6559614ddf31a67929e5839cdc59a172438780be978dcf32c576c1dae0e", + "reason": "Existing platform index selects a public mirror URL; downloaded SHA256 exactly equals the root-lock artifact. Record the exact URL as well as the unchanged version/bytes.", + "version": "3.1.6" + }, + "markupsafe": { + "artifacts_sha256": "62c3dace5d1ca62491a7e0771746e778afa3000114dbc29ec028351ca216a036", + "reason": "Existing platform index selects a public mirror URL; downloaded SHA256 exactly equals the root-lock artifact. Record the exact URL as well as the unchanged version/bytes.", + "version": "3.0.3" + }, + "opencv-python": { + "artifacts_sha256": "a11ff4dc9e05cef42546db12b81ca48a3c130d1d2ef423db4cb7117e57eb4e48", + "reason": "Root lock records this version but no distribution artifact; the complete target closure now fixes its exact public-index artifact URLs and SHA256.", + "version": "4.13.0.92" + }, + "torch": { + "artifacts_sha256": "bb46edcf9e40c8f094086a919992713d2a8c04f948e98baacc9acb057cf054db", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "2.9.1+cpu" + }, + "torchvision": { + "artifacts_sha256": "e092f2e3af23d2df5372ab55b1b629777fb3843d433a0d6f61cfd269cd087cb0", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "0.24.1" + } + }, + "cpu-sglang-amd64": { + "huggingface-hub": { + "artifacts_sha256": "56260e3b49b08c3efc9997034700913e0708522013d2e317b8098bf92208636e", + "reason": "The required Transformers5 version requires huggingface-hub>=1.3 or>=1.5,<2, excluding root0.36.2.", + "version": "1.16.1" + }, + "jinja2": { + "artifacts_sha256": "e96bf6559614ddf31a67929e5839cdc59a172438780be978dcf32c576c1dae0e", + "reason": "Existing platform index selects a public mirror URL; downloaded SHA256 exactly equals the root-lock artifact. Record the exact URL as well as the unchanged version/bytes.", + "version": "3.1.6" + }, + "markupsafe": { + "artifacts_sha256": "51d898edcbb8ebae8046549245c206b7be9d9325e46d7af2ed7d068ac6036b56", + "reason": "Existing platform index selects a public mirror URL; downloaded SHA256 exactly equals the root-lock artifact. Record the exact URL as well as the unchanged version/bytes.", + "version": "3.0.3" + }, + "openai": { + "artifacts_sha256": "23eae015c24806c96e0b7c0fe8b6d3106e9562f5aee9792eb8d7c22ca240e175", + "reason": "The declared pinned SGLang engine requires this exact version, excluding the root version; retained solver conflict identifies the package pin.", + "version": "2.6.1" + }, + "timm": { + "artifacts_sha256": "ac1e32d187b99339dc83ba4640957cba61df08f7055b3c1c05aa09f58d2dcad5", + "reason": "The declared pinned SGLang engine requires this exact version, excluding the root version; retained solver conflict identifies the package pin.", + "version": "1.0.16" + }, + "torch": { + "artifacts_sha256": "e77b4094acdf1ce8b83aacf2a886326faae571e3f51796cc9c1a9f3cb9834eaa", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "2.9.1+cpu" + }, + "torchvision": { + "artifacts_sha256": "1878eceaefe63d2b46088da7e14d020b0768f4b3281c7a173a037ce2f332526c", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "0.24.1+cpu" + }, + "transformers": { + "artifacts_sha256": "3fa603d73cae20dd39945f5d9b757a4d5b60bc0316661eb4cad34e0b97d4aa6a", + "reason": "Declared TF5 bundle requires transformers>=5.17,<6, or the pinned SGLang/TensorRT engine requires its own exact TF5 version; root4.57.6 is incompatible.", + "version": "5.3.0" + }, + "triton": { + "artifacts_sha256": "0af48bf1d0c4a6facd84593b29c071f53f4a688b5b9758fc02a692c07fa7739c", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "3.5.1" + } + }, + "cpu-sglang-arm64": { + "huggingface-hub": { + "artifacts_sha256": "56260e3b49b08c3efc9997034700913e0708522013d2e317b8098bf92208636e", + "reason": "The required Transformers5 version requires huggingface-hub>=1.3 or>=1.5,<2, excluding root0.36.2.", + "version": "1.16.1" + }, + "jinja2": { + "artifacts_sha256": "e96bf6559614ddf31a67929e5839cdc59a172438780be978dcf32c576c1dae0e", + "reason": "Existing platform index selects a public mirror URL; downloaded SHA256 exactly equals the root-lock artifact. Record the exact URL as well as the unchanged version/bytes.", + "version": "3.1.6" + }, + "markupsafe": { + "artifacts_sha256": "62c3dace5d1ca62491a7e0771746e778afa3000114dbc29ec028351ca216a036", + "reason": "Existing platform index selects a public mirror URL; downloaded SHA256 exactly equals the root-lock artifact. Record the exact URL as well as the unchanged version/bytes.", + "version": "3.0.3" + }, + "openai": { + "artifacts_sha256": "23eae015c24806c96e0b7c0fe8b6d3106e9562f5aee9792eb8d7c22ca240e175", + "reason": "The declared pinned SGLang engine requires this exact version, excluding the root version; retained solver conflict identifies the package pin.", + "version": "2.6.1" + }, + "timm": { + "artifacts_sha256": "ac1e32d187b99339dc83ba4640957cba61df08f7055b3c1c05aa09f58d2dcad5", + "reason": "The declared pinned SGLang engine requires this exact version, excluding the root version; retained solver conflict identifies the package pin.", + "version": "1.0.16" + }, + "torch": { + "artifacts_sha256": "bb46edcf9e40c8f094086a919992713d2a8c04f948e98baacc9acb057cf054db", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "2.9.1+cpu" + }, + "torchvision": { + "artifacts_sha256": "e092f2e3af23d2df5372ab55b1b629777fb3843d433a0d6f61cfd269cd087cb0", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "0.24.1" + }, + "transformers": { + "artifacts_sha256": "3fa603d73cae20dd39945f5d9b757a4d5b60bc0316661eb4cad34e0b97d4aa6a", + "reason": "Declared TF5 bundle requires transformers>=5.17,<6, or the pinned SGLang/TensorRT engine requires its own exact TF5 version; root4.57.6 is incompatible.", + "version": "5.3.0" + } + }, + "cpu-transformers5-amd64": { + "huggingface-hub": { + "artifacts_sha256": "56260e3b49b08c3efc9997034700913e0708522013d2e317b8098bf92208636e", + "reason": "The required Transformers5 version requires huggingface-hub>=1.3 or>=1.5,<2, excluding root0.36.2.", + "version": "1.16.1" + }, + "jinja2": { + "artifacts_sha256": "e96bf6559614ddf31a67929e5839cdc59a172438780be978dcf32c576c1dae0e", + "reason": "Existing platform index selects a public mirror URL; downloaded SHA256 exactly equals the root-lock artifact. Record the exact URL as well as the unchanged version/bytes.", + "version": "3.1.6" + }, + "markupsafe": { + "artifacts_sha256": "51d898edcbb8ebae8046549245c206b7be9d9325e46d7af2ed7d068ac6036b56", + "reason": "Existing platform index selects a public mirror URL; downloaded SHA256 exactly equals the root-lock artifact. Record the exact URL as well as the unchanged version/bytes.", + "version": "3.0.3" + }, + "safetensors": { + "artifacts_sha256": "fa734f2119039a9ecdbccada46a9e199e91f2376597acb480847a60246950ba1", + "reason": "The required Transformers5 or TensorRT diffusers dependency requires safetensors>=0.8.0, excluding root0.7.0.", + "version": "0.8.0" + }, + "sentence-transformers": { + "artifacts_sha256": "9ee2aaf2ea1d65127c9d15578e8314e474987bdeef677b68a61b2b18f797b269", + "reason": "The transformers5 bundle explicitly requires sentence-transformers>=5.6,<6, excluding the root version.", + "version": "5.7.0" + }, + "tokenizers": { + "artifacts_sha256": "38395faa2b65845b5b92aba3072a24aec7c26e3a4fe9c080521bf6e099362850", + "reason": "The declared transformers>=5.17 bundle requires tokenizers>=0.23.1,<0.24, excluding root0.22.2.", + "version": "0.23.3" + }, + "torch": { + "artifacts_sha256": "e77b4094acdf1ce8b83aacf2a886326faae571e3f51796cc9c1a9f3cb9834eaa", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "2.9.1+cpu" + }, + "torchvision": { + "artifacts_sha256": "1878eceaefe63d2b46088da7e14d020b0768f4b3281c7a173a037ce2f332526c", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "0.24.1+cpu" + }, + "transformers": { + "artifacts_sha256": "1d611f8c0040d83f78b8fcc191f5f7058ef9f3e6ef7144a6adc12f5a008b7306", + "reason": "Declared TF5 bundle requires transformers>=5.17,<6, or the pinned SGLang/TensorRT engine requires its own exact TF5 version; root4.57.6 is incompatible.", + "version": "5.17.0" + } + }, + "cpu-transformers5-arm64": { + "huggingface-hub": { + "artifacts_sha256": "56260e3b49b08c3efc9997034700913e0708522013d2e317b8098bf92208636e", + "reason": "The required Transformers5 version requires huggingface-hub>=1.3 or>=1.5,<2, excluding root0.36.2.", + "version": "1.16.1" + }, + "jinja2": { + "artifacts_sha256": "e96bf6559614ddf31a67929e5839cdc59a172438780be978dcf32c576c1dae0e", + "reason": "Existing platform index selects a public mirror URL; downloaded SHA256 exactly equals the root-lock artifact. Record the exact URL as well as the unchanged version/bytes.", + "version": "3.1.6" + }, + "markupsafe": { + "artifacts_sha256": "62c3dace5d1ca62491a7e0771746e778afa3000114dbc29ec028351ca216a036", + "reason": "Existing platform index selects a public mirror URL; downloaded SHA256 exactly equals the root-lock artifact. Record the exact URL as well as the unchanged version/bytes.", + "version": "3.0.3" + }, + "safetensors": { + "artifacts_sha256": "0be19b01af2cd153a366c1600f0d2d600216df3bf0877c5d78c26027ad511b21", + "reason": "The required Transformers5 or TensorRT diffusers dependency requires safetensors>=0.8.0, excluding root0.7.0.", + "version": "0.8.0" + }, + "sentence-transformers": { + "artifacts_sha256": "9ee2aaf2ea1d65127c9d15578e8314e474987bdeef677b68a61b2b18f797b269", + "reason": "The transformers5 bundle explicitly requires sentence-transformers>=5.6,<6, excluding the root version.", + "version": "5.7.0" + }, + "tokenizers": { + "artifacts_sha256": "d9691de410ad294639cdad634ab9ff1e08bd5f456c9375e25de0e350647510da", + "reason": "The declared transformers>=5.17 bundle requires tokenizers>=0.23.1,<0.24, excluding root0.22.2.", + "version": "0.23.3" + }, + "torch": { + "artifacts_sha256": "bb46edcf9e40c8f094086a919992713d2a8c04f948e98baacc9acb057cf054db", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "2.9.1+cpu" + }, + "torchvision": { + "artifacts_sha256": "e092f2e3af23d2df5372ab55b1b629777fb3843d433a0d6f61cfd269cd087cb0", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "0.24.1" + }, + "transformers": { + "artifacts_sha256": "1d611f8c0040d83f78b8fcc191f5f7058ef9f3e6ef7144a6adc12f5a008b7306", + "reason": "Declared TF5 bundle requires transformers>=5.17,<6, or the pinned SGLang/TensorRT engine requires its own exact TF5 version; root4.57.6 is incompatible.", + "version": "5.17.0" + } + }, + "cuda12-ctranslate2-amd64": {}, + "cuda12-default-amd64": { + "nvidia-cublas-cu12": { + "artifacts_sha256": "193de7f3d05657a391920e601ea29c14c9d4996895e0afec29448a03cecba8d3", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.8.4.1" + }, + "nvidia-cuda-cupti-cu12": { + "artifacts_sha256": "522171550bebc4bb9224cec284795f454c35ef23ad46b276a66272bbea551b9c", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.8.90" + }, + "nvidia-cuda-nvrtc-cu12": { + "artifacts_sha256": "c5ed6ed7b2e9024ed61e553e510e8aa9d9a36e7cebea4a6505e08221dd5eff5e", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.8.93" + }, + "nvidia-cuda-runtime-cu12": { + "artifacts_sha256": "f8c03ce9074cb8f05db0b4d3670a29e13ff5774b790009c0fca86929e919960c", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.8.90" + }, + "nvidia-cufft-cu12": { + "artifacts_sha256": "847d459d9b0ae23aaa2fbc424bf07313a659543d29f96b3f1dd29ea588568c89", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "11.3.3.83" + }, + "nvidia-cufile-cu12": { + "artifacts_sha256": "9990f9558f05fd9e360fd1b354015108b929bcfe67d0ac582a3314c24156d1fd", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "1.13.1.3" + }, + "nvidia-curand-cu12": { + "artifacts_sha256": "e43b89e790741660b974e1fb79d241e0e87abceb46a194f1c1ddb2cb0d8aed22", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "10.3.9.90" + }, + "nvidia-cusolver-cu12": { + "artifacts_sha256": "58a06bc9778ae686cc717c44281868e171511a591feb0e2f1051c1828c13a343", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "11.7.3.90" + }, + "nvidia-cusparse-cu12": { + "artifacts_sha256": "edab01c9085f9a7fbc51a62e3c8b63218fbbaec47befcf6ad893b2acfe955fbe", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.5.8.93" + }, + "nvidia-nvjitlink-cu12": { + "artifacts_sha256": "1abb32d907efc9ab50a49d68e5a687139e7289ba14a737ffa2a34af45559f8e3", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.8.93" + }, + "nvidia-nvtx-cu12": { + "artifacts_sha256": "bcdc94e672488682a4dd1718db0e438e4529e694557d8edada7d7326943c1fcd", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.8.90" + }, + "opencv-python": { + "artifacts_sha256": "ad482f49c18b6052e6b860597ebbccbd47a5e4541acea25b3e0e848398b52b09", + "reason": "Root lock records this version but no distribution artifact; the complete target closure now fixes its exact public-index artifact URLs and SHA256.", + "version": "4.13.0.92" + }, + "torch": { + "artifacts_sha256": "673a1455b6af0fc86abef518ded5b73d62cbcc085335dd755c770c7c62d01245", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "2.9.1" + }, + "torchvision": { + "artifacts_sha256": "6d53ffae15eec1185f903da5a78351e7d50bb30d228468145a453effc750ea69", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "0.24.1" + } + }, + "cuda12-sglang-amd64": { + "huggingface-hub": { + "artifacts_sha256": "56260e3b49b08c3efc9997034700913e0708522013d2e317b8098bf92208636e", + "reason": "The required Transformers5 version requires huggingface-hub>=1.3 or>=1.5,<2, excluding root0.36.2.", + "version": "1.16.1" + }, + "nvidia-cublas-cu12": { + "artifacts_sha256": "193de7f3d05657a391920e601ea29c14c9d4996895e0afec29448a03cecba8d3", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.8.4.1" + }, + "nvidia-cuda-cupti-cu12": { + "artifacts_sha256": "522171550bebc4bb9224cec284795f454c35ef23ad46b276a66272bbea551b9c", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.8.90" + }, + "nvidia-cuda-nvrtc-cu12": { + "artifacts_sha256": "c5ed6ed7b2e9024ed61e553e510e8aa9d9a36e7cebea4a6505e08221dd5eff5e", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.8.93" + }, + "nvidia-cuda-runtime-cu12": { + "artifacts_sha256": "f8c03ce9074cb8f05db0b4d3670a29e13ff5774b790009c0fca86929e919960c", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.8.90" + }, + "nvidia-cufft-cu12": { + "artifacts_sha256": "847d459d9b0ae23aaa2fbc424bf07313a659543d29f96b3f1dd29ea588568c89", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "11.3.3.83" + }, + "nvidia-cufile-cu12": { + "artifacts_sha256": "9990f9558f05fd9e360fd1b354015108b929bcfe67d0ac582a3314c24156d1fd", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "1.13.1.3" + }, + "nvidia-curand-cu12": { + "artifacts_sha256": "e43b89e790741660b974e1fb79d241e0e87abceb46a194f1c1ddb2cb0d8aed22", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "10.3.9.90" + }, + "nvidia-cusolver-cu12": { + "artifacts_sha256": "58a06bc9778ae686cc717c44281868e171511a591feb0e2f1051c1828c13a343", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "11.7.3.90" + }, + "nvidia-cusparse-cu12": { + "artifacts_sha256": "edab01c9085f9a7fbc51a62e3c8b63218fbbaec47befcf6ad893b2acfe955fbe", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.5.8.93" + }, + "nvidia-nvjitlink-cu12": { + "artifacts_sha256": "1abb32d907efc9ab50a49d68e5a687139e7289ba14a737ffa2a34af45559f8e3", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.8.93" + }, + "nvidia-nvtx-cu12": { + "artifacts_sha256": "bcdc94e672488682a4dd1718db0e438e4529e694557d8edada7d7326943c1fcd", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.8.90" + }, + "openai": { + "artifacts_sha256": "23eae015c24806c96e0b7c0fe8b6d3106e9562f5aee9792eb8d7c22ca240e175", + "reason": "The declared pinned SGLang engine requires this exact version, excluding the root version; retained solver conflict identifies the package pin.", + "version": "2.6.1" + }, + "timm": { + "artifacts_sha256": "ac1e32d187b99339dc83ba4640957cba61df08f7055b3c1c05aa09f58d2dcad5", + "reason": "The declared pinned SGLang engine requires this exact version, excluding the root version; retained solver conflict identifies the package pin.", + "version": "1.0.16" + }, + "torch": { + "artifacts_sha256": "673a1455b6af0fc86abef518ded5b73d62cbcc085335dd755c770c7c62d01245", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "2.9.1" + }, + "torchvision": { + "artifacts_sha256": "6d53ffae15eec1185f903da5a78351e7d50bb30d228468145a453effc750ea69", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "0.24.1" + }, + "transformers": { + "artifacts_sha256": "3fa603d73cae20dd39945f5d9b757a4d5b60bc0316661eb4cad34e0b97d4aa6a", + "reason": "Declared TF5 bundle requires transformers>=5.17,<6, or the pinned SGLang/TensorRT engine requires its own exact TF5 version; root4.57.6 is incompatible.", + "version": "5.3.0" + } + }, + "cuda12-sglang-vision-extract-amd64": { + "huggingface-hub": { + "artifacts_sha256": "56260e3b49b08c3efc9997034700913e0708522013d2e317b8098bf92208636e", + "reason": "The required Transformers5 version requires huggingface-hub>=1.3 or>=1.5,<2, excluding root0.36.2.", + "version": "1.16.1" + }, + "nvidia-cublas-cu12": { + "artifacts_sha256": "193de7f3d05657a391920e601ea29c14c9d4996895e0afec29448a03cecba8d3", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.8.4.1" + }, + "nvidia-cuda-cupti-cu12": { + "artifacts_sha256": "522171550bebc4bb9224cec284795f454c35ef23ad46b276a66272bbea551b9c", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.8.90" + }, + "nvidia-cuda-nvrtc-cu12": { + "artifacts_sha256": "c5ed6ed7b2e9024ed61e553e510e8aa9d9a36e7cebea4a6505e08221dd5eff5e", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.8.93" + }, + "nvidia-cuda-runtime-cu12": { + "artifacts_sha256": "f8c03ce9074cb8f05db0b4d3670a29e13ff5774b790009c0fca86929e919960c", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.8.90" + }, + "nvidia-cufft-cu12": { + "artifacts_sha256": "847d459d9b0ae23aaa2fbc424bf07313a659543d29f96b3f1dd29ea588568c89", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "11.3.3.83" + }, + "nvidia-cufile-cu12": { + "artifacts_sha256": "9990f9558f05fd9e360fd1b354015108b929bcfe67d0ac582a3314c24156d1fd", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "1.13.1.3" + }, + "nvidia-curand-cu12": { + "artifacts_sha256": "e43b89e790741660b974e1fb79d241e0e87abceb46a194f1c1ddb2cb0d8aed22", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "10.3.9.90" + }, + "nvidia-cusolver-cu12": { + "artifacts_sha256": "58a06bc9778ae686cc717c44281868e171511a591feb0e2f1051c1828c13a343", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "11.7.3.90" + }, + "nvidia-cusparse-cu12": { + "artifacts_sha256": "edab01c9085f9a7fbc51a62e3c8b63218fbbaec47befcf6ad893b2acfe955fbe", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.5.8.93" + }, + "nvidia-nvjitlink-cu12": { + "artifacts_sha256": "1abb32d907efc9ab50a49d68e5a687139e7289ba14a737ffa2a34af45559f8e3", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.8.93" + }, + "nvidia-nvtx-cu12": { + "artifacts_sha256": "bcdc94e672488682a4dd1718db0e438e4529e694557d8edada7d7326943c1fcd", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.8.90" + }, + "openai": { + "artifacts_sha256": "23eae015c24806c96e0b7c0fe8b6d3106e9562f5aee9792eb8d7c22ca240e175", + "reason": "The declared pinned SGLang engine requires this exact version, excluding the root version; retained solver conflict identifies the package pin.", + "version": "2.6.1" + }, + "timm": { + "artifacts_sha256": "ac1e32d187b99339dc83ba4640957cba61df08f7055b3c1c05aa09f58d2dcad5", + "reason": "The declared pinned SGLang engine requires this exact version, excluding the root version; retained solver conflict identifies the package pin.", + "version": "1.0.16" + }, + "torch": { + "artifacts_sha256": "673a1455b6af0fc86abef518ded5b73d62cbcc085335dd755c770c7c62d01245", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "2.9.1" + }, + "torchvision": { + "artifacts_sha256": "6d53ffae15eec1185f903da5a78351e7d50bb30d228468145a453effc750ea69", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "0.24.1" + }, + "transformers": { + "artifacts_sha256": "3fa603d73cae20dd39945f5d9b757a4d5b60bc0316661eb4cad34e0b97d4aa6a", + "reason": "Declared TF5 bundle requires transformers>=5.17,<6, or the pinned SGLang/TensorRT engine requires its own exact TF5 version; root4.57.6 is incompatible.", + "version": "5.3.0" + } + }, + "cuda12-transformers5-amd64": { + "huggingface-hub": { + "artifacts_sha256": "56260e3b49b08c3efc9997034700913e0708522013d2e317b8098bf92208636e", + "reason": "The required Transformers5 version requires huggingface-hub>=1.3 or>=1.5,<2, excluding root0.36.2.", + "version": "1.16.1" + }, + "nvidia-cublas-cu12": { + "artifacts_sha256": "193de7f3d05657a391920e601ea29c14c9d4996895e0afec29448a03cecba8d3", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.8.4.1" + }, + "nvidia-cuda-cupti-cu12": { + "artifacts_sha256": "522171550bebc4bb9224cec284795f454c35ef23ad46b276a66272bbea551b9c", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.8.90" + }, + "nvidia-cuda-nvrtc-cu12": { + "artifacts_sha256": "c5ed6ed7b2e9024ed61e553e510e8aa9d9a36e7cebea4a6505e08221dd5eff5e", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.8.93" + }, + "nvidia-cuda-runtime-cu12": { + "artifacts_sha256": "f8c03ce9074cb8f05db0b4d3670a29e13ff5774b790009c0fca86929e919960c", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.8.90" + }, + "nvidia-cufft-cu12": { + "artifacts_sha256": "847d459d9b0ae23aaa2fbc424bf07313a659543d29f96b3f1dd29ea588568c89", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "11.3.3.83" + }, + "nvidia-cufile-cu12": { + "artifacts_sha256": "9990f9558f05fd9e360fd1b354015108b929bcfe67d0ac582a3314c24156d1fd", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "1.13.1.3" + }, + "nvidia-curand-cu12": { + "artifacts_sha256": "e43b89e790741660b974e1fb79d241e0e87abceb46a194f1c1ddb2cb0d8aed22", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "10.3.9.90" + }, + "nvidia-cusolver-cu12": { + "artifacts_sha256": "58a06bc9778ae686cc717c44281868e171511a591feb0e2f1051c1828c13a343", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "11.7.3.90" + }, + "nvidia-cusparse-cu12": { + "artifacts_sha256": "edab01c9085f9a7fbc51a62e3c8b63218fbbaec47befcf6ad893b2acfe955fbe", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.5.8.93" + }, + "nvidia-nvjitlink-cu12": { + "artifacts_sha256": "1abb32d907efc9ab50a49d68e5a687139e7289ba14a737ffa2a34af45559f8e3", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.8.93" + }, + "nvidia-nvtx-cu12": { + "artifacts_sha256": "bcdc94e672488682a4dd1718db0e438e4529e694557d8edada7d7326943c1fcd", + "reason": "The unchanged CUDA12 image index route selects PyPI torch2.9.1 (CUDA12.8); its exact NVIDIA dependencies conflict with the root CUDA12.9 versions. All solver failures are retained in the root-wide constraint probes.", + "version": "12.8.90" + }, + "safetensors": { + "artifacts_sha256": "fa734f2119039a9ecdbccada46a9e199e91f2376597acb480847a60246950ba1", + "reason": "The required Transformers5 or TensorRT diffusers dependency requires safetensors>=0.8.0, excluding root0.7.0.", + "version": "0.8.0" + }, + "sentence-transformers": { + "artifacts_sha256": "9ee2aaf2ea1d65127c9d15578e8314e474987bdeef677b68a61b2b18f797b269", + "reason": "The transformers5 bundle explicitly requires sentence-transformers>=5.6,<6, excluding the root version.", + "version": "5.7.0" + }, + "tokenizers": { + "artifacts_sha256": "38395faa2b65845b5b92aba3072a24aec7c26e3a4fe9c080521bf6e099362850", + "reason": "The declared transformers>=5.17 bundle requires tokenizers>=0.23.1,<0.24, excluding root0.22.2.", + "version": "0.23.3" + }, + "torch": { + "artifacts_sha256": "673a1455b6af0fc86abef518ded5b73d62cbcc085335dd755c770c7c62d01245", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "2.9.1" + }, + "torchvision": { + "artifacts_sha256": "6d53ffae15eec1185f903da5a78351e7d50bb30d228468145a453effc750ea69", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "0.24.1" + }, + "transformers": { + "artifacts_sha256": "1d611f8c0040d83f78b8fcc191f5f7058ef9f3e6ef7144a6adc12f5a008b7306", + "reason": "Declared TF5 bundle requires transformers>=5.17,<6, or the pinned SGLang/TensorRT engine requires its own exact TF5 version; root4.57.6 is incompatible.", + "version": "5.17.0" + } + }, + "cuda13-sglang-cu130-amd64": { + "grpcio": { + "artifacts_sha256": "6998304d93ff54fc5f18a24951ae987db7a4d08b68706087bc6a191e41e9e783", + "reason": "The pinned SGLang cu130 dependency requires grpcio>=1.81.1, excluding root1.78.0.", + "version": "1.85.0rc1" + }, + "huggingface-hub": { + "artifacts_sha256": "56260e3b49b08c3efc9997034700913e0708522013d2e317b8098bf92208636e", + "reason": "The required Transformers5 version requires huggingface-hub>=1.3 or>=1.5,<2, excluding root0.36.2.", + "version": "1.16.1" + }, + "jinja2": { + "artifacts_sha256": "e96bf6559614ddf31a67929e5839cdc59a172438780be978dcf32c576c1dae0e", + "reason": "Existing platform index selects a public mirror URL; downloaded SHA256 exactly equals the root-lock artifact. Record the exact URL as well as the unchanged version/bytes.", + "version": "3.1.6" + }, + "markupsafe": { + "artifacts_sha256": "51d898edcbb8ebae8046549245c206b7be9d9325e46d7af2ed7d068ac6036b56", + "reason": "Existing platform index selects a public mirror URL; downloaded SHA256 exactly equals the root-lock artifact. Record the exact URL as well as the unchanged version/bytes.", + "version": "3.0.3" + }, + "numpy": { + "artifacts_sha256": "3fbf0ec574a1481739cb8f9dc98d7ad16d60938af33fe38cf3f878fec24882ad", + "reason": "The pinned engine requires numpy<2.4 (SGLang numba or TensorRT requirement), excluding root2.4.4.", + "version": "2.3.5" + }, + "openai": { + "artifacts_sha256": "23eae015c24806c96e0b7c0fe8b6d3106e9562f5aee9792eb8d7c22ca240e175", + "reason": "The declared pinned SGLang engine requires this exact version, excluding the root version; retained solver conflict identifies the package pin.", + "version": "2.6.1" + }, + "timm": { + "artifacts_sha256": "ac1e32d187b99339dc83ba4640957cba61df08f7055b3c1c05aa09f58d2dcad5", + "reason": "The declared pinned SGLang engine requires this exact version, excluding the root version; retained solver conflict identifies the package pin.", + "version": "1.0.16" + }, + "torch": { + "artifacts_sha256": "41bdb56a153ea74938b435fd5a8c72f8befe0d6b1901397b4cf0020eee311068", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "2.13.0+cu130" + }, + "torchvision": { + "artifacts_sha256": "293481015a497abcbb8bb61e0bdc3a1bea29cfcb5243e61c98ddf7bccbaf51bf", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "0.28.0+cu130" + }, + "transformers": { + "artifacts_sha256": "3e2e3fea948e0afaadd128eec5e96a8cedd9a33c106d0c085c905fe45998d090", + "reason": "Declared TF5 bundle requires transformers>=5.17,<6, or the pinned SGLang/TensorRT engine requires its own exact TF5 version; root4.57.6 is incompatible.", + "version": "5.12.1" + }, + "triton": { + "artifacts_sha256": "fbf9f785095b8fe790eecd3bceff3b493ee6f89c8aaf5736f58d1430665fdba0", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "3.7.1" + } + }, + "cuda13-tensorrt-llm-amd64": { + "click": { + "artifacts_sha256": "9bd22e1f54f8fa5a492b8d7013d168ba12beb8e242e7624755bea481fb5593a8", + "reason": "TensorRT-LLM1.3.0rc24 declares a constraint incompatible with the root pin; the retained root-wide solver failure records the exact required range/version.", + "version": "8.3.3" + }, + "datasets": { + "artifacts_sha256": "7ed98b50c6e920cab7b3c7251bbafdb767bbc447d6eabc297dcdff47b4b73c71", + "reason": "TensorRT-LLM1.3.0rc24 declares a constraint incompatible with the root pin; the retained root-wide solver failure records the exact required range/version.", + "version": "3.1.0" + }, + "fastapi": { + "artifacts_sha256": "6c7a1a2731c2e421d92e4947c79ea5f75b4600eafcb36eb1fadd586177b1e308", + "reason": "TensorRT-LLM1.3.0rc24 declares a constraint incompatible with the root pin; the retained root-wide solver failure records the exact required range/version.", + "version": "0.121.3" + }, + "fsspec": { + "artifacts_sha256": "62803e69c62b30aa45c9691c06d226f3124218ae309559a23fe733815ae47343", + "reason": "TensorRT-LLM1.3.0rc24 requires datasets3.1.0, which requires fsspec[http]>=2023.1.0,<=2024.9.0; root2025.3.0 is incompatible.", + "version": "2024.9.0" + }, + "huggingface-hub": { + "artifacts_sha256": "56260e3b49b08c3efc9997034700913e0708522013d2e317b8098bf92208636e", + "reason": "The required Transformers5 version requires huggingface-hub>=1.3 or>=1.5,<2, excluding root0.36.2.", + "version": "1.16.1" + }, + "jinja2": { + "artifacts_sha256": "e96bf6559614ddf31a67929e5839cdc59a172438780be978dcf32c576c1dae0e", + "reason": "Existing platform index selects a public mirror URL; downloaded SHA256 exactly equals the root-lock artifact. Record the exact URL as well as the unchanged version/bytes.", + "version": "3.1.6" + }, + "markupsafe": { + "artifacts_sha256": "51d898edcbb8ebae8046549245c206b7be9d9325e46d7af2ed7d068ac6036b56", + "reason": "Existing platform index selects a public mirror URL; downloaded SHA256 exactly equals the root-lock artifact. Record the exact URL as well as the unchanged version/bytes.", + "version": "3.0.3" + }, + "numpy": { + "artifacts_sha256": "3fbf0ec574a1481739cb8f9dc98d7ad16d60938af33fe38cf3f878fec24882ad", + "reason": "The pinned engine requires numpy<2.4 (SGLang numba or TensorRT requirement), excluding root2.4.4.", + "version": "2.3.5" + }, + "peft": { + "artifacts_sha256": "3f459baeb5e3c64a2180bff5c9b43ef94142349116788cc32b5ded94f9750161", + "reason": "TensorRT-LLM1.3.0rc24 declares a constraint incompatible with the root pin; the retained root-wide solver failure records the exact required range/version.", + "version": "0.18.1" + }, + "safetensors": { + "artifacts_sha256": "96b44c6819cabbd2240a22efcc2f1e44adfe49afea24f8f33502debca29e92c5", + "reason": "The required Transformers5 or TensorRT diffusers dependency requires safetensors>=0.8.0, excluding root0.7.0.", + "version": "0.9.0rc1" + }, + "setuptools": { + "artifacts_sha256": "0b9ee7d244ab5c9cb32d4e7f5a750d9e94da2e3febabd3d213dcea5377d148fb", + "reason": "TensorRT-LLM1.3.0rc24 declares a constraint incompatible with the root pin; the retained root-wide solver failure records the exact required range/version.", + "version": "79.0.1" + }, + "starlette": { + "artifacts_sha256": "eb3e0ee400ba4893d92bf7b4519d0ac6b0fb1aecdc7b66ede7c916e30bd478be", + "reason": "TensorRT-LLM1.3.0rc24 requires fastapi>=0.120.1,<=0.121.3, whose starlette>=0.40,<0.51 excludes root1.3.1.", + "version": "0.50.0" + }, + "torch": { + "artifacts_sha256": "a61a321662e1f671d8e5bb9d7e273d9849b9fe5b6f5d01f00df11be4b5aabdc4", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "2.11.0+cu130" + }, + "torchvision": { + "artifacts_sha256": "901f12ee9a56a61f1737a1722090530ad4fad71d8398d6c62d168817afb5b092", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "0.26.0+cu130" + }, + "transformers": { + "artifacts_sha256": "77d6ecbc010c739b6fd7e57d5a5b920f007624091e5fc01e2ff22936ca4ce473", + "reason": "Declared TF5 bundle requires transformers>=5.17,<6, or the pinned SGLang/TensorRT engine requires its own exact TF5 version; root4.57.6 is incompatible.", + "version": "5.5.4" + }, + "triton": { + "artifacts_sha256": "f0a5cfceb3e8e2b6d740fe70811943e0cead6c9572aea6736b5837b66967c572", + "reason": "Preserve the existing platform-specific public-index route and the engine Torch/vision/triton pairing. CPU and cu130 artifacts are explicit variants; exact source/version is recorded instead of silently inheriting the root CUDA12.9 build.", + "version": "3.6.0" + } + } + } +} diff --git a/packages/sie_server/src/sie_server/bundle_lock.py b/packages/sie_server/src/sie_server/bundle_lock.py new file mode 100644 index 000000000..8e8cdcdf1 --- /dev/null +++ b/packages/sie_server/src/sie_server/bundle_lock.py @@ -0,0 +1,485 @@ +"""Check saved bundle closures and the inventory installed from those locks. + +This is build tooling: it never imports a model runtime. The scope is the +``bundle-libs`` overlay, not the separately resolved base virtual environment. +""" + +from __future__ import annotations + +import argparse +import hashlib +import importlib.metadata +import json +import platform as host_platform +import re +import sys +import tomllib +from collections.abc import Mapping, Sequence +from dataclasses import dataclass +from pathlib import Path +from typing import Any +from urllib.parse import unquote, urlsplit, urlunsplit + +import yaml +from packaging.markers import Marker +from packaging.requirements import Requirement +from packaging.utils import canonicalize_name, parse_wheel_filename +from packaging.version import Version + +from sie_server.bundle_requirements import resolve_bundle_requirements + +SCHEMA_VERSION = 1 +UV_VERSION = "0.9.28" +PYTHON_VERSION = "3.12" +_MACHINES = {"amd64": "x86_64", "arm64": "aarch64"} +_SHA256 = re.compile(r"[0-9a-f]{64}\Z") +_GIT_SHA = re.compile(r"[0-9a-f]{40}\Z") + + +def digest(path: Path) -> str: + """Hash a build input without interpreting it.""" + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def canonical_digest(value: object) -> str: + """Hash JSON data independently of indentation or dictionary order.""" + return hashlib.sha256(json.dumps(value, sort_keys=True, separators=(",", ":")).encode()).hexdigest() + + +def policy_digest(compiler: Path | None = None) -> str: + """Bind the exact verifier, declaration resolver and compilation policy.""" + if compiler is None: + compiler = Path(__file__).resolve().parents[4] / "tools/ci/bundle_lock.py" + return canonical_digest( + { + "verifier": digest(Path(__file__)), + "requirements": digest(Path(__file__).with_name("bundle_requirements.py")), + "compiler": digest(compiler), + } + ) + + +@dataclass(frozen=True) +class Target: + """One image overlay, with an explicit architecture and Python ABI.""" + + platform: str + bundle: str + architecture: str + + def __post_init__(self) -> None: + if self.platform not in {"cpu", "cuda12", "cuda13"} or self.architecture not in _MACHINES: + msg = "unsupported bundle lock platform or architecture" + raise ValueError(msg) + if not re.fullmatch(r"[a-z0-9]+(?:-[a-z0-9]+)*", self.bundle): + msg = "invalid bundle name" + raise ValueError(msg) + + @property + def name(self) -> str: + return f"{self.platform}-{self.bundle}-{self.architecture}" + + @property + def python_platform(self) -> str: + return f"{_MACHINES[self.architecture]}-manylinux_2_35" + + def as_dict(self) -> dict[str, str]: + return { + "platform": self.platform, + "bundle": self.bundle, + "architecture": self.architecture, + "python_version": PYTHON_VERSION, + "python_platform": self.python_platform, + } + + def marker_environment(self) -> dict[str, str]: + return { + "implementation_name": "cpython", + "implementation_version": "3.12.0", + "os_name": "posix", + "platform_machine": _MACHINES[self.architecture], + "platform_python_implementation": "CPython", + "platform_release": "", + "platform_system": "Linux", + "platform_version": "", + "python_full_version": "3.12.0", + "python_version": PYTHON_VERSION, + "sys_platform": "linux", + "extra": "", + } + + +def bundle_requirements(bundles: Path, target: Target) -> list[str]: + """Use the same declaration and CPU exclusions as resolve-deps.""" + data = yaml.safe_load((bundles / f"{target.bundle}.yaml").read_text(encoding="utf-8")) + return resolve_bundle_requirements(data["deps"], exclude_cuda=target.platform == "cpu") + + +def root_packages(root_lock: Path) -> dict[str, list[dict[str, Any]]]: + """Keep exact versions and artifact sources, including local Torch builds.""" + result: dict[str, list[dict[str, Any]]] = {} + for row in tomllib.loads(root_lock.read_text(encoding="utf-8"))["package"]: + source = row.get("source", {}) + if "editable" in source or "virtual" in source: + continue # Workspace projects are installed separately from bundle-libs. + if "version" not in row or not ({"registry", "url", "git"} & source.keys()): + msg = f"unsupported root package source: {row.get('name')}" + raise ValueError(msg) + result.setdefault(canonicalize_name(row["name"]), []).append(row) + return result + + +def root_constraints(root_lock: Path, exceptions: Mapping[str, Mapping[str, str]]) -> list[str]: + """Pin every root package, except an explicitly recorded exact alternative. + + ``==2.9.1`` admits a local build such as ``+cpu`` but excludes ``.post1``. + The artifact and exact local version are checked separately against the + exception manifest. This never drops an entire untrusted transitive graph. + """ + result = [] + for name, rows in sorted(root_packages(root_lock).items()): + if name in exceptions: + version = exceptions[name]["version"] + else: + versions = {Version(row["version"]).public for row in rows} + if len(versions) != 1: + msg = f"root has multiple public versions of {name}; record an exact target exception" + raise ValueError(msg) + version = versions.pop() + Version(version) + result.append(f"{name}=={version}") + return result + + +def _public_url(value: object) -> str: + if not isinstance(value, str): + msg = "lock source URL must be a string" + raise ValueError(msg) + url = urlsplit(value) + if url.scheme != "https" or not url.hostname or url.username or url.password: + msg = "lock sources must use credential-free HTTPS" + raise ValueError(msg) + return value + + +def artifact_sources(package: Mapping[str, Any]) -> list[dict[str, str]]: + """Canonical immutable source identities, excluding upload-time metadata.""" + if "vcs" in package: + vcs = package["vcs"] + commit = vcs.get("commit-id", "") + if vcs.get("type") != "git" or not isinstance(commit, str) or not _GIT_SHA.fullmatch(commit): + msg = "VCS lock source requires an exact Git commit" + raise ValueError(msg) + return [{"url": _public_url(vcs.get("url")), "git_commit": commit}] + artifacts = list(package.get("wheels", [])) + artifacts.extend(package[key] for key in ("sdist", "archive") if key in package) + if not artifacts: + msg = f"no immutable artifact for {package.get('name')}" + raise ValueError(msg) + result = [] + for artifact in artifacts: + sha = artifact.get("hashes", {}).get("sha256", "") + if not isinstance(sha, str) or not _SHA256.fullmatch(sha): + msg = "every locked artifact requires SHA256" + raise ValueError(msg) + result.append({"url": _public_url(artifact.get("url")), "sha256": sha}) + return sorted(result, key=lambda row: row["url"]) + + +def read_packages(path: Path, target: Target) -> dict[str, dict[str, Any]]: + """Read a fixed-target PEP751 lock, refusing unbound or duplicate entries.""" + data = tomllib.loads(path.read_text(encoding="utf-8")) + if data.get("lock-version") != "1.0": + msg = "unsupported bundle lock format" + raise ValueError(msg) + result = {} + for row in data.get("packages", []): + if row.get("marker") and not Marker(row["marker"]).evaluate(target.marker_environment()): + continue + name = canonicalize_name(row["name"]) + Version(row["version"]) + artifact_sources(row) + if name in result: + msg = f"duplicate locked distribution: {name}" + raise ValueError(msg) + wheels = row.get("wheels", []) + if wheels: + compatible = False + for wheel in wheels: + filename = unquote(urlsplit(wheel["url"]).path).rsplit("/", maxsplit=1)[-1] + wheel_name, version, _build, tags = parse_wheel_filename(filename) + if wheel_name != name or version != Version(row["version"]): + msg = f"locked wheel identity differs for {name}" + raise ValueError(msg) + compatible |= any( + tag.platform == "any" or tag.platform.endswith(_MACHINES[target.architecture]) for tag in tags + ) + if not compatible: + msg = f"locked wheel architecture differs for {name}" + raise ValueError(msg) + result[name] = row + if not result: + msg = "bundle lock has no packages for the selected target" + raise ValueError(msg) + return result + + +def _root_artifacts(rows: Sequence[Mapping[str, Any]]) -> set[tuple[str, str]]: + result = set() + for row in rows: + if "git" in row["source"]: + url = urlsplit(row["source"]["git"]) + if not _GIT_SHA.fullmatch(url.fragment): + msg = "root VCS source requires an exact Git commit" + raise ValueError(msg) + result.add((_public_url(urlunsplit(url._replace(query="", fragment=""))), url.fragment)) + for artifact in [*row.get("wheels", []), *([row["sdist"]] if "sdist" in row else [])]: + result.add((artifact["url"], artifact["hash"].removeprefix("sha256:"))) + return result + + +def required_exceptions( + packages: Mapping[str, Mapping[str, Any]], + root_lock: Path, +) -> dict[str, dict[str, str]]: + """Report exact version/source deviations; this does not approve them.""" + root = root_packages(root_lock) + result = {} + for name, package in packages.items(): + if name not in root: + continue + same_version = [row for row in root[name] if Version(row["version"]) == Version(package["version"])] + sources = artifact_sources(package) + allowed = _root_artifacts(same_version) + if not same_version or any( + (row["url"], row.get("sha256", row.get("git_commit", ""))) not in allowed for row in sources + ): + result[name] = {"version": package["version"], "artifacts_sha256": canonical_digest(sources)} + return result + + +def validate_exceptions( + packages: Mapping[str, Mapping[str, Any]], + root_lock: Path, + exceptions: Mapping[str, Mapping[str, str]], +) -> None: + """Fail on an unapproved deviation, stale exception, or changed source.""" + required = required_exceptions(packages, root_lock) + if set(required) != set(exceptions): + msg = f"bundle exceptions differ: missing={sorted(set(required) - set(exceptions))}, stale={sorted(set(exceptions) - set(required))}" + raise ValueError(msg) + for name, expected in required.items(): + exception = exceptions[name] + if ( + any(exception.get(key) != value for key, value in expected.items()) + or not exception.get("reason", "").strip() + ): + msg = f"version/source exception is not exact or documented: {name}" + raise ValueError(msg) + + +def _check_requirement_source(requirement: Requirement, package: Mapping[str, Any]) -> None: + if requirement.url is None: + return + if requirement.url.startswith("git+"): + url, separator, commit = requirement.url.removeprefix("git+").rpartition("@") + vcs = package.get("vcs", {}) + if not separator or not _GIT_SHA.fullmatch(commit) or vcs.get("url") != url or vcs.get("commit-id") != commit: + msg = f"bundle declared VCS source differs: {requirement.name}" + raise ValueError(msg) + elif requirement.url != package.get("archive", {}).get("url"): + msg = f"bundle declared archive source differs: {requirement.name}" + raise ValueError(msg) + + +def check_lock( + lock_dir: Path, bundles: Path, root_lock: Path, target: Target, *, compiler: Path | None = None +) -> dict[str, Any]: + """Bind a saved closure to current inputs, target, and reviewed exceptions.""" + folder = lock_dir / target.name + if not folder.is_dir(): + msg = f"unsupported bundle lock target: {target.name}" + raise ValueError(msg) + manifest = json.loads((folder / "manifest.json").read_text(encoding="utf-8")) + exception_file = json.loads((lock_dir / "exceptions.json").read_text(encoding="utf-8")) + if manifest.get("schema_version") != SCHEMA_VERSION or exception_file.get("schema_version") != SCHEMA_VERSION: + msg = "unsupported bundle manifest schema" + raise ValueError(msg) + if manifest.get("target") != target.as_dict() or manifest.get("uv_version") != UV_VERSION: + msg = "bundle manifest target or installer differs" + raise ValueError(msg) + if manifest.get("policy_sha256") != policy_digest(compiler): + msg = "bundle compilation or verification policy changed; recompile and review" + raise ValueError(msg) + requirements = bundle_requirements(bundles, target) + expected_inputs = {"uv_lock_sha256": digest(root_lock), "requirements_sha256": canonical_digest(requirements)} + exceptions = exception_file["targets"].get(target.name, {}) + if manifest.get("inputs") != expected_inputs or manifest.get("exceptions_sha256") != canonical_digest(exceptions): + msg = "bundle lock inputs changed; recompile and review the complete closure" + raise ValueError(msg) + lock = folder / "pylock.toml" + if manifest.get("lock_sha256") != digest(lock): + msg = "bundle lock hash differs" + raise ValueError(msg) + packages = read_packages(lock, target) + validate_exceptions(packages, root_lock, exceptions) + for line in requirements: + requirement = Requirement(line) + if requirement.marker is not None and not requirement.marker.evaluate(target.marker_environment()): + continue + name = canonicalize_name(requirement.name) + if name not in packages or not requirement.specifier.contains(packages[name]["version"], prereleases=True): + msg = f"bundle declaration is not satisfied: {name}" + raise ValueError(msg) + _check_requirement_source(requirement, packages[name]) + return {"manifest": manifest, "packages": packages, "requirements": requirements} + + +def _check_direct_source(package: Mapping[str, Any], direct: Mapping[str, Any] | None) -> None: + name = package["name"] + if "vcs" in package: + vcs = package["vcs"] + if ( + not direct + or direct.get("url") != vcs["url"] + or direct.get("vcs_info", {}).get("commit_id") != vcs["commit-id"] + ): + msg = f"installed VCS source differs: {name}" + raise ValueError(msg) + elif "archive" in package: + archive = package["archive"] + if not direct or direct.get("url") != archive["url"]: + msg = f"installed archive source differs: {name}" + raise ValueError(msg) + _check_recorded_hash(direct, archive["hashes"]["sha256"], name) + elif direct is not None: + # uv may preserve a direct wheel URL when installing PEP751 locks. + allowed = {row["url"]: row.get("sha256") for row in artifact_sources(package)} + if direct.get("url") not in allowed: + msg = f"installed artifact source differs: {name}" + raise ValueError(msg) + _check_recorded_hash(direct, allowed[direct["url"]], name) + + +def _check_recorded_hash(direct: Mapping[str, Any], expected: str | None, name: str) -> None: + # uv0.9.28 checks the PEP751 hash during installation but writes an empty + # archive_info in PEP610 metadata. Check a hash when recorded; do not claim + # installed metadata independently proves the downloaded artifact's bytes. + info = direct.get("archive_info", {}) + hashes = info.get("hashes", {}) + if (hashes and hashes.get("sha256") != expected) or (info.get("hash") and info["hash"] != f"sha256={expected}"): + msg = f"installed recorded artifact hash differs: {name}" + raise ValueError(msg) + + +def _validate_dependencies( + distributions: Mapping[str, importlib.metadata.Distribution], + packages: Mapping[str, Mapping[str, Any]], + requirements: Sequence[str], + target: Target, +) -> None: + extras: dict[str, set[str]] = {name: {""} for name in distributions} + for line in requirements: + req = Requirement(line) + if req.marker is None or req.marker.evaluate(target.marker_environment()): + extras[canonicalize_name(req.name)].update(req.extras) + visited = set() + while pending := [ + (name, extra) for name, values in extras.items() for extra in values if (name, extra) not in visited + ]: + for name, extra in pending: + visited.add((name, extra)) + # The saved target fixes the ABI. A patch-specific installed + # requirement must still be checked against this actual Python. + marker = target.marker_environment() | { + "extra": extra, + "python_full_version": host_platform.python_version(), + "implementation_version": host_platform.python_version(), + } + for line in distributions[name].requires or []: + req = Requirement(line) + if req.marker is not None and not req.marker.evaluate(marker): + continue + dependency = canonicalize_name(req.name) + if dependency not in distributions or not req.specifier.contains( + distributions[dependency].version, prereleases=True + ): + msg = f"installed dependency is not satisfied: {name} requires {dependency}" + raise ValueError(msg) + extras[dependency].update(req.extras) + _check_requirement_source(req, packages[dependency]) + + +def verify_inventory( + checked: Mapping[str, Any], + installed: Path, + target: Target, +) -> dict[str, Any]: + """Inspect installed metadata, never import the distribution's code.""" + packages = checked["packages"] + distributions = {} + rows = [] + for dist in importlib.metadata.distributions(path=[str(installed)]): + name = canonicalize_name(dist.metadata["Name"]) + if name in distributions: + msg = f"duplicate installed distribution: {name}" + raise ValueError(msg) + distributions[name] = dist + if set(distributions) != set(packages): + msg = f"installed inventory differs: missing={sorted(set(packages) - set(distributions))}, unexpected={sorted(set(distributions) - set(packages))}" + raise ValueError(msg) + for name, dist in sorted(distributions.items()): + if Version(dist.version) != Version(packages[name]["version"]): + msg = f"installed version differs: {name}" + raise ValueError(msg) + text = dist.read_text("direct_url.json") + direct = json.loads(text) if text else None + _check_direct_source(packages[name], direct) + rows.append({"name": name, "version": dist.version, "direct_url": direct}) + _validate_dependencies(distributions, packages, checked["requirements"], target) + return { + "schema_version": SCHEMA_VERSION, + "target": target.as_dict(), + "lock_sha256": checked["manifest"]["lock_sha256"], + "inputs": checked["manifest"]["inputs"], + "exceptions_sha256": checked["manifest"]["exceptions_sha256"], + "policy_sha256": checked["manifest"]["policy_sha256"], + "uv_version": checked["manifest"]["uv_version"], + "runtime_python_version": host_platform.python_version(), + "source_check": "installer verifies locked artifact hashes; inventory checks versions and recorded direct sources", + "packages": rows, + } + + +def main(argv: Sequence[str] | None = None) -> int: + """Docker pre-install validation and post-install inventory receipt.""" + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("command", choices=("check", "verify")) + parser.add_argument("--lock-dir", type=Path, required=True) + parser.add_argument("--bundles-dir", type=Path, required=True) + parser.add_argument("--root-lock", type=Path, required=True) + parser.add_argument("--compiler", type=Path, required=True) + parser.add_argument("--platform", required=True) + parser.add_argument("--bundle", required=True) + parser.add_argument("--architecture", required=True) + parser.add_argument("--installed", type=Path) + parser.add_argument("--receipt", type=Path) + args = parser.parse_args(argv) + target = Target(args.platform, args.bundle, args.architecture) + checked = check_lock(args.lock_dir, args.bundles_dir, args.root_lock, target, compiler=args.compiler) + if args.command == "verify": + if ( + sys.platform != "linux" + or host_platform.machine() != _MACHINES[target.architecture] + or sys.version_info[:2] != (3, 12) + ): + parser.error("installed inventory verification must run on the locked Linux/Python/architecture target") + if args.installed is None or args.receipt is None: + parser.error("verify requires --installed and --receipt") + receipt = verify_inventory(checked, args.installed, target) + args.receipt.write_text(json.dumps(receipt, indent=2, sort_keys=True) + "\n", encoding="utf-8") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/packages/sie_server/tests/core/test_bundle_image_resolution.py b/packages/sie_server/tests/core/test_bundle_image_resolution.py index 1a8a5e5b1..49f4bf894 100644 --- a/packages/sie_server/tests/core/test_bundle_image_resolution.py +++ b/packages/sie_server/tests/core/test_bundle_image_resolution.py @@ -1,15 +1,12 @@ -"""Resolve each release-matrix bundle the way its image install does. +"""Check every saved image overlay with the Docker-pinned PEP751 reader. -The image build runs on linux/amd64. ``uv pip install --dry-run`` applies that -marker environment on any host, with the same ``--target``, constraint, and -requirements arguments as the Dockerfiles. pip on macOS evaluates markers for -Darwin and misses the linux nvidia conflict those constraints used to create. -``--no-config`` keeps the repo's uv torch index from standing in for PyPI. +These dry runs check installer compatibility for all release targets and the +documented CPU arm64 targets without installing model packages. Actual image +builds additionally verify the installed inventory before copying the receipt. """ from __future__ import annotations -import json import os import shutil import subprocess @@ -18,132 +15,27 @@ from pathlib import Path import pytest -import yaml -from sie_server.bundle_requirements import lock_constraint_lines, parse_uv_lock, resolve_bundle_requirements +from sie_server.bundle_lock import UV_VERSION, Target, check_lock -_REPO_ROOT = Path(__file__).resolve().parents[4] -_BUNDLES = _REPO_ROOT / "packages" / "sie_server" / "bundles" -# CUDA 12 and 13 images are Ubuntu 22.04 (glibc 2.35). manylinux_2_28 rejects -# wheels such as sglang 0.5.20, which publish only manylinux_2_34 tags. -_LINUX_PLATFORM = "x86_64-manylinux_2_35" -_PYTHON_VERSION = "3.12" -# Dockerfile.cuda12's non-default index branch. Embedding is not in the -# release matrix today; keep the same case split as the image. -_SGLANG_CUDA12_BUNDLES = frozenset({"sglang", "sglang-embedding", "sglang-vision-extract"}) -_SCRUBBED_ENV = ( - "UV_INDEX", - "UV_INDEX_URL", - "UV_EXTRA_INDEX_URL", - "UV_DEFAULT_INDEX", - "UV_INDEX_STRATEGY", - "UV_TORCH_BACKEND", - "UV_CONSTRAINT", - "UV_OVERRIDE", - "PIP_INDEX_URL", - "PIP_EXTRA_INDEX_URL", - "PIP_CONSTRAINT", -) - - -def _release_targets() -> list[tuple[str, str]]: - data = json.loads((_REPO_ROOT / ".github" / "release-matrix.json").read_text()) - targets = [(str(platform), str(bundle)) for platform in data["platforms"] for bundle in data["bundles"]] - targets.extend((str(item["platform"]), str(item["bundle"])) for item in data.get("include", [])) - return targets +from tools.ci.bundle_lock import BUNDLES, LOCKS, resolver_environment, targets - -_TARGETS = _release_targets() +_REPO_ROOT = Path(__file__).resolve().parents[4] +_TARGETS = targets(_REPO_ROOT) def _uv_executable() -> str: - sibling = Path(sys.executable).resolve().with_name("uv") - if sibling.is_file() and os.access(sibling, os.X_OK): - return str(sibling) found = shutil.which("uv") - if found: - return found - pytest.fail( - "SIE_RUN_IMAGE_RESOLUTION=1 but uv is not installed; the resolution job must not pass without resolving" - ) - - -def _image_requirements(platform: str, bundle: str) -> list[str]: - bundle_path = _BUNDLES / f"{bundle}.yaml" - deps = yaml.safe_load(bundle_path.read_text())["deps"] - # Dockerfile.cpu passes --cpu, which drops flash-attn, xformers, and fla-core. - return resolve_bundle_requirements(deps, exclude_cuda=platform == "cpu") + if not found: + pytest.fail("SIE_RUN_IMAGE_RESOLUTION=1 but uv is not installed") + version = subprocess.run( # noqa: S603 - version-check the explicitly selected uv executable + [found, "--version"], check=True, text=True, capture_output=True + ).stdout.split() + if version[:2] != ["uv", UV_VERSION]: + pytest.fail(f"bundle image validation requires the Docker-pinned uv {UV_VERSION}") + return found -def _resolve_command(platform: str, bundle: str, target: Path, requirements: Path, constraints: Path) -> list[str]: - """Arguments that affect resolution, matched to the platform Dockerfile.""" - command = [ - _uv_executable(), - "pip", - "install", - "--dry-run", - "--no-config", - "--python-platform", - _LINUX_PLATFORM, - "--python-version", - _PYTHON_VERSION, - "--target", - str(target), - ] - if platform == "cuda13": - # packages/sie_server/Dockerfile.cuda13 - command.extend( - [ - "--index-strategy", - "unsafe-best-match", - "--prerelease=allow", - "--extra-index-url", - "https://download.pytorch.org/whl/cu130", - "--extra-index-url", - "https://docs.sglang.ai/whl/cu130/", - "--constraint", - str(constraints), - ] - ) - elif platform == "cpu": - # packages/sie_server/Dockerfile.cpu. pip searches every configured index; - # uv's default first-index strategy would not. - command.extend( - [ - "--index-url", - "https://download.pytorch.org/whl/cpu", - "--extra-index-url", - "https://pypi.org/simple", - "--index-strategy", - "unsafe-best-match", - "-c", - str(constraints), - ] - ) - else: - # packages/sie_server/Dockerfile.cuda12 - if bundle in _SGLANG_CUDA12_BUNDLES: - command.extend( - [ - "--extra-index-url", - "https://docs.sglang.ai/whl/cu129/", - "--index-strategy", - "unsafe-best-match", - ] - ) - command.extend(["-c", str(constraints)]) - command.extend(["-r", str(requirements)]) - return command - - -def _resolver_env() -> dict[str, str]: - env = os.environ.copy() - for key in _SCRUBBED_ENV: - env.pop(key, None) - return env - - -def test_missing_uv_fails_the_opt_in(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None: - monkeypatch.setattr(sys, "executable", str(tmp_path / "python")) +def test_missing_uv_fails_the_opt_in(monkeypatch: pytest.MonkeyPatch) -> None: monkeypatch.setattr(shutil, "which", lambda _name: None) with pytest.raises(pytest.fail.Exception, match="uv is not installed"): _uv_executable() @@ -151,38 +43,35 @@ def test_missing_uv_fails_the_opt_in(monkeypatch: pytest.MonkeyPatch, tmp_path: @pytest.mark.skipif( os.environ.get("SIE_RUN_IMAGE_RESOLUTION") != "1", - reason="needs network access to package indexes", -) -@pytest.mark.parametrize( - ("platform", "bundle"), - _TARGETS, - ids=[f"{platform}-{bundle}" for platform, bundle in _TARGETS], + reason="opt-in installer compatibility check", ) -def test_release_bundle_constraints_resolve(platform: str, bundle: str) -> None: - requirements = _image_requirements(platform, bundle) - if not requirements: - return - constraints = lock_constraint_lines(requirements, parse_uv_lock(_REPO_ROOT / "uv.lock")) - with tempfile.TemporaryDirectory() as tmp: - root = Path(tmp) - requirements_path = root / "requirements.txt" - constraints_path = root / "constraints.txt" - target = root / "bundle-libs" - target.mkdir() - requirements_path.write_text("\n".join(requirements) + "\n", encoding="utf-8") - constraints_path.write_text("\n".join(constraints) + "\n", encoding="utf-8") - command = _resolve_command(platform, bundle, target, requirements_path, constraints_path) - assert str(target) in command - assert str(requirements_path) in command - assert str(constraints_path) in command - completed = subprocess.run( # noqa: S603 - fixed uv resolution command built above +@pytest.mark.parametrize("target", _TARGETS, ids=[target.name for target in _TARGETS]) +def test_saved_bundle_is_consumed_without_fresh_resolution(target: Target) -> None: + check_lock(_REPO_ROOT / LOCKS, _REPO_ROOT / BUNDLES, _REPO_ROOT / "uv.lock", target) + with tempfile.TemporaryDirectory() as temp: + command = [ + _uv_executable(), + "pip", + "sync", + "--dry-run", + "--no-config", + "--python", + sys.executable, + "--python-platform", + target.python_platform, + "--python-version", + "3.12", + "--target", + str(Path(temp) / "bundle-libs"), + str(_REPO_ROOT / LOCKS / target.name / "pylock.toml"), + ] + completed = subprocess.run( # noqa: S603 - fixed installer arguments and checked repository lock command, check=False, capture_output=True, text=True, - env=_resolver_env(), - cwd=tmp, + env=resolver_environment(), + cwd=temp, timeout=900, ) - details = (completed.stderr or completed.stdout or "")[-4000:] - assert completed.returncode == 0, details + assert completed.returncode == 0, (completed.stderr or completed.stdout or "")[-4000:] diff --git a/packages/sie_server/tests/core/test_bundle_lock.py b/packages/sie_server/tests/core/test_bundle_lock.py new file mode 100644 index 000000000..d26b479ff --- /dev/null +++ b/packages/sie_server/tests/core/test_bundle_lock.py @@ -0,0 +1,249 @@ +"""Adversarial build-input and installed-metadata checks; no model imports.""" + +from __future__ import annotations + +import json +from pathlib import Path + +import pytest +from packaging.requirements import Requirement +from sie_server.bundle_lock import ( + Target, + _check_requirement_source, + artifact_sources, + canonical_digest, + check_lock, + digest, + policy_digest, + read_packages, + required_exceptions, + root_constraints, + validate_exceptions, + verify_inventory, +) + +TARGET = Target("cpu", "default", "amd64") +HASH = "a" * 64 +WHEEL_URL = "https://files.pythonhosted.org/packages/demo-1.0-py3-none-any.whl" + + +def write_distribution(installed: Path, name="demo", version="1.0", *, requires=(), direct=None): + info = installed / f"{name}-{version}.dist-info" + info.mkdir(parents=True) + text = f"Metadata-Version: 2.4\nName: {name}\nVersion: {version}\n" + text += "".join(f"Requires-Dist: {requirement}\n" for requirement in requires) + (info / "METADATA").write_text(text) + if direct is not None: + (info / "direct_url.json").write_text(json.dumps(direct)) + return info + + +@pytest.fixture +def locked(tmp_path): + root_lock = tmp_path / "uv.lock" + root_lock.write_text( + 'version = 1\n[[package]]\nname = "demo"\nversion = "1.0"\n' + 'source = { registry = "https://pypi.org/simple" }\n' + f'wheels = [{{url = "{WHEEL_URL}", hash = "sha256:{HASH}"}}]\n' + ) + bundles = tmp_path / "bundles" + bundles.mkdir() + (bundles / "default.yaml").write_text('name: default\ndeps:\n demo: ">=1,<2"\n') + locks = tmp_path / "locks" + folder = locks / TARGET.name + folder.mkdir(parents=True) + lock = folder / "pylock.toml" + lock.write_text( + 'lock-version = "1.0"\n[[packages]]\nname = "demo"\nversion = "1.0"\n' + f'wheels = [{{url = "{WHEEL_URL}", hashes = {{ sha256 = "{HASH}" }} }}]\n' + ) + manifest = { + "schema_version": 1, + "uv_version": "0.9.28", + "policy_sha256": policy_digest(), + "target": TARGET.as_dict(), + "inputs": {"uv_lock_sha256": digest(root_lock), "requirements_sha256": canonical_digest(["demo>=1,<2"])}, + "lock_sha256": digest(lock), + "exceptions_sha256": canonical_digest({}), + } + (folder / "manifest.json").write_text(json.dumps(manifest)) + (locks / "exceptions.json").write_text(json.dumps({"schema_version": 1, "targets": {}})) + return locks, bundles, root_lock + + +def test_clean_metadata_inventory_is_checked_without_importing_package(locked, tmp_path): + checked = check_lock(*locked, TARGET) + installed = tmp_path / "installed" + write_distribution(installed) + (installed / "demo.py").write_text('raise AssertionError("must not import installed code")') + receipt = verify_inventory(checked, installed, TARGET) + assert receipt["packages"] == [{"name": "demo", "version": "1.0", "direct_url": None}] + assert receipt["lock_sha256"] == checked["manifest"]["lock_sha256"] + + +@pytest.mark.parametrize("mutation", ["root", "requirements", "target", "lock", "exception", "policy"]) +def test_stale_inputs_and_wrong_target_fail_before_install(locked, mutation): + locks, bundles, root_lock = locked + manifest_path = locks / TARGET.name / "manifest.json" + manifest = json.loads(manifest_path.read_text()) + if mutation == "root": + root_lock.write_text(root_lock.read_text() + "\n# different root lock\n") + elif mutation == "requirements": + (bundles / "default.yaml").write_text('deps:\n demo: ">=1.1,<2"\n') + elif mutation == "target": + manifest["target"]["architecture"] = "arm64" + manifest_path.write_text(json.dumps(manifest)) + elif mutation == "lock": + lock = locks / TARGET.name / "pylock.toml" + lock.write_text(lock.read_text() + "\n# altered\n") + elif mutation == "policy": + manifest["policy_sha256"] = "c" * 64 + manifest_path.write_text(json.dumps(manifest)) + else: + (locks / "exceptions.json").write_text( + json.dumps({"schema_version": 1, "targets": {TARGET.name: {"demo": {"version": "2.0"}}}}) + ) + with pytest.raises(ValueError, match=r"bundle .* (changed|differs)"): + check_lock(*locked, TARGET) + + +@pytest.mark.parametrize("mutation", ["missing", "extra", "version", "duplicate", "source", "dependency"]) +def test_actual_inventory_drift_is_rejected(locked, tmp_path, mutation): + checked = check_lock(*locked, TARGET) + installed = tmp_path / "installed" + if mutation != "missing": + write_distribution( + installed, + version="1.1" if mutation == "version" else "1.0", + requires=("absent>=1",) if mutation == "dependency" else (), + direct={"url": "https://unapproved.example/demo.whl", "archive_info": {"hashes": {"sha256": HASH}}} + if mutation == "source" + else None, + ) + if mutation == "extra": + write_distribution(installed, "unlocked") + if mutation == "duplicate": + write_distribution(installed, version="0.9") + with pytest.raises(ValueError, match=r"(installed|distribution)"): + verify_inventory(checked, installed, TARGET) + + +def test_requested_extra_dependency_is_not_silently_omitted(locked, tmp_path): + checked = check_lock(*locked, TARGET) + checked["requirements"] = ["demo[feature]>=1"] + installed = tmp_path / "installed" + write_distribution(installed, requires=('absent>=1; extra == "feature"',)) + with pytest.raises(ValueError, match="requires absent"): + verify_inventory(checked, installed, TARGET) + + +def test_inactive_dependency_marker_does_not_charge_another_platform(locked, tmp_path): + checked = check_lock(*locked, TARGET) + installed = tmp_path / "installed" + write_distribution(installed, requires=('absent>=1; sys_platform == "win32"',)) + verify_inventory(checked, installed, TARGET) + + +def test_actual_python_patch_dependency_is_checked(locked, tmp_path, monkeypatch): + checked = check_lock(*locked, TARGET) + installed = tmp_path / "installed" + write_distribution(installed, requires=('absent>=1; python_full_version >= "3.12.1"',)) + monkeypatch.setattr("sie_server.bundle_lock.host_platform.python_version", lambda: "3.12.12") + with pytest.raises(ValueError, match="requires absent"): + verify_inventory(checked, installed, TARGET) + + +def test_unsupported_image_combination_is_explicit(locked): + with pytest.raises(ValueError, match="unsupported bundle lock target"): + check_lock(*locked, Target("cuda13", "default", "arm64")) + + +def test_exact_exception_rejects_wrong_version_source_and_stale_record(locked): + packages = read_packages(locked[0] / TARGET.name / "pylock.toml", TARGET) + package = packages["demo"] + package["version"] = "1.1" + required = required_exceptions(packages, locked[2]) + approved = {"demo": required["demo"] | {"reason": "Declared engine requires demo>=1.1; root1.0 is incompatible."}} + validate_exceptions(packages, locked[2], approved) + assert root_constraints(locked[2], approved) == ["demo==1.1"] + with pytest.raises(ValueError, match="missing"): + validate_exceptions(packages, locked[2], {}) + package["wheels"][0]["url"] = "https://changed.example/demo-1.0-py3-none-any.whl" + with pytest.raises(ValueError, match="not exact"): + validate_exceptions(packages, locked[2], approved) + with pytest.raises(ValueError, match="stale"): + validate_exceptions({}, locked[2], approved) + + +def test_root_pins_do_not_use_a_post_release_wildcard(tmp_path): + lock = tmp_path / "uv.lock" + lock.write_text( + '[[package]]\nname="torch"\nversion="2.9.1+cu129"\nsource={registry="https://download.pytorch.org/whl/cu129"}\n' + ) + assert root_constraints(lock, {}) == ["torch==2.9.1"] + + +@pytest.mark.parametrize( + "source", + [ + {"archive": {"url": "https://files.pythonhosted.org/demo.whl", "hashes": {}}}, + {"archive": {"url": "https://user:secret@example.test/demo.whl", "hashes": {"sha256": HASH}}}, + {"vcs": {"type": "git", "url": "https://github.com/example/demo", "commit-id": "main"}}, + ], +) +def test_unbound_or_credential_bearing_sources_are_rejected(source): + with pytest.raises(ValueError, match=r"(requires|must use)"): + artifact_sources({"name": "demo", "version": "1", **source}) + + +@pytest.mark.parametrize("actual_commit", ["c" * 40, "b" * 40]) +def test_vcs_commit_is_verified_from_installed_metadata(locked, tmp_path, actual_commit): + checked = check_lock(*locked, TARGET) + checked["packages"]["demo"] = { + "name": "demo", + "version": "1.0", + "vcs": {"type": "git", "url": "https://github.com/example/demo", "commit-id": "b" * 40}, + } + installed = tmp_path / "installed" + write_distribution( + installed, + direct={"url": "https://github.com/example/demo", "vcs_info": {"vcs": "git", "commit_id": actual_commit}}, + ) + if actual_commit == "b" * 40: + verify_inventory(checked, installed, TARGET) + else: + with pytest.raises(ValueError, match="VCS source"): + verify_inventory(checked, installed, TARGET) + + +def test_arm64_lock_cannot_silently_reuse_x86_wheel(locked): + path = locked[0] / TARGET.name / "pylock.toml" + path.write_text(path.read_text().replace("py3-none-any.whl", "cp312-cp312-manylinux_2_28_x86_64.whl")) + with pytest.raises(ValueError, match="architecture"): + read_packages(path, Target("cpu", "default", "arm64")) + + +@pytest.mark.parametrize("source", ["archive", "vcs"]) +def test_declared_source_cannot_be_substituted_with_same_version(source): + if source == "archive": + requirement = Requirement(f"demo @ {WHEEL_URL}") + package = {"archive": {"url": WHEEL_URL}} + _check_requirement_source(requirement, package) + package["archive"]["url"] = "https://example.test/different.whl" + else: + requirement = Requirement("demo @ git+https://github.com/example/demo@" + "b" * 40) + package = {"vcs": {"url": "https://github.com/example/demo", "commit-id": "b" * 40}} + _check_requirement_source(requirement, package) + package["vcs"]["commit-id"] = "c" * 40 + with pytest.raises(ValueError, match=r"declared .* source"): + _check_requirement_source(requirement, package) + + +def test_direct_root_artifact_is_not_silently_omitted(locked): + locks, _bundles, root_lock = locked + root_lock.write_text(root_lock.read_text().replace('registry = "https://pypi.org/simple"', f'url = "{WHEEL_URL}"')) + packages = read_packages(locks / TARGET.name / "pylock.toml", TARGET) + assert root_constraints(root_lock, {}) == ["demo==1.0"] + assert required_exceptions(packages, root_lock) == {} + packages["demo"]["wheels"][0]["hashes"]["sha256"] = "b" * 64 + assert "demo" in required_exceptions(packages, root_lock) diff --git a/tools/ci/bundle_lock.py b/tools/ci/bundle_lock.py new file mode 100644 index 000000000..fecce53ca --- /dev/null +++ b/tools/ci/bundle_lock.py @@ -0,0 +1,233 @@ +"""Compile and check the complete, reviewed image-overlay dependency locks. + +Run with the Docker-pinned uv version; compilation uses public indexes and an +explicit cutoff. Ordinary image builds consume the saved artifacts, without a +fresh dependency solve. No package is installed by this command. +""" +# ruff: noqa: INP001 - repository command modules use namespace packages + +from __future__ import annotations + +import argparse +import hashlib +import json +import os +import shutil +import subprocess +import sys +import tempfile +import tomllib +from pathlib import Path +from urllib.parse import urlsplit +from urllib.request import urlopen + +from sie_server.bundle_lock import ( + SCHEMA_VERSION, + UV_VERSION, + Target, + bundle_requirements, + canonical_digest, + check_lock, + digest, + policy_digest, + read_packages, + root_constraints, + validate_exceptions, +) + +ROOT = Path(__file__).resolve().parents[2] +LOCKS = Path("packages/sie_server/bundle-locks") +BUNDLES = Path("packages/sie_server/bundles") + + +def targets(root: Path) -> list[Target]: + matrix = json.loads((root / ".github/release-matrix.json").read_text()) + result = [Target(platform, bundle, "amd64") for platform in matrix["platforms"] for bundle in matrix["bundles"]] + result += [Target(item["platform"], item["bundle"], "amd64") for item in matrix["include"]] + # Dockerfile.cpu documents arm64 as well as the amd64 release matrix. + result += [Target("cpu", bundle, "arm64") for bundle in matrix["bundles"]] + if len({target.name for target in result}) != len(result): + raise ValueError("duplicate bundle lock target") + return result + + +def index_arguments(target: Target) -> list[str]: + arguments = ["--default-index", "https://pypi.org/simple"] + if target.platform == "cpu": + arguments += ["--index", "https://download.pytorch.org/whl/cpu", "--index-strategy", "unsafe-best-match"] + elif target.platform == "cuda13": + arguments += [ + "--index", + "https://download.pytorch.org/whl/cu130", + "--index", + "https://docs.sglang.ai/whl/cu130/", + "--index-strategy", + "unsafe-best-match", + "--prerelease", + "allow", + ] + elif target.bundle in {"sglang", "sglang-embedding", "sglang-vision-extract"}: + arguments += ["--index", "https://docs.sglang.ai/whl/cu129/", "--index-strategy", "unsafe-best-match"] + return arguments + + +def resolver_environment() -> dict[str, str]: + # Do not let an ambient private index, dependency override, or disabled hash + # check change a public lock. The explicit cache argument remains local. + return {key: value for key, value in os.environ.items() if not key.startswith(("UV_", "PIP_"))} + + +def check_all(root: Path) -> None: + expected = targets(root) + actual = {path.name for path in (root / LOCKS).iterdir() if path.is_dir()} + if actual != {target.name for target in expected}: + raise ValueError("saved bundle target set differs from release matrix plus CPU arm64") + for target in expected: + checked = check_lock( + root / LOCKS, root / BUNDLES, root / "uv.lock", target, compiler=root / "tools/ci/bundle_lock.py" + ) + if checked["manifest"].get("indexes") != index_arguments(target): + raise ValueError(f"bundle index policy differs: {target.name}") + + +def complete_artifact_hashes(lock: Path) -> list[dict[str, object]]: + """Hash small public artifacts omitted by uv0.9.28's PEP751 writer. + + Some PyTorch mirror entries lack index hashes even with --generate-hashes. + Never accept those as unhashed installs: retrieve at most 64MiB per missing + artifact during explicit lock compilation, or fail without saving a lock. + """ + text = lock.read_text() + completed = [] + cache: dict[str, tuple[str, int]] = {} + for package in tomllib.loads(text)["packages"]: + artifacts = package.get("wheels", []) + [package[key] for key in ("sdist", "archive") if key in package] + for artifact in artifacts: + if artifact.get("hashes", {}).get("sha256"): + continue + url = artifact["url"] + parts = urlsplit(url) + if parts.scheme != "https" or not parts.hostname or parts.username or parts.password: + raise ValueError("missing-hash artifact must use credential-free HTTPS") + if url not in cache: + digestor = hashlib.sha256() + size = 0 + with urlopen(url, timeout=60) as response: # noqa: S310 - HTTPS validated above + if urlsplit(response.geturl()).scheme != "https": + raise ValueError("artifact redirect is not HTTPS") + while block := response.read(1024 * 1024): + size += len(block) + if size > 64 * 1024 * 1024: + raise ValueError("missing-hash artifact exceeds 64MiB compilation bound") + digestor.update(block) + cache[url] = (digestor.hexdigest(), size) + sha256, size = cache[url] + # The Docker-pinned uv writer emits each artifact on one TOML line. + candidates = [ + line for line in text.splitlines() if f"url = {json.dumps(url)}" in line and "hashes = {}" in line + ] + if len(candidates) != 1: + raise ValueError("unexpected uv artifact serialization; refusing an ambiguous hash edit") + line = candidates[0] + text = text.replace(line, line.replace("hashes = {}", f'hashes = {{ sha256 = "{sha256}" }}'), 1) + completed.append({"url": url, "sha256": sha256, "bytes": size}) + lock.write_text(text) + return completed + + +def compile_target(root: Path, target: Target, uv: str, cutoff: str, cache: Path | None) -> None: + policy = json.loads((root / LOCKS / "exceptions.json").read_text()) + exceptions = policy["targets"].get(target.name, {}) + requirements = bundle_requirements(root / BUNDLES, target) + constraints = root_constraints(root / "uv.lock", exceptions) + version = subprocess.run( # noqa: S603 - explicit compiler executable, no shell + [uv, "--version"], check=True, capture_output=True, text=True + ).stdout.split() + if version[:2] != ["uv", UV_VERSION]: + raise ValueError(f"compile requires uv {UV_VERSION}, matching the Docker installer") + with tempfile.TemporaryDirectory(prefix="sie-bundle-lock-") as temp: + directory = Path(temp) + (directory / "requirements.in").write_text("\n".join(requirements) + "\n") + (directory / "constraints.txt").write_text("\n".join(constraints) + "\n") + command = [ + uv, + "pip", + "compile", + "requirements.in", + "--constraint", + "constraints.txt", + "--no-config", + "--python-platform", + target.python_platform, + "--python-version", + "3.12", + "--python", + sys.executable, + "--no-python-downloads", + "--format", + "pylock.toml", + "--generate-hashes", + "--output-file", + "pylock.toml", + "--no-header", + "--exclude-newer", + cutoff, + *index_arguments(target), + ] + if cache is not None: + command += ["--cache-dir", str(cache.resolve())] + subprocess.run( # noqa: S603 - fixed compile arguments and explicit public indexes + command, check=True, cwd=directory, env=resolver_environment(), timeout=900 + ) + completed_hashes = complete_artifact_hashes(directory / "pylock.toml") + packages = read_packages(directory / "pylock.toml", target) + validate_exceptions(packages, root / "uv.lock", exceptions) + manifest = { + "schema_version": SCHEMA_VERSION, + "target": target.as_dict(), + "uv_version": UV_VERSION, + "policy_sha256": policy_digest(root / "tools/ci/bundle_lock.py"), + "exclude_newer": cutoff, + "indexes": index_arguments(target), + "completed_artifact_hashes": completed_hashes, + "inputs": { + "uv_lock_sha256": digest(root / "uv.lock"), + "requirements_sha256": canonical_digest(requirements), + }, + "exceptions_sha256": canonical_digest(exceptions), + "lock_sha256": digest(directory / "pylock.toml"), + } + destination = root / LOCKS / target.name + destination.mkdir(parents=True, exist_ok=True) + shutil.copyfile(directory / "pylock.toml", destination / "pylock.toml") + (destination / "manifest.json").write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n") + check_lock(root / LOCKS, root / BUNDLES, root / "uv.lock", target) + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("command", choices=("check", "compile")) + parser.add_argument("--root", type=Path, default=ROOT) + parser.add_argument("--target", action="append") + parser.add_argument("--uv", default="uv") + parser.add_argument("--exclude-newer") + parser.add_argument("--cache", type=Path) + args = parser.parse_args() + if args.command == "check": + check_all(args.root) + return 0 + if not args.exclude_newer: + parser.error("compile requires an explicit --exclude-newer cutoff") + selected = targets(args.root) + if args.target: + unknown = set(args.target) - {target.name for target in selected} + if unknown: + parser.error(f"unsupported targets: {sorted(unknown)}") + selected = [target for target in selected if target.name in args.target] + for target in selected: + compile_target(args.root, target, args.uv, args.exclude_newer, args.cache) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tools/ci/tests/test_bundle_lock.py b/tools/ci/tests/test_bundle_lock.py new file mode 100644 index 000000000..85fe6825b --- /dev/null +++ b/tools/ci/tests/test_bundle_lock.py @@ -0,0 +1,106 @@ +"""The saved bundle policy is public, complete and rejects drift.""" + +from __future__ import annotations + +import hashlib +import io +import json + +import pytest +from sie_server.bundle_lock import Target + +from tools.ci import bundle_lock + + +def test_target_matrix_preserves_cpu_arm64_in_addition_to_every_release(): + selected = bundle_lock.targets(bundle_lock.ROOT) + assert len(selected) == 15 + assert len({target.name for target in selected}) == 15 + assert {target.bundle for target in selected if target.architecture == "arm64"} == { + "default", + "ctranslate2", + "sglang", + "transformers5", + } + assert all(target.platform == "cpu" for target in selected if target.architecture == "arm64") + + +def test_ambient_private_index_or_hash_bypass_is_not_a_compilation_input(monkeypatch): + monkeypatch.setenv("UV_NO_VERIFY_HASHES", "1") + monkeypatch.setenv("PIP_INDEX_URL", "https://example.test/private") + monkeypatch.setenv("UV_OVERRIDE", "unreviewed.txt") + monkeypatch.setenv("SIE_BUNDLE_CONTROL", "retained") + env = bundle_lock.resolver_environment() + assert not any(key.startswith(("UV_", "PIP_")) for key in env) + assert env["SIE_BUNDLE_CONTROL"] == "retained" + + +class Response(io.BytesIO): + def __init__(self, data=b"public wheel bytes", url="https://example.test/demo-1-py3-none-any.whl"): + super().__init__(data) + self.url = url + + def geturl(self): + return self.url + + +def missing_hash(tmp_path, url="https://example.test/demo-1-py3-none-any.whl"): + path = tmp_path / "pylock.toml" + path.write_text( + 'lock-version = "1.0"\n[[packages]]\nname = "demo"\nversion = "1"\n' + f"wheels = [{{url = {json.dumps(url)}, hashes = {{}} }}]\n" + ) + return path + + +def test_missing_index_hash_is_bound_to_actual_downloaded_bytes(tmp_path, monkeypatch): + path = missing_hash(tmp_path) + monkeypatch.setattr(bundle_lock, "urlopen", lambda *_args, **_kwargs: Response()) + completed = bundle_lock.complete_artifact_hashes(path) + expected = hashlib.sha256(b"public wheel bytes").hexdigest() + assert completed[0]["sha256"] == expected + assert completed[0]["bytes"] == len(b"public wheel bytes") + assert expected in path.read_text() + monkeypatch.setattr(bundle_lock, "urlopen", lambda *_args, **_kwargs: pytest.fail("must not redownload")) + assert bundle_lock.complete_artifact_hashes(path) == [] + + +@pytest.mark.parametrize("url", ["http://example.test/wheel", "https://user:password@example.test/wheel"]) +def test_untrusted_missing_hash_source_fails_before_network(tmp_path, monkeypatch, url): + path = missing_hash(tmp_path, url) + prior = path.read_bytes() + monkeypatch.setattr(bundle_lock, "urlopen", lambda *_args, **_kwargs: pytest.fail("must not fetch")) + with pytest.raises(ValueError, match="credential-free HTTPS"): + bundle_lock.complete_artifact_hashes(path) + assert path.read_bytes() == prior + + +def test_insecure_redirect_and_oversized_hash_completion_do_not_save(tmp_path, monkeypatch): + path = missing_hash(tmp_path) + prior = path.read_bytes() + monkeypatch.setattr(bundle_lock, "urlopen", lambda *_args, **_kwargs: Response(url="http://example.test/redirect")) + with pytest.raises(ValueError, match="redirect"): + bundle_lock.complete_artifact_hashes(path) + assert path.read_bytes() == prior + monkeypatch.setattr(Response, "read", lambda *_args: b"a" * (1024 * 1024)) + monkeypatch.setattr(bundle_lock, "urlopen", lambda *_args, **_kwargs: Response()) + with pytest.raises(ValueError, match="64MiB"): + bundle_lock.complete_artifact_hashes(path) + assert path.read_bytes() == prior + + +def test_saved_target_and_index_policy_cannot_drift(tmp_path, monkeypatch): + target = Target("cpu", "default", "amd64") + folder = tmp_path / bundle_lock.LOCKS / target.name + folder.mkdir(parents=True) + monkeypatch.setattr(bundle_lock, "targets", lambda _root: [target]) + monkeypatch.setattr(bundle_lock, "check_lock", lambda *_args, **_kwargs: {"manifest": {"indexes": ["private"]}}) + with pytest.raises(ValueError, match="index policy"): + bundle_lock.check_all(tmp_path) + (folder.parent / "unexpected").mkdir() + with pytest.raises(ValueError, match="target set"): + bundle_lock.check_all(tmp_path) + + +def test_repository_locks_bind_current_public_inputs(): + bundle_lock.check_all(bundle_lock.ROOT) diff --git a/tools/ci/tests/test_docker_task.py b/tools/ci/tests/test_docker_task.py index 129737201..0f78055b1 100644 --- a/tools/ci/tests/test_docker_task.py +++ b/tools/ci/tests/test_docker_task.py @@ -332,27 +332,22 @@ def _dockerfile_logical_lines(text: str) -> list[str]: def test_bundle_image_installs_are_constrained_to_the_lock(dockerfile: str) -> None: text = (Path(__file__).resolve().parents[3] / "packages" / "sie_server" / dockerfile).read_text() assert "COPY uv.lock /tmp/uv.lock" in text - assert "--constraints-output /tmp/bundle-constraints.txt" in text + assert "COPY packages/sie_server/bundle-locks /tmp/bundle-locks" in text + assert "ARG TARGETARCH" in text + assert 'test "$(uv --version)" = "uv 0.9.28"' in text + logical = _dockerfile_logical_lines(text) + check = next(i for i, line in enumerate(logical) if "sie_server.bundle_lock check" in line) + sync = next(i for i, line in enumerate(logical) if "uv pip sync" in line) + assert check < sync + assert "--no-config --python /app/.venv/bin/python" in logical[sync] + assert "--target /app/bundle-libs" in logical[sync] + assert "${BUNDLE}-${TARGETARCH}/pylock.toml" in logical[sync] + assert "sie_server.bundle_lock verify" in logical[sync] + assert "--installed /app/bundle-libs --receipt /app/bundle-libs-inventory.json" in logical[sync] assert "pip freeze --path /app/bundle-libs > /app/bundle-libs-freeze.txt" in text - assert "/app/bundle-libs-freeze.txt /app/bundle-libs-freeze.txt" in text - installs = [ - line - for line in _dockerfile_logical_lines(text) - if "-r /tmp/bundle-requirements.txt" in line and ("pip install" in line or "uv pip install" in line) - ] - assert installs - constraints_file = "/tmp/bundle-constraints.txt" # noqa: S108 - # A case/if arm ends at `;;`. One logical RUN can hold both CUDA 12 - # branches, so each install command is checked on its own. - commands = [ - part.strip() - for line in installs - for part in line.split(";;") - if "-r /tmp/bundle-requirements.txt" in part and ("pip install" in part or "uv pip install" in part) - ] - assert commands - for command in commands: - assert f"-c {constraints_file}" in command or f"--constraint {constraints_file}" in command + for receipt in ("bundle-libs-freeze.txt", "bundle-libs-inventory.json"): + assert f"/app/{receipt} /app/{receipt}" in text + assert "-r /tmp/bundle-requirements.txt" not in text def test_expected_release_set_has_sixteen_tags_and_six_names(complete_source): From 1cfe8c5e58baec1872c0deaad5631dbc76b2970a Mon Sep 17 00:00:00 2001 From: svonava Date: Sun, 18 Oct 2026 04:02:13 -0700 Subject: [PATCH 09/13] fix(build): retain explicit CUDA13 wheel variants --- packages/sie_server/bundle-locks/README.md | 8 +++ .../cpu-ctranslate2-amd64/manifest.json | 3 +- .../cpu-ctranslate2-arm64/manifest.json | 3 +- .../cpu-default-amd64/manifest.json | 3 +- .../cpu-default-arm64/manifest.json | 3 +- .../cpu-sglang-amd64/manifest.json | 3 +- .../cpu-sglang-arm64/manifest.json | 3 +- .../cpu-transformers5-amd64/manifest.json | 3 +- .../cpu-transformers5-arm64/manifest.json | 3 +- .../cuda12-ctranslate2-amd64/manifest.json | 3 +- .../cuda12-default-amd64/manifest.json | 3 +- .../cuda12-sglang-amd64/manifest.json | 3 +- .../manifest.json | 3 +- .../cuda12-transformers5-amd64/manifest.json | 3 +- .../cuda13-sglang-cu130-amd64/manifest.json | 5 +- .../cuda13-sglang-cu130-amd64/pylock.toml | 12 ++-- .../cuda13-tensorrt-llm-amd64/manifest.json | 3 +- .../sie_server/bundle-locks/exceptions.json | 22 +++++++ .../sie_server/src/sie_server/bundle_lock.py | 44 +++++++++++++- .../core/test_bundle_image_resolution.py | 16 +++-- .../sie_server/tests/core/test_bundle_lock.py | 59 ++++++++++++++++++- tools/ci/bundle_lock.py | 7 ++- tools/ci/tests/test_bundle_lock.py | 29 +++++++++ 23 files changed, 213 insertions(+), 31 deletions(-) diff --git a/packages/sie_server/bundle-locks/README.md b/packages/sie_server/bundle-locks/README.md index 0d6bad7ff..6b3e4dede 100644 --- a/packages/sie_server/bundle-locks/README.md +++ b/packages/sie_server/bundle-locks/README.md @@ -54,6 +54,14 @@ and engine-required Transformers, Torch, and related versions are also explicit. Same-byte public mirrors and a root entry without artifact records are labeled source differences; they are not reported as dependency incompatibilities. +The CUDA 13 SGLang index omits upload timestamps for its native cu130 wheels. +The global cutoff therefore excludes those index candidates in uv 0.9.28. +The `source_pins` records preserve the established cu130 variants with exact +public wheel URLs, versions, SHA256 hashes, and reasons. These are explicit +exceptions for the named artifacts, not a disabled cutoff: all index-resolved +candidates still obey the compilation cutoff. The verifier rejects a missing, +changed, or substituted source pin, and binds its digest into the build receipt. + ## Validation and updates From a bootstrapped clean checkout: diff --git a/packages/sie_server/bundle-locks/cpu-ctranslate2-amd64/manifest.json b/packages/sie_server/bundle-locks/cpu-ctranslate2-amd64/manifest.json index fc024c5f6..54a90eda3 100644 --- a/packages/sie_server/bundle-locks/cpu-ctranslate2-amd64/manifest.json +++ b/packages/sie_server/bundle-locks/cpu-ctranslate2-amd64/manifest.json @@ -15,8 +15,9 @@ "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" }, "lock_sha256": "1f2350156ca95ae0ed398f20d94458135d6c9ac1fd4985419e1ea6873576e718", - "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "policy_sha256": "ad0ea4aba9172f1b79f0c8fb274af90d4d3d161c74e0eb578f9d63c3cd3b5bea", "schema_version": 1, + "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { "architecture": "amd64", "bundle": "ctranslate2", diff --git a/packages/sie_server/bundle-locks/cpu-ctranslate2-arm64/manifest.json b/packages/sie_server/bundle-locks/cpu-ctranslate2-arm64/manifest.json index 327b65287..8ceb2ad68 100644 --- a/packages/sie_server/bundle-locks/cpu-ctranslate2-arm64/manifest.json +++ b/packages/sie_server/bundle-locks/cpu-ctranslate2-arm64/manifest.json @@ -15,8 +15,9 @@ "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" }, "lock_sha256": "1bc8a0f417323c67420e71cf16b71e562c7db5842b50d4c5cd60efea8106141b", - "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "policy_sha256": "ad0ea4aba9172f1b79f0c8fb274af90d4d3d161c74e0eb578f9d63c3cd3b5bea", "schema_version": 1, + "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { "architecture": "arm64", "bundle": "ctranslate2", diff --git a/packages/sie_server/bundle-locks/cpu-default-amd64/manifest.json b/packages/sie_server/bundle-locks/cpu-default-amd64/manifest.json index d5f1cf9ab..928ac55d8 100644 --- a/packages/sie_server/bundle-locks/cpu-default-amd64/manifest.json +++ b/packages/sie_server/bundle-locks/cpu-default-amd64/manifest.json @@ -26,8 +26,9 @@ "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" }, "lock_sha256": "3ef32d5d618de1e61ab62c2077e07a16f09053cb992cab9606ce02e584c79652", - "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "policy_sha256": "ad0ea4aba9172f1b79f0c8fb274af90d4d3d161c74e0eb578f9d63c3cd3b5bea", "schema_version": 1, + "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { "architecture": "amd64", "bundle": "default", diff --git a/packages/sie_server/bundle-locks/cpu-default-arm64/manifest.json b/packages/sie_server/bundle-locks/cpu-default-arm64/manifest.json index 08794a5a0..727f4164d 100644 --- a/packages/sie_server/bundle-locks/cpu-default-arm64/manifest.json +++ b/packages/sie_server/bundle-locks/cpu-default-arm64/manifest.json @@ -26,8 +26,9 @@ "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" }, "lock_sha256": "49f489165b533576418ef6d0c7d86cacc968e57e335d76f145988392cb56a663", - "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "policy_sha256": "ad0ea4aba9172f1b79f0c8fb274af90d4d3d161c74e0eb578f9d63c3cd3b5bea", "schema_version": 1, + "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { "architecture": "arm64", "bundle": "default", diff --git a/packages/sie_server/bundle-locks/cpu-sglang-amd64/manifest.json b/packages/sie_server/bundle-locks/cpu-sglang-amd64/manifest.json index 4c9361eed..bfe7eb32f 100644 --- a/packages/sie_server/bundle-locks/cpu-sglang-amd64/manifest.json +++ b/packages/sie_server/bundle-locks/cpu-sglang-amd64/manifest.json @@ -31,8 +31,9 @@ "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" }, "lock_sha256": "9ad62d85b2dea1cedb4cde7256aa85e9f500ae1f00c5bcc2214b8cde7820514f", - "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "policy_sha256": "ad0ea4aba9172f1b79f0c8fb274af90d4d3d161c74e0eb578f9d63c3cd3b5bea", "schema_version": 1, + "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { "architecture": "amd64", "bundle": "sglang", diff --git a/packages/sie_server/bundle-locks/cpu-sglang-arm64/manifest.json b/packages/sie_server/bundle-locks/cpu-sglang-arm64/manifest.json index 0877a9969..932769dd3 100644 --- a/packages/sie_server/bundle-locks/cpu-sglang-arm64/manifest.json +++ b/packages/sie_server/bundle-locks/cpu-sglang-arm64/manifest.json @@ -31,8 +31,9 @@ "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" }, "lock_sha256": "6680e1454e1fe6bf0d4aa7b6647b6fb8c948d2eff9646a51cbdcaac56eff09fb", - "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "policy_sha256": "ad0ea4aba9172f1b79f0c8fb274af90d4d3d161c74e0eb578f9d63c3cd3b5bea", "schema_version": 1, + "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { "architecture": "arm64", "bundle": "sglang", diff --git a/packages/sie_server/bundle-locks/cpu-transformers5-amd64/manifest.json b/packages/sie_server/bundle-locks/cpu-transformers5-amd64/manifest.json index 9ef5ac69e..df8f220d7 100644 --- a/packages/sie_server/bundle-locks/cpu-transformers5-amd64/manifest.json +++ b/packages/sie_server/bundle-locks/cpu-transformers5-amd64/manifest.json @@ -26,8 +26,9 @@ "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" }, "lock_sha256": "3e756b5dffc07c0527a9a3465dbab2c17a0873beefe37e39f7cbd8e68b43f6cc", - "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "policy_sha256": "ad0ea4aba9172f1b79f0c8fb274af90d4d3d161c74e0eb578f9d63c3cd3b5bea", "schema_version": 1, + "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { "architecture": "amd64", "bundle": "transformers5", diff --git a/packages/sie_server/bundle-locks/cpu-transformers5-arm64/manifest.json b/packages/sie_server/bundle-locks/cpu-transformers5-arm64/manifest.json index 8ec51d6cf..0584bd91c 100644 --- a/packages/sie_server/bundle-locks/cpu-transformers5-arm64/manifest.json +++ b/packages/sie_server/bundle-locks/cpu-transformers5-arm64/manifest.json @@ -26,8 +26,9 @@ "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" }, "lock_sha256": "f0243e01019a55d573ceffa9798460b0a503d128e5f1942e8901d83658995219", - "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "policy_sha256": "ad0ea4aba9172f1b79f0c8fb274af90d4d3d161c74e0eb578f9d63c3cd3b5bea", "schema_version": 1, + "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { "architecture": "arm64", "bundle": "transformers5", diff --git a/packages/sie_server/bundle-locks/cuda12-ctranslate2-amd64/manifest.json b/packages/sie_server/bundle-locks/cuda12-ctranslate2-amd64/manifest.json index 2dc8ad650..f6991e46e 100644 --- a/packages/sie_server/bundle-locks/cuda12-ctranslate2-amd64/manifest.json +++ b/packages/sie_server/bundle-locks/cuda12-ctranslate2-amd64/manifest.json @@ -11,8 +11,9 @@ "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" }, "lock_sha256": "1f2350156ca95ae0ed398f20d94458135d6c9ac1fd4985419e1ea6873576e718", - "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "policy_sha256": "ad0ea4aba9172f1b79f0c8fb274af90d4d3d161c74e0eb578f9d63c3cd3b5bea", "schema_version": 1, + "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { "architecture": "amd64", "bundle": "ctranslate2", diff --git a/packages/sie_server/bundle-locks/cuda12-default-amd64/manifest.json b/packages/sie_server/bundle-locks/cuda12-default-amd64/manifest.json index f89a01ae3..899bc9c7f 100644 --- a/packages/sie_server/bundle-locks/cuda12-default-amd64/manifest.json +++ b/packages/sie_server/bundle-locks/cuda12-default-amd64/manifest.json @@ -11,8 +11,9 @@ "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" }, "lock_sha256": "913c67d8a1215c8b68a1bf909c86742b14b12fc3f8e17dbbe11951505d603c2b", - "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "policy_sha256": "ad0ea4aba9172f1b79f0c8fb274af90d4d3d161c74e0eb578f9d63c3cd3b5bea", "schema_version": 1, + "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { "architecture": "amd64", "bundle": "default", diff --git a/packages/sie_server/bundle-locks/cuda12-sglang-amd64/manifest.json b/packages/sie_server/bundle-locks/cuda12-sglang-amd64/manifest.json index bd86370db..8b851a17b 100644 --- a/packages/sie_server/bundle-locks/cuda12-sglang-amd64/manifest.json +++ b/packages/sie_server/bundle-locks/cuda12-sglang-amd64/manifest.json @@ -15,8 +15,9 @@ "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" }, "lock_sha256": "9b59da8d8bfaea7599787085f2e16e54082cb9eecf1085fec2178b98eba2439f", - "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "policy_sha256": "ad0ea4aba9172f1b79f0c8fb274af90d4d3d161c74e0eb578f9d63c3cd3b5bea", "schema_version": 1, + "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { "architecture": "amd64", "bundle": "sglang", diff --git a/packages/sie_server/bundle-locks/cuda12-sglang-vision-extract-amd64/manifest.json b/packages/sie_server/bundle-locks/cuda12-sglang-vision-extract-amd64/manifest.json index 8c09a966c..73d758a8d 100644 --- a/packages/sie_server/bundle-locks/cuda12-sglang-vision-extract-amd64/manifest.json +++ b/packages/sie_server/bundle-locks/cuda12-sglang-vision-extract-amd64/manifest.json @@ -15,8 +15,9 @@ "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" }, "lock_sha256": "a74358f2ff818ad75d589987a4dd34ca9340a9a6739c8bc041671f658330bea8", - "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "policy_sha256": "ad0ea4aba9172f1b79f0c8fb274af90d4d3d161c74e0eb578f9d63c3cd3b5bea", "schema_version": 1, + "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { "architecture": "amd64", "bundle": "sglang-vision-extract", diff --git a/packages/sie_server/bundle-locks/cuda12-transformers5-amd64/manifest.json b/packages/sie_server/bundle-locks/cuda12-transformers5-amd64/manifest.json index 3997bd5a2..55ee9bba3 100644 --- a/packages/sie_server/bundle-locks/cuda12-transformers5-amd64/manifest.json +++ b/packages/sie_server/bundle-locks/cuda12-transformers5-amd64/manifest.json @@ -11,8 +11,9 @@ "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" }, "lock_sha256": "b1c1101c295e2283084a6bd7d893508c1733e611458a164d94d3b6e389665a56", - "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "policy_sha256": "ad0ea4aba9172f1b79f0c8fb274af90d4d3d161c74e0eb578f9d63c3cd3b5bea", "schema_version": 1, + "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { "architecture": "amd64", "bundle": "transformers5", diff --git a/packages/sie_server/bundle-locks/cuda13-sglang-cu130-amd64/manifest.json b/packages/sie_server/bundle-locks/cuda13-sglang-cu130-amd64/manifest.json index d1f3231dd..0aca0d73c 100644 --- a/packages/sie_server/bundle-locks/cuda13-sglang-cu130-amd64/manifest.json +++ b/packages/sie_server/bundle-locks/cuda13-sglang-cu130-amd64/manifest.json @@ -29,9 +29,10 @@ "requirements_sha256": "6d29b7815d5f5105dbc70e23f5c3c51a225c6b2e0127eca3834a327d94eeec4a", "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" }, - "lock_sha256": "619a3c7eedc61badcd94a3a19988aa204fc53299b63e8c721723d0697c28d787", - "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "lock_sha256": "35f443a12d4a0e11b81b50078724d363f7defd60f22dfe394c7fc42ce6401e1b", + "policy_sha256": "ad0ea4aba9172f1b79f0c8fb274af90d4d3d161c74e0eb578f9d63c3cd3b5bea", "schema_version": 1, + "source_pins_sha256": "6808e668b2e2a0982ffa734b251936b07fab343a4b201d549e85333691f7ec85", "target": { "architecture": "amd64", "bundle": "sglang-cu130", diff --git a/packages/sie_server/bundle-locks/cuda13-sglang-cu130-amd64/pylock.toml b/packages/sie_server/bundle-locks/cuda13-sglang-cu130-amd64/pylock.toml index 80a1ec393..ab1ff3a15 100644 --- a/packages/sie_server/bundle-locks/cuda13-sglang-cu130-amd64/pylock.toml +++ b/packages/sie_server/bundle-locks/cuda13-sglang-cu130-amd64/pylock.toml @@ -1005,13 +1005,13 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/5d/40/e1e72872c6354b3 [[packages]] name = "sgl-deep-ep" -version = "0.1.2" -wheels = [{ url = "https://files.pythonhosted.org/packages/e5/4d/eff6ebd61e34c4e617f1373a4ebc35a25b884cf54a4879664dfd6327c87d/sgl_deep_ep-0.1.2-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-08-19T23:29:21Z, size = 15331145, hashes = { sha256 = "63c90e60b5cbb63dac10ab62b432306c37ce2f7777ffb3f05bee765210a31c80" } }] +version = "0.1.2+cu130" +archive = { url = "https://github.com/sgl-project/whl/releases/download/v0.1.2/sgl_deep_ep-0.1.2+cu130-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hashes = { sha256 = "9c15cb83b56bcc1ec1a838f47a06e9e067c69e0f0b16498d0e7451a548c2047a" } } [[packages]] name = "sgl-deep-gemm" -version = "0.2.0" -wheels = [{ url = "https://files.pythonhosted.org/packages/d3/7e/f334fc133f1a710841b0d6ddf8d29148c6b367f32b270f8664529e622559/sgl_deep_gemm-0.2.0-py3-none-manylinux2014_x86_64.whl", upload-time = 2026-09-14T06:16:37Z, size = 5419649, hashes = { sha256 = "f208c333fca6686b482abc1e2dbb1960cd73be92f632829dc46fd6f7e9b9fb4d" } }] +version = "0.2.0+cu130" +archive = { url = "https://github.com/sgl-project/whl/releases/download/v0.2.0/sgl_deep_gemm-0.2.0+cu130-py3-none-manylinux2014_x86_64.whl", hashes = { sha256 = "acdb102d1e0ba82b64af343412214d92e0f192f4ddc07101e8763c0c1e638ac0" } } [[packages]] name = "sglang" @@ -1020,8 +1020,8 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/34/33/a253bf07c3973f2 [[packages]] name = "sglang-kernel" -version = "0.4.7" -wheels = [{ url = "https://files.pythonhosted.org/packages/63/db/45fcc5dc66de8e8f2e63c908b30bc309f20086d6b063a1aaa813c6dc478f/sglang_kernel-0.4.7-cp310-abi3-manylinux2014_x86_64.whl", upload-time = 2026-09-13T22:54:51Z, size = 373107099, hashes = { sha256 = "666f39de214a1558c5a98f43e6562e1032d8d08823b61f6a307830882f3241ce" } }] +version = "0.4.7+cu130" +archive = { url = "https://github.com/sgl-project/whl/releases/download/v0.4.7/sglang_kernel-0.4.7+cu130-cp310-abi3-manylinux2014_x86_64.whl", hashes = { sha256 = "d312128f33e95dec2f7e9f6b7f4295d092e430cb9ef3e07a3a970e0741c7023e" } } [[packages]] name = "shellingham" diff --git a/packages/sie_server/bundle-locks/cuda13-tensorrt-llm-amd64/manifest.json b/packages/sie_server/bundle-locks/cuda13-tensorrt-llm-amd64/manifest.json index a21e0e6d6..322a54c37 100644 --- a/packages/sie_server/bundle-locks/cuda13-tensorrt-llm-amd64/manifest.json +++ b/packages/sie_server/bundle-locks/cuda13-tensorrt-llm-amd64/manifest.json @@ -30,8 +30,9 @@ "uv_lock_sha256": "70fa46eb35df2c928eb419caec58a8cda544aea28196ef127006a65bb062ef94" }, "lock_sha256": "53da95f8af3e7c4b2b35daa5265c2e7962c833940b234dff71cb24829ecbc78c", - "policy_sha256": "843447f263635fd10ec336d2e678de73ef23dfc1ae1cd07cc83ee9c204a6b203", + "policy_sha256": "ad0ea4aba9172f1b79f0c8fb274af90d4d3d161c74e0eb578f9d63c3cd3b5bea", "schema_version": 1, + "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { "architecture": "amd64", "bundle": "tensorrt-llm", diff --git a/packages/sie_server/bundle-locks/exceptions.json b/packages/sie_server/bundle-locks/exceptions.json index e4ee6707d..4a309a278 100644 --- a/packages/sie_server/bundle-locks/exceptions.json +++ b/packages/sie_server/bundle-locks/exceptions.json @@ -1,5 +1,27 @@ { "schema_version": 1, + "source_pins": { + "cuda13-sglang-cu130-amd64": { + "sgl-deep-ep": { + "reason": "Preserve the CUDA13 bundle's native cu130 variant. The official cu130 index omits upload timestamps, so uv0.9.28 excludes this artifact under the global cutoff. This exact public wheel and SHA256 are an explicit source exception; the cutoff still applies to index-resolved candidates.", + "sha256": "9c15cb83b56bcc1ec1a838f47a06e9e067c69e0f0b16498d0e7451a548c2047a", + "url": "https://github.com/sgl-project/whl/releases/download/v0.1.2/sgl_deep_ep-0.1.2+cu130-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", + "version": "0.1.2+cu130" + }, + "sgl-deep-gemm": { + "reason": "Preserve the CUDA13 compatibility smoke's required 0.2.0+cu130 variant. The official cu130 index omits upload timestamps, so uv0.9.28 excludes this artifact under the global cutoff. This exact public wheel and SHA256 are an explicit source exception; the cutoff still applies to index-resolved candidates.", + "sha256": "acdb102d1e0ba82b64af343412214d92e0f192f4ddc07101e8763c0c1e638ac0", + "url": "https://github.com/sgl-project/whl/releases/download/v0.2.0/sgl_deep_gemm-0.2.0+cu130-py3-none-manylinux2014_x86_64.whl", + "version": "0.2.0+cu130" + }, + "sglang-kernel": { + "reason": "Preserve the CUDA13 compatibility smoke's required 0.4.7+cu130 variant. The official cu130 index omits upload timestamps, so uv0.9.28 excludes this artifact under the global cutoff. This exact public wheel and SHA256 are an explicit source exception; the cutoff still applies to index-resolved candidates.", + "sha256": "d312128f33e95dec2f7e9f6b7f4295d092e430cb9ef3e07a3a970e0741c7023e", + "url": "https://github.com/sgl-project/whl/releases/download/v0.4.7/sglang_kernel-0.4.7+cu130-cp310-abi3-manylinux2014_x86_64.whl", + "version": "0.4.7+cu130" + } + } + }, "scope": "Exact version and artifact-source departures for the bundle-libs overlay only. Root-compatible overlaps remain pinned.", "targets": { "cpu-ctranslate2-amd64": {}, diff --git a/packages/sie_server/src/sie_server/bundle_lock.py b/packages/sie_server/src/sie_server/bundle_lock.py index 8e8cdcdf1..de52aad29 100644 --- a/packages/sie_server/src/sie_server/bundle_lock.py +++ b/packages/sie_server/src/sie_server/bundle_lock.py @@ -202,7 +202,10 @@ def read_packages(path: Path, target: Target) -> dict[str, dict[str, Any]]: if name in result: msg = f"duplicate locked distribution: {name}" raise ValueError(msg) - wheels = row.get("wheels", []) + wheels = list(row.get("wheels", [])) + archive = row.get("archive") + if archive and urlsplit(archive["url"]).path.endswith(".whl"): + wheels.append(archive) if wheels: compatible = False for wheel in wheels: @@ -278,6 +281,39 @@ def validate_exceptions( raise ValueError(msg) +def source_constraints(pins: Mapping[str, Mapping[str, str]]) -> list[str]: + """Bind an undated platform wheel without relaxing the global cutoff.""" + result = [] + for name, pin in sorted(pins.items()): + url = _public_url(pin.get("url")) + sha = pin.get("sha256", "") + filename = unquote(urlsplit(url).path).rsplit("/", maxsplit=1)[-1] + wheel_name, version, _build, _tags = parse_wheel_filename(filename) + if ( + canonicalize_name(name) != name + or wheel_name != name + or version != Version(pin["version"]) + or not _SHA256.fullmatch(sha) + or urlsplit(url).fragment + or not pin.get("reason", "").strip() + ): + msg = f"platform source pin is not exact or documented: {name}" + raise ValueError(msg) + result.append(f"{name} @ {url}#sha256={sha}") + return result + + +def validate_source_pins(packages: Mapping[str, Mapping[str, Any]], pins: Mapping[str, Mapping[str, str]]) -> None: + """A recorded platform source is mandatory, not merely an index hint.""" + source_constraints(pins) + for name, pin in pins.items(): + package = packages.get(name) + expected = [{"url": pin["url"], "sha256": pin["sha256"]}] + if package is None or package["version"] != pin["version"] or artifact_sources(package) != expected: + msg = f"locked platform source differs: {name}" + raise ValueError(msg) + + def _check_requirement_source(requirement: Requirement, package: Mapping[str, Any]) -> None: if requirement.url is None: return @@ -314,15 +350,20 @@ def check_lock( requirements = bundle_requirements(bundles, target) expected_inputs = {"uv_lock_sha256": digest(root_lock), "requirements_sha256": canonical_digest(requirements)} exceptions = exception_file["targets"].get(target.name, {}) + source_pins = exception_file.get("source_pins", {}).get(target.name, {}) if manifest.get("inputs") != expected_inputs or manifest.get("exceptions_sha256") != canonical_digest(exceptions): msg = "bundle lock inputs changed; recompile and review the complete closure" raise ValueError(msg) + if manifest.get("source_pins_sha256") != canonical_digest(source_pins): + msg = "bundle platform source pins changed; recompile and review" + raise ValueError(msg) lock = folder / "pylock.toml" if manifest.get("lock_sha256") != digest(lock): msg = "bundle lock hash differs" raise ValueError(msg) packages = read_packages(lock, target) validate_exceptions(packages, root_lock, exceptions) + validate_source_pins(packages, source_pins) for line in requirements: requirement = Requirement(line) if requirement.marker is not None and not requirement.marker.evaluate(target.marker_environment()): @@ -443,6 +484,7 @@ def verify_inventory( "lock_sha256": checked["manifest"]["lock_sha256"], "inputs": checked["manifest"]["inputs"], "exceptions_sha256": checked["manifest"]["exceptions_sha256"], + "source_pins_sha256": checked["manifest"]["source_pins_sha256"], "policy_sha256": checked["manifest"]["policy_sha256"], "uv_version": checked["manifest"]["uv_version"], "runtime_python_version": host_platform.python_version(), diff --git a/packages/sie_server/tests/core/test_bundle_image_resolution.py b/packages/sie_server/tests/core/test_bundle_image_resolution.py index 49f4bf894..4ffbee783 100644 --- a/packages/sie_server/tests/core/test_bundle_image_resolution.py +++ b/packages/sie_server/tests/core/test_bundle_image_resolution.py @@ -7,6 +7,7 @@ from __future__ import annotations +import importlib.util import os import shutil import subprocess @@ -17,10 +18,13 @@ import pytest from sie_server.bundle_lock import UV_VERSION, Target, check_lock -from tools.ci.bundle_lock import BUNDLES, LOCKS, resolver_environment, targets - _REPO_ROOT = Path(__file__).resolve().parents[4] -_TARGETS = targets(_REPO_ROOT) +_COMPILER_SPEC = importlib.util.spec_from_file_location("bundle_lock_compiler", _REPO_ROOT / "tools/ci/bundle_lock.py") +assert _COMPILER_SPEC is not None +assert _COMPILER_SPEC.loader is not None +compiler = importlib.util.module_from_spec(_COMPILER_SPEC) +_COMPILER_SPEC.loader.exec_module(compiler) +_TARGETS = compiler.targets(_REPO_ROOT) def _uv_executable() -> str: @@ -47,7 +51,7 @@ def test_missing_uv_fails_the_opt_in(monkeypatch: pytest.MonkeyPatch) -> None: ) @pytest.mark.parametrize("target", _TARGETS, ids=[target.name for target in _TARGETS]) def test_saved_bundle_is_consumed_without_fresh_resolution(target: Target) -> None: - check_lock(_REPO_ROOT / LOCKS, _REPO_ROOT / BUNDLES, _REPO_ROOT / "uv.lock", target) + check_lock(_REPO_ROOT / compiler.LOCKS, _REPO_ROOT / compiler.BUNDLES, _REPO_ROOT / "uv.lock", target) with tempfile.TemporaryDirectory() as temp: command = [ _uv_executable(), @@ -63,14 +67,14 @@ def test_saved_bundle_is_consumed_without_fresh_resolution(target: Target) -> No "3.12", "--target", str(Path(temp) / "bundle-libs"), - str(_REPO_ROOT / LOCKS / target.name / "pylock.toml"), + str(_REPO_ROOT / compiler.LOCKS / target.name / "pylock.toml"), ] completed = subprocess.run( # noqa: S603 - fixed installer arguments and checked repository lock command, check=False, capture_output=True, text=True, - env=resolver_environment(), + env=compiler.resolver_environment(), cwd=temp, timeout=900, ) diff --git a/packages/sie_server/tests/core/test_bundle_lock.py b/packages/sie_server/tests/core/test_bundle_lock.py index d26b479ff..e1686741b 100644 --- a/packages/sie_server/tests/core/test_bundle_lock.py +++ b/packages/sie_server/tests/core/test_bundle_lock.py @@ -18,7 +18,9 @@ read_packages, required_exceptions, root_constraints, + source_constraints, validate_exceptions, + validate_source_pins, verify_inventory, ) @@ -65,6 +67,7 @@ def locked(tmp_path): "inputs": {"uv_lock_sha256": digest(root_lock), "requirements_sha256": canonical_digest(["demo>=1,<2"])}, "lock_sha256": digest(lock), "exceptions_sha256": canonical_digest({}), + "source_pins_sha256": canonical_digest({}), } (folder / "manifest.json").write_text(json.dumps(manifest)) (locks / "exceptions.json").write_text(json.dumps({"schema_version": 1, "targets": {}})) @@ -81,7 +84,7 @@ def test_clean_metadata_inventory_is_checked_without_importing_package(locked, t assert receipt["lock_sha256"] == checked["manifest"]["lock_sha256"] -@pytest.mark.parametrize("mutation", ["root", "requirements", "target", "lock", "exception", "policy"]) +@pytest.mark.parametrize("mutation", ["root", "requirements", "target", "lock", "exception", "source_pin", "policy"]) def test_stale_inputs_and_wrong_target_fail_before_install(locked, mutation): locks, bundles, root_lock = locked manifest_path = locks / TARGET.name / "manifest.json" @@ -99,6 +102,10 @@ def test_stale_inputs_and_wrong_target_fail_before_install(locked, mutation): elif mutation == "policy": manifest["policy_sha256"] = "c" * 64 manifest_path.write_text(json.dumps(manifest)) + elif mutation == "source_pin": + (locks / "exceptions.json").write_text( + json.dumps({"schema_version": 1, "targets": {}, "source_pins": {TARGET.name: {"demo": {}}}}) + ) else: (locks / "exceptions.json").write_text( json.dumps({"schema_version": 1, "targets": {TARGET.name: {"demo": {"version": "2.0"}}}}) @@ -183,6 +190,56 @@ def test_root_pins_do_not_use_a_post_release_wildcard(tmp_path): assert root_constraints(lock, {}) == ["torch==2.9.1"] +def pinned_source(): + return {"demo": {"version": "1.0", "url": WHEEL_URL, "sha256": HASH, "reason": "Exact undated platform wheel."}} + + +def test_platform_source_pin_constrains_version_url_and_hash(locked): + pins = pinned_source() + assert source_constraints(pins) == [f"demo @ {WHEEL_URL}#sha256={HASH}"] + packages = read_packages(locked[0] / TARGET.name / "pylock.toml", TARGET) + validate_source_pins(packages, pins) + + +@pytest.mark.parametrize("mutation", ["missing", "version", "url", "hash", "stale"]) +def test_platform_source_substitution_is_rejected(locked, mutation): + packages = read_packages(locked[0] / TARGET.name / "pylock.toml", TARGET) + pins = pinned_source() + if mutation == "missing": + packages.pop("demo") + elif mutation == "version": + packages["demo"]["version"] = "1.1" + elif mutation == "url": + packages["demo"]["wheels"][0]["url"] = WHEEL_URL.replace("files.pythonhosted.org", "example.test") + elif mutation == "hash": + packages["demo"]["wheels"][0]["hashes"]["sha256"] = "b" * 64 + else: + pins["other"] = pins.pop("demo") | {"url": WHEEL_URL.replace("demo-", "other-")} + with pytest.raises(ValueError, match="locked platform source differs"): + validate_source_pins(packages, pins) + + +@pytest.mark.parametrize( + ("field", "value"), [("sha256", "unpinned"), ("version", "1.1"), ("reason", ""), ("url", WHEEL_URL + "#unreviewed")] +) +def test_inexact_platform_pin_is_refused_before_compile(field, value): + pins = pinned_source() + pins["demo"][field] = value + with pytest.raises(ValueError, match="not exact or documented"): + source_constraints(pins) + + +def test_direct_wheel_source_still_checks_target_architecture(locked): + path = locked[0] / TARGET.name / "pylock.toml" + arm_url = WHEEL_URL.replace("py3-none-any", "cp312-cp312-manylinux_2_28_aarch64") + path.write_text( + 'lock-version = "1.0"\n[[packages]]\nname = "demo"\nversion = "1.0"\n' + f'archive = {{url = "{arm_url}", hashes = {{sha256 = "{HASH}"}}}}\n' + ) + with pytest.raises(ValueError, match="wheel architecture differs"): + read_packages(path, TARGET) + + @pytest.mark.parametrize( "source", [ diff --git a/tools/ci/bundle_lock.py b/tools/ci/bundle_lock.py index fecce53ca..c920cc569 100644 --- a/tools/ci/bundle_lock.py +++ b/tools/ci/bundle_lock.py @@ -32,7 +32,9 @@ policy_digest, read_packages, root_constraints, + source_constraints, validate_exceptions, + validate_source_pins, ) ROOT = Path(__file__).resolve().parents[2] @@ -138,8 +140,9 @@ def complete_artifact_hashes(lock: Path) -> list[dict[str, object]]: def compile_target(root: Path, target: Target, uv: str, cutoff: str, cache: Path | None) -> None: policy = json.loads((root / LOCKS / "exceptions.json").read_text()) exceptions = policy["targets"].get(target.name, {}) + source_pins = policy.get("source_pins", {}).get(target.name, {}) requirements = bundle_requirements(root / BUNDLES, target) - constraints = root_constraints(root / "uv.lock", exceptions) + constraints = root_constraints(root / "uv.lock", exceptions) + source_constraints(source_pins) version = subprocess.run( # noqa: S603 - explicit compiler executable, no shell [uv, "--version"], check=True, capture_output=True, text=True ).stdout.split() @@ -182,6 +185,7 @@ def compile_target(root: Path, target: Target, uv: str, cutoff: str, cache: Path completed_hashes = complete_artifact_hashes(directory / "pylock.toml") packages = read_packages(directory / "pylock.toml", target) validate_exceptions(packages, root / "uv.lock", exceptions) + validate_source_pins(packages, source_pins) manifest = { "schema_version": SCHEMA_VERSION, "target": target.as_dict(), @@ -195,6 +199,7 @@ def compile_target(root: Path, target: Target, uv: str, cutoff: str, cache: Path "requirements_sha256": canonical_digest(requirements), }, "exceptions_sha256": canonical_digest(exceptions), + "source_pins_sha256": canonical_digest(source_pins), "lock_sha256": digest(directory / "pylock.toml"), } destination = root / LOCKS / target.name diff --git a/tools/ci/tests/test_bundle_lock.py b/tools/ci/tests/test_bundle_lock.py index 85fe6825b..fad1186b5 100644 --- a/tools/ci/tests/test_bundle_lock.py +++ b/tools/ci/tests/test_bundle_lock.py @@ -5,6 +5,8 @@ import hashlib import io import json +from pathlib import Path +from types import SimpleNamespace import pytest from sie_server.bundle_lock import Target @@ -104,3 +106,30 @@ def test_saved_target_and_index_policy_cannot_drift(tmp_path, monkeypatch): def test_repository_locks_bind_current_public_inputs(): bundle_lock.check_all(bundle_lock.ROOT) + + +def test_direct_platform_pins_keep_the_global_index_cutoff(tmp_path, monkeypatch): + target = Target("cuda13", "sglang-cu130", "amd64") + locks = tmp_path / bundle_lock.LOCKS + locks.mkdir(parents=True) + url = "https://example.test/demo-1.0+cu130-cp312-cp312-manylinux_2_28_x86_64.whl" + pin = {"version": "1.0+cu130", "url": url, "sha256": "a" * 64, "reason": "Undated native platform wheel."} + (locks / "exceptions.json").write_text(json.dumps({"targets": {}, "source_pins": {target.name: {"demo": pin}}})) + monkeypatch.setattr(bundle_lock, "bundle_requirements", lambda *_args: ["demo==1.0"]) + monkeypatch.setattr(bundle_lock, "root_constraints", lambda *_args: ["packaging==24.2"]) + calls = [] + + def compile_probe(command, **kwargs): + if command == ["uv", "--version"]: + return SimpleNamespace(stdout="uv 0.9.28\n") + calls.append(command) + constraints = (Path(kwargs["cwd"]) / "constraints.txt").read_text().splitlines() + assert constraints == ["packaging==24.2", f"demo @ {url}#sha256={'a' * 64}"] + assert command[command.index("--exclude-newer") + 1] == "2026-10-18T00:00:00Z" + assert "--exclude-newer-package" not in command + raise RuntimeError("stop before resolver") + + monkeypatch.setattr(bundle_lock.subprocess, "run", compile_probe) + with pytest.raises(RuntimeError, match="stop before resolver"): + bundle_lock.compile_target(tmp_path, target, "uv", "2026-10-18T00:00:00Z", None) + assert len(calls) == 1 From a4cdffadf86aa7b370e209877addaad754e720a9 Mon Sep 17 00:00:00 2001 From: svonava Date: Sun, 18 Oct 2026 04:10:16 -0700 Subject: [PATCH 10/13] fix(ci): select the exact bundle lock installer --- .github/workflows/ci.yml | 6 ++-- packages/sie_server/bundle-locks/README.md | 7 +++-- .../core/test_bundle_image_resolution.py | 30 +++++++++++++++++-- 3 files changed, 36 insertions(+), 7 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 0a3895ecf..292f8a8f7 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -127,9 +127,9 @@ jobs: - name: Validate every saved target with the Docker installer env: SIE_RUN_IMAGE_RESOLUTION: "1" - run: >- - mise exec --no-deps uv@0.9.28 -- uv run --frozen --project . --no-sync pytest -q - packages/sie_server/tests/core/test_bundle_image_resolution.py + run: | + export SIE_BUNDLE_LOCK_UV="$(mise exec --no-deps uv@0.9.28 -- which uv)" + mise exec -- uv run --frozen --project . --no-sync pytest -q packages/sie_server/tests/core/test_bundle_image_resolution.py typescript: name: CI / TypeScript diff --git a/packages/sie_server/bundle-locks/README.md b/packages/sie_server/bundle-locks/README.md index 6b3e4dede..ff0ad72d5 100644 --- a/packages/sie_server/bundle-locks/README.md +++ b/packages/sie_server/bundle-locks/README.md @@ -69,19 +69,22 @@ From a bootstrapped clean checkout: ```console mise exec -- uv run --frozen --no-sync python tools/ci/bundle_lock.py check mise install uv@0.9.28 -SIE_RUN_IMAGE_RESOLUTION=1 mise exec --no-deps uv@0.9.28 -- uv run --frozen --no-sync pytest -q packages/sie_server/tests/core/test_bundle_image_resolution.py +export SIE_BUNDLE_LOCK_UV="$(mise exec --no-deps uv@0.9.28 -- which uv)" +SIE_RUN_IMAGE_RESOLUTION=1 mise exec -- uv run --frozen --no-sync pytest -q packages/sie_server/tests/core/test_bundle_image_resolution.py ``` The required Bundle resolution CI job runs these checks for all 15 targets. Its dry runs check the actual saved-lock reader without installing model packages. Image builds perform the additional installed-inventory check. +The explicit installer path prevents `uv run` from selecting the separate uv +version installed in the project environment; its version is still checked. For an intentional update, first review any new root/bundle conflicts and edit the exact exception records. Compile with an explicit cutoff using only public indexes, then review the complete lock and manifest diff: ```console -mise exec --no-deps uv@0.9.28 -- uv run --frozen --no-sync python tools/ci/bundle_lock.py compile --target cpu-default-amd64 --exclude-newer 2026-10-18T00:00:00Z +mise exec -- uv run --frozen --no-sync python tools/ci/bundle_lock.py compile --uv "$SIE_BUNDLE_LOCK_UV" --target cpu-default-amd64 --exclude-newer 2026-10-18T00:00:00Z ``` The compiler rejects a different uv version and strips ambient pip/uv index, diff --git a/packages/sie_server/tests/core/test_bundle_image_resolution.py b/packages/sie_server/tests/core/test_bundle_image_resolution.py index 4ffbee783..a713af894 100644 --- a/packages/sie_server/tests/core/test_bundle_image_resolution.py +++ b/packages/sie_server/tests/core/test_bundle_image_resolution.py @@ -14,6 +14,7 @@ import sys import tempfile from pathlib import Path +from types import SimpleNamespace import pytest from sie_server.bundle_lock import UV_VERSION, Target, check_lock @@ -28,23 +29,48 @@ def _uv_executable() -> str: - found = shutil.which("uv") + # uv run prepends the project environment, which contains the separately + # root-pinned uv. CI resolves the Docker installer before entering it. + found = os.environ.get("SIE_BUNDLE_LOCK_UV") or shutil.which("uv") if not found: pytest.fail("SIE_RUN_IMAGE_RESOLUTION=1 but uv is not installed") version = subprocess.run( # noqa: S603 - version-check the explicitly selected uv executable [found, "--version"], check=True, text=True, capture_output=True ).stdout.split() if version[:2] != ["uv", UV_VERSION]: - pytest.fail(f"bundle image validation requires the Docker-pinned uv {UV_VERSION}") + pytest.fail( + f"bundle image validation requires the Docker-pinned uv {UV_VERSION}; found {version[:2]} at {found}" + ) return found def test_missing_uv_fails_the_opt_in(monkeypatch: pytest.MonkeyPatch) -> None: + monkeypatch.delenv("SIE_BUNDLE_LOCK_UV", raising=False) monkeypatch.setattr(shutil, "which", lambda _name: None) with pytest.raises(pytest.fail.Exception, match="uv is not installed"): _uv_executable() +def test_explicit_installer_wins_over_the_project_uv(monkeypatch: pytest.MonkeyPatch) -> None: + monkeypatch.setenv("SIE_BUNDLE_LOCK_UV", "/docker-pinned/uv") + monkeypatch.setattr(shutil, "which", lambda _name: pytest.fail("must not select the project uv")) + + def version(command, **_kwargs): + assert command == ["/docker-pinned/uv", "--version"] + return SimpleNamespace(stdout=f"uv {UV_VERSION}\n") + + monkeypatch.setattr(subprocess, "run", version) + assert _uv_executable() == "/docker-pinned/uv" + + +def test_explicit_wrong_installer_is_not_a_version_bypass(monkeypatch: pytest.MonkeyPatch) -> None: + monkeypatch.setenv("SIE_BUNDLE_LOCK_UV", "/wrong/uv") + monkeypatch.setattr(shutil, "which", lambda _name: pytest.fail("must not silently fall back")) + monkeypatch.setattr(subprocess, "run", lambda *_args, **_kwargs: SimpleNamespace(stdout="uv 0.5.31\n")) + with pytest.raises(pytest.fail.Exception, match="requires the Docker-pinned uv"): + _uv_executable() + + @pytest.mark.skipif( os.environ.get("SIE_RUN_IMAGE_RESOLUTION") != "1", reason="opt-in installer compatibility check", From e67b964d7c0e7623af2bb264d451d5f658b6b08c Mon Sep 17 00:00:00 2001 From: svonava Date: Sun, 18 Oct 2026 04:21:01 -0700 Subject: [PATCH 11/13] fix(ci): preserve installer resolver failures --- .github/workflows/ci.yml | 3 ++- packages/sie_server/bundle-locks/README.md | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 292f8a8f7..e689b255f 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -128,7 +128,8 @@ jobs: env: SIE_RUN_IMAGE_RESOLUTION: "1" run: | - export SIE_BUNDLE_LOCK_UV="$(mise exec --no-deps uv@0.9.28 -- which uv)" + SIE_BUNDLE_LOCK_UV="$(mise exec --no-deps uv@0.9.28 -- which uv)" + export SIE_BUNDLE_LOCK_UV mise exec -- uv run --frozen --project . --no-sync pytest -q packages/sie_server/tests/core/test_bundle_image_resolution.py typescript: diff --git a/packages/sie_server/bundle-locks/README.md b/packages/sie_server/bundle-locks/README.md index ff0ad72d5..d113648a3 100644 --- a/packages/sie_server/bundle-locks/README.md +++ b/packages/sie_server/bundle-locks/README.md @@ -69,7 +69,8 @@ From a bootstrapped clean checkout: ```console mise exec -- uv run --frozen --no-sync python tools/ci/bundle_lock.py check mise install uv@0.9.28 -export SIE_BUNDLE_LOCK_UV="$(mise exec --no-deps uv@0.9.28 -- which uv)" +SIE_BUNDLE_LOCK_UV="$(mise exec --no-deps uv@0.9.28 -- which uv)" +export SIE_BUNDLE_LOCK_UV SIE_RUN_IMAGE_RESOLUTION=1 mise exec -- uv run --frozen --no-sync pytest -q packages/sie_server/tests/core/test_bundle_image_resolution.py ``` From 5099112b84b4285599bb83ca57b7cb844e21a0b2 Mon Sep 17 00:00:00 2001 From: svonava Date: Sun, 18 Oct 2026 06:57:27 -0700 Subject: [PATCH 12/13] fix(server): stop trusted pins at ambiguous lock nodes --- .../src/sie_server/bundle_requirements.py | 13 ++- .../tests/core/test_bundle_requirements.py | 79 +++++++++++++++++++ 2 files changed, 88 insertions(+), 4 deletions(-) diff --git a/packages/sie_server/src/sie_server/bundle_requirements.py b/packages/sie_server/src/sie_server/bundle_requirements.py index 778ef109a..097aa7930 100644 --- a/packages/sie_server/src/sie_server/bundle_requirements.py +++ b/packages/sie_server/src/sie_server/bundle_requirements.py @@ -213,7 +213,8 @@ def lock_constraint_lines(requirements: Sequence[str], lock: UvLock) -> list[str distribution (``huggingface-hub`` 0.36 from ``sentence-transformers`` versus ``huggingface-hub>=1`` from transformers 5). The constrained requirement itself stays pinned. A package with two public versions is - skipped with a comment instead of aborting. + skipped with a comment instead of aborting. Its combined outgoing edges + cannot establish trusted pins, but still exclude pins on untrusted paths. """ grouped = _requirement_groups(requirements) constrained: list[tuple[str, frozenset[str]]] = [] @@ -231,8 +232,8 @@ def lock_constraint_lines(requirements: Sequence[str], lock: UvLock) -> list[str else: untrusted.append(root) - constrained_reach = _reachable(constrained, lock) - exact_reach = _reachable(exact, lock) + constrained_reach = _reachable(constrained, lock, follow_ambiguous=False) + exact_reach = _reachable(exact, lock, follow_ambiguous=False) untrusted_reach = _reachable(untrusted, lock) # A transitive package an untrusted root can reach stays unpinned, even # when a constrained root reaches it too. The image installs the untrusted @@ -362,7 +363,7 @@ def _root_extras(reqs: Sequence[Requirement]) -> frozenset[str]: return frozenset(extras) -def _reachable(roots: Sequence[tuple[str, frozenset[str]]], lock: UvLock) -> set[str]: +def _reachable(roots: Sequence[tuple[str, frozenset[str]]], lock: UvLock, *, follow_ambiguous: bool = True) -> set[str]: seen_packages: set[str] = set() seen_extras: set[tuple[str, str]] = set() stack = list(roots) @@ -370,6 +371,10 @@ def _reachable(roots: Sequence[tuple[str, frozenset[str]]], lock: UvLock) -> set name, extras = stack.pop() if name not in lock.versions and name not in lock.ambiguous: continue + if not follow_ambiguous and name in lock.ambiguous: + # Keep the skip diagnostic, but not edges from an unknown version. + seen_packages.add(name) + continue if name not in seen_packages: seen_packages.add(name) for edge in lock.dependencies.get(name, ()): diff --git a/packages/sie_server/tests/core/test_bundle_requirements.py b/packages/sie_server/tests/core/test_bundle_requirements.py index 777dcd527..5a445e2a9 100644 --- a/packages/sie_server/tests/core/test_bundle_requirements.py +++ b/packages/sie_server/tests/core/test_bundle_requirements.py @@ -2,9 +2,11 @@ from pathlib import Path +import pytest import yaml from packaging.requirements import Requirement from sie_server.bundle_requirements import ( + UvLock, bundle_requirements_sha256, lock_constraint_lines, locked_versions_from_uv_lock, @@ -461,3 +463,80 @@ def test_multiple_public_versions_are_skipped_without_raising() -> None: assert "stable==3.1.0" in constraints assert not any(line.startswith("split==") for line in constraints) assert "# split skipped: uv.lock has multiple public versions" in constraints + + +@pytest.fixture +def ambiguous_dependency_lock() -> UvLock: + return parse_uv_lock(""" +version = 1 +[[package]] +name = "parent" +version = "1.0.0" +dependencies = [{ name = "split", extra = ["feature"] }] + +[[package]] +name = "split" +version = "1.0.0" +dependencies = [{ name = "old-only" }] +[package.optional-dependencies] +feature = [{ name = "optional-only" }] + +[[package]] +name = "split" +version = "2.0.0" +dependencies = [{ name = "new-only" }] + +[[package]] +name = "independent" +version = "1.0.0" +dependencies = [{ name = "old-only" }, { name = "optional-only" }] + +[[package]] +name = "untrusted" +version = "1.0.0" +dependencies = [{ name = "split", extra = ["feature"] }] + +[[package]] +name = "old-only" +version = "3.0.0" +dependencies = [{ name = "leaf" }] + +[[package]] +name = "leaf" +version = "4.0.0" + +[[package]] +name = "optional-only" +version = "5.0.0" + +[[package]] +name = "new-only" +version = "6.0.0" +""") + + +@pytest.mark.parametrize("root", ["split[feature]>=2", "parent>=1", "parent==1.0.0"]) +@pytest.mark.parametrize("independent", [False, True]) +def test_ambiguous_dependencies_need_an_independent_trusted_path( + ambiguous_dependency_lock: UvLock, root: str, independent: bool +) -> None: + requirements = [root, "independent>=1"] if independent else [root] + constraints = lock_constraint_lines(requirements, ambiguous_dependency_lock) + + assert "# split skipped: uv.lock has multiple public versions" in constraints + assert not any(line.startswith("split==") for line in constraints) + # Neither version's combined dependency graph describes a known install. + assert "new-only==6.0.0" not in constraints + for pin in ("old-only==3.0.0", "optional-only==5.0.0", "leaf==4.0.0"): + assert (pin in constraints) is independent + + +@pytest.mark.parametrize("untrusted", ["untrusted==9", "untrusted @ https://example.com/untrusted.whl"]) +def test_untrusted_paths_through_ambiguous_dependencies_still_unpin_shared_neighbors( + ambiguous_dependency_lock: UvLock, untrusted: str +) -> None: + constraints = lock_constraint_lines(["independent>=1", untrusted], ambiguous_dependency_lock) + + assert "independent==1.0.0" in constraints + for pin in ("old-only==3.0.0", "optional-only==5.0.0", "leaf==4.0.0"): + assert pin not in constraints From d020e9d3b300d661fd50d5922f58db972687c9b9 Mon Sep 17 00:00:00 2001 From: svonava Date: Sun, 18 Oct 2026 07:56:10 -0700 Subject: [PATCH 13/13] fix(build): bind compiled bundle policy to target checkout --- .../cpu-ctranslate2-amd64/manifest.json | 2 +- .../cpu-ctranslate2-arm64/manifest.json | 2 +- .../cpu-default-amd64/manifest.json | 2 +- .../cpu-default-arm64/manifest.json | 2 +- .../cpu-sglang-amd64/manifest.json | 2 +- .../cpu-sglang-arm64/manifest.json | 2 +- .../cpu-transformers5-amd64/manifest.json | 2 +- .../cpu-transformers5-arm64/manifest.json | 2 +- .../cuda12-ctranslate2-amd64/manifest.json | 2 +- .../cuda12-default-amd64/manifest.json | 2 +- .../cuda12-sglang-amd64/manifest.json | 2 +- .../manifest.json | 2 +- .../cuda12-transformers5-amd64/manifest.json | 2 +- .../cuda13-sglang-cu130-amd64/manifest.json | 2 +- .../cuda13-tensorrt-llm-amd64/manifest.json | 2 +- tools/ci/bundle_lock.py | 2 +- tools/ci/tests/test_bundle_lock.py | 48 +++++++++++++++++++ 17 files changed, 64 insertions(+), 16 deletions(-) diff --git a/packages/sie_server/bundle-locks/cpu-ctranslate2-amd64/manifest.json b/packages/sie_server/bundle-locks/cpu-ctranslate2-amd64/manifest.json index 7a3ca06b1..f35f98c58 100644 --- a/packages/sie_server/bundle-locks/cpu-ctranslate2-amd64/manifest.json +++ b/packages/sie_server/bundle-locks/cpu-ctranslate2-amd64/manifest.json @@ -15,7 +15,7 @@ "uv_lock_sha256": "536b7f46b5560f0dfbe5a503ecf4166514658f1340c4721d1ea263a43b3e5aa5" }, "lock_sha256": "1f2350156ca95ae0ed398f20d94458135d6c9ac1fd4985419e1ea6873576e718", - "policy_sha256": "a45cf878a0bfa686c968587850a783557448e69b63e75d04bd445b6b772d5ed6", + "policy_sha256": "dbc9ef2b65ea54bebe46021a7813897c378207508e4d84caf45e93d31faf15d4", "schema_version": 1, "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { diff --git a/packages/sie_server/bundle-locks/cpu-ctranslate2-arm64/manifest.json b/packages/sie_server/bundle-locks/cpu-ctranslate2-arm64/manifest.json index 727176d91..3f77f81de 100644 --- a/packages/sie_server/bundle-locks/cpu-ctranslate2-arm64/manifest.json +++ b/packages/sie_server/bundle-locks/cpu-ctranslate2-arm64/manifest.json @@ -15,7 +15,7 @@ "uv_lock_sha256": "536b7f46b5560f0dfbe5a503ecf4166514658f1340c4721d1ea263a43b3e5aa5" }, "lock_sha256": "1bc8a0f417323c67420e71cf16b71e562c7db5842b50d4c5cd60efea8106141b", - "policy_sha256": "a45cf878a0bfa686c968587850a783557448e69b63e75d04bd445b6b772d5ed6", + "policy_sha256": "dbc9ef2b65ea54bebe46021a7813897c378207508e4d84caf45e93d31faf15d4", "schema_version": 1, "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { diff --git a/packages/sie_server/bundle-locks/cpu-default-amd64/manifest.json b/packages/sie_server/bundle-locks/cpu-default-amd64/manifest.json index 294603d68..dd293ced6 100644 --- a/packages/sie_server/bundle-locks/cpu-default-amd64/manifest.json +++ b/packages/sie_server/bundle-locks/cpu-default-amd64/manifest.json @@ -26,7 +26,7 @@ "uv_lock_sha256": "536b7f46b5560f0dfbe5a503ecf4166514658f1340c4721d1ea263a43b3e5aa5" }, "lock_sha256": "2fc30b972e17643a619ecc7ba6528ae820264f9a11f7263d122931e8b9ac5e4c", - "policy_sha256": "a45cf878a0bfa686c968587850a783557448e69b63e75d04bd445b6b772d5ed6", + "policy_sha256": "dbc9ef2b65ea54bebe46021a7813897c378207508e4d84caf45e93d31faf15d4", "schema_version": 1, "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { diff --git a/packages/sie_server/bundle-locks/cpu-default-arm64/manifest.json b/packages/sie_server/bundle-locks/cpu-default-arm64/manifest.json index 9e5105b3f..fba3df785 100644 --- a/packages/sie_server/bundle-locks/cpu-default-arm64/manifest.json +++ b/packages/sie_server/bundle-locks/cpu-default-arm64/manifest.json @@ -26,7 +26,7 @@ "uv_lock_sha256": "536b7f46b5560f0dfbe5a503ecf4166514658f1340c4721d1ea263a43b3e5aa5" }, "lock_sha256": "e620951ba1e8ac2797bbca04f29847e7cd656c32f877a609740928c6b74c9e41", - "policy_sha256": "a45cf878a0bfa686c968587850a783557448e69b63e75d04bd445b6b772d5ed6", + "policy_sha256": "dbc9ef2b65ea54bebe46021a7813897c378207508e4d84caf45e93d31faf15d4", "schema_version": 1, "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { diff --git a/packages/sie_server/bundle-locks/cpu-sglang-amd64/manifest.json b/packages/sie_server/bundle-locks/cpu-sglang-amd64/manifest.json index e86d9d0c5..baf07bdf9 100644 --- a/packages/sie_server/bundle-locks/cpu-sglang-amd64/manifest.json +++ b/packages/sie_server/bundle-locks/cpu-sglang-amd64/manifest.json @@ -31,7 +31,7 @@ "uv_lock_sha256": "536b7f46b5560f0dfbe5a503ecf4166514658f1340c4721d1ea263a43b3e5aa5" }, "lock_sha256": "9ad62d85b2dea1cedb4cde7256aa85e9f500ae1f00c5bcc2214b8cde7820514f", - "policy_sha256": "a45cf878a0bfa686c968587850a783557448e69b63e75d04bd445b6b772d5ed6", + "policy_sha256": "dbc9ef2b65ea54bebe46021a7813897c378207508e4d84caf45e93d31faf15d4", "schema_version": 1, "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { diff --git a/packages/sie_server/bundle-locks/cpu-sglang-arm64/manifest.json b/packages/sie_server/bundle-locks/cpu-sglang-arm64/manifest.json index c3269e65c..62f4692ed 100644 --- a/packages/sie_server/bundle-locks/cpu-sglang-arm64/manifest.json +++ b/packages/sie_server/bundle-locks/cpu-sglang-arm64/manifest.json @@ -31,7 +31,7 @@ "uv_lock_sha256": "536b7f46b5560f0dfbe5a503ecf4166514658f1340c4721d1ea263a43b3e5aa5" }, "lock_sha256": "6680e1454e1fe6bf0d4aa7b6647b6fb8c948d2eff9646a51cbdcaac56eff09fb", - "policy_sha256": "a45cf878a0bfa686c968587850a783557448e69b63e75d04bd445b6b772d5ed6", + "policy_sha256": "dbc9ef2b65ea54bebe46021a7813897c378207508e4d84caf45e93d31faf15d4", "schema_version": 1, "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { diff --git a/packages/sie_server/bundle-locks/cpu-transformers5-amd64/manifest.json b/packages/sie_server/bundle-locks/cpu-transformers5-amd64/manifest.json index 0197a426e..4116fa4ca 100644 --- a/packages/sie_server/bundle-locks/cpu-transformers5-amd64/manifest.json +++ b/packages/sie_server/bundle-locks/cpu-transformers5-amd64/manifest.json @@ -26,7 +26,7 @@ "uv_lock_sha256": "536b7f46b5560f0dfbe5a503ecf4166514658f1340c4721d1ea263a43b3e5aa5" }, "lock_sha256": "3e756b5dffc07c0527a9a3465dbab2c17a0873beefe37e39f7cbd8e68b43f6cc", - "policy_sha256": "a45cf878a0bfa686c968587850a783557448e69b63e75d04bd445b6b772d5ed6", + "policy_sha256": "dbc9ef2b65ea54bebe46021a7813897c378207508e4d84caf45e93d31faf15d4", "schema_version": 1, "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { diff --git a/packages/sie_server/bundle-locks/cpu-transformers5-arm64/manifest.json b/packages/sie_server/bundle-locks/cpu-transformers5-arm64/manifest.json index 67c919bcf..bb311b3ff 100644 --- a/packages/sie_server/bundle-locks/cpu-transformers5-arm64/manifest.json +++ b/packages/sie_server/bundle-locks/cpu-transformers5-arm64/manifest.json @@ -26,7 +26,7 @@ "uv_lock_sha256": "536b7f46b5560f0dfbe5a503ecf4166514658f1340c4721d1ea263a43b3e5aa5" }, "lock_sha256": "f0243e01019a55d573ceffa9798460b0a503d128e5f1942e8901d83658995219", - "policy_sha256": "a45cf878a0bfa686c968587850a783557448e69b63e75d04bd445b6b772d5ed6", + "policy_sha256": "dbc9ef2b65ea54bebe46021a7813897c378207508e4d84caf45e93d31faf15d4", "schema_version": 1, "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { diff --git a/packages/sie_server/bundle-locks/cuda12-ctranslate2-amd64/manifest.json b/packages/sie_server/bundle-locks/cuda12-ctranslate2-amd64/manifest.json index a61dbddb7..8ab0320c4 100644 --- a/packages/sie_server/bundle-locks/cuda12-ctranslate2-amd64/manifest.json +++ b/packages/sie_server/bundle-locks/cuda12-ctranslate2-amd64/manifest.json @@ -11,7 +11,7 @@ "uv_lock_sha256": "536b7f46b5560f0dfbe5a503ecf4166514658f1340c4721d1ea263a43b3e5aa5" }, "lock_sha256": "1f2350156ca95ae0ed398f20d94458135d6c9ac1fd4985419e1ea6873576e718", - "policy_sha256": "a45cf878a0bfa686c968587850a783557448e69b63e75d04bd445b6b772d5ed6", + "policy_sha256": "dbc9ef2b65ea54bebe46021a7813897c378207508e4d84caf45e93d31faf15d4", "schema_version": 1, "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { diff --git a/packages/sie_server/bundle-locks/cuda12-default-amd64/manifest.json b/packages/sie_server/bundle-locks/cuda12-default-amd64/manifest.json index 65e499255..27c72fdc0 100644 --- a/packages/sie_server/bundle-locks/cuda12-default-amd64/manifest.json +++ b/packages/sie_server/bundle-locks/cuda12-default-amd64/manifest.json @@ -11,7 +11,7 @@ "uv_lock_sha256": "536b7f46b5560f0dfbe5a503ecf4166514658f1340c4721d1ea263a43b3e5aa5" }, "lock_sha256": "00e18b1fd36bddd93131eeaa4606f2029dec48e3c8013734cb9bfe427181920b", - "policy_sha256": "a45cf878a0bfa686c968587850a783557448e69b63e75d04bd445b6b772d5ed6", + "policy_sha256": "dbc9ef2b65ea54bebe46021a7813897c378207508e4d84caf45e93d31faf15d4", "schema_version": 1, "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { diff --git a/packages/sie_server/bundle-locks/cuda12-sglang-amd64/manifest.json b/packages/sie_server/bundle-locks/cuda12-sglang-amd64/manifest.json index 1495c5a12..271f669ce 100644 --- a/packages/sie_server/bundle-locks/cuda12-sglang-amd64/manifest.json +++ b/packages/sie_server/bundle-locks/cuda12-sglang-amd64/manifest.json @@ -15,7 +15,7 @@ "uv_lock_sha256": "536b7f46b5560f0dfbe5a503ecf4166514658f1340c4721d1ea263a43b3e5aa5" }, "lock_sha256": "9b59da8d8bfaea7599787085f2e16e54082cb9eecf1085fec2178b98eba2439f", - "policy_sha256": "a45cf878a0bfa686c968587850a783557448e69b63e75d04bd445b6b772d5ed6", + "policy_sha256": "dbc9ef2b65ea54bebe46021a7813897c378207508e4d84caf45e93d31faf15d4", "schema_version": 1, "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { diff --git a/packages/sie_server/bundle-locks/cuda12-sglang-vision-extract-amd64/manifest.json b/packages/sie_server/bundle-locks/cuda12-sglang-vision-extract-amd64/manifest.json index f599e0d77..0c2187612 100644 --- a/packages/sie_server/bundle-locks/cuda12-sglang-vision-extract-amd64/manifest.json +++ b/packages/sie_server/bundle-locks/cuda12-sglang-vision-extract-amd64/manifest.json @@ -15,7 +15,7 @@ "uv_lock_sha256": "536b7f46b5560f0dfbe5a503ecf4166514658f1340c4721d1ea263a43b3e5aa5" }, "lock_sha256": "a74358f2ff818ad75d589987a4dd34ca9340a9a6739c8bc041671f658330bea8", - "policy_sha256": "a45cf878a0bfa686c968587850a783557448e69b63e75d04bd445b6b772d5ed6", + "policy_sha256": "dbc9ef2b65ea54bebe46021a7813897c378207508e4d84caf45e93d31faf15d4", "schema_version": 1, "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { diff --git a/packages/sie_server/bundle-locks/cuda12-transformers5-amd64/manifest.json b/packages/sie_server/bundle-locks/cuda12-transformers5-amd64/manifest.json index 5c29a3fc9..d06d1e67c 100644 --- a/packages/sie_server/bundle-locks/cuda12-transformers5-amd64/manifest.json +++ b/packages/sie_server/bundle-locks/cuda12-transformers5-amd64/manifest.json @@ -11,7 +11,7 @@ "uv_lock_sha256": "536b7f46b5560f0dfbe5a503ecf4166514658f1340c4721d1ea263a43b3e5aa5" }, "lock_sha256": "b1c1101c295e2283084a6bd7d893508c1733e611458a164d94d3b6e389665a56", - "policy_sha256": "a45cf878a0bfa686c968587850a783557448e69b63e75d04bd445b6b772d5ed6", + "policy_sha256": "dbc9ef2b65ea54bebe46021a7813897c378207508e4d84caf45e93d31faf15d4", "schema_version": 1, "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { diff --git a/packages/sie_server/bundle-locks/cuda13-sglang-cu130-amd64/manifest.json b/packages/sie_server/bundle-locks/cuda13-sglang-cu130-amd64/manifest.json index f74fadb95..8a7ae6d4a 100644 --- a/packages/sie_server/bundle-locks/cuda13-sglang-cu130-amd64/manifest.json +++ b/packages/sie_server/bundle-locks/cuda13-sglang-cu130-amd64/manifest.json @@ -30,7 +30,7 @@ "uv_lock_sha256": "536b7f46b5560f0dfbe5a503ecf4166514658f1340c4721d1ea263a43b3e5aa5" }, "lock_sha256": "35f443a12d4a0e11b81b50078724d363f7defd60f22dfe394c7fc42ce6401e1b", - "policy_sha256": "a45cf878a0bfa686c968587850a783557448e69b63e75d04bd445b6b772d5ed6", + "policy_sha256": "dbc9ef2b65ea54bebe46021a7813897c378207508e4d84caf45e93d31faf15d4", "schema_version": 1, "source_pins_sha256": "6808e668b2e2a0982ffa734b251936b07fab343a4b201d549e85333691f7ec85", "target": { diff --git a/packages/sie_server/bundle-locks/cuda13-tensorrt-llm-amd64/manifest.json b/packages/sie_server/bundle-locks/cuda13-tensorrt-llm-amd64/manifest.json index 95a99a140..f46626c63 100644 --- a/packages/sie_server/bundle-locks/cuda13-tensorrt-llm-amd64/manifest.json +++ b/packages/sie_server/bundle-locks/cuda13-tensorrt-llm-amd64/manifest.json @@ -30,7 +30,7 @@ "uv_lock_sha256": "536b7f46b5560f0dfbe5a503ecf4166514658f1340c4721d1ea263a43b3e5aa5" }, "lock_sha256": "53da95f8af3e7c4b2b35daa5265c2e7962c833940b234dff71cb24829ecbc78c", - "policy_sha256": "a45cf878a0bfa686c968587850a783557448e69b63e75d04bd445b6b772d5ed6", + "policy_sha256": "dbc9ef2b65ea54bebe46021a7813897c378207508e4d84caf45e93d31faf15d4", "schema_version": 1, "source_pins_sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", "target": { diff --git a/tools/ci/bundle_lock.py b/tools/ci/bundle_lock.py index c920cc569..51456dcf8 100644 --- a/tools/ci/bundle_lock.py +++ b/tools/ci/bundle_lock.py @@ -206,7 +206,7 @@ def compile_target(root: Path, target: Target, uv: str, cutoff: str, cache: Path destination.mkdir(parents=True, exist_ok=True) shutil.copyfile(directory / "pylock.toml", destination / "pylock.toml") (destination / "manifest.json").write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n") - check_lock(root / LOCKS, root / BUNDLES, root / "uv.lock", target) + check_lock(root / LOCKS, root / BUNDLES, root / "uv.lock", target, compiler=root / "tools/ci/bundle_lock.py") def main() -> int: diff --git a/tools/ci/tests/test_bundle_lock.py b/tools/ci/tests/test_bundle_lock.py index fad1186b5..aca5d735b 100644 --- a/tools/ci/tests/test_bundle_lock.py +++ b/tools/ci/tests/test_bundle_lock.py @@ -108,6 +108,54 @@ def test_repository_locks_bind_current_public_inputs(): bundle_lock.check_all(bundle_lock.ROOT) +def test_compile_another_checkout_binds_its_compiler_policy(tmp_path, monkeypatch): + target = Target("cpu", "default", "amd64") + compiler = tmp_path / "tools/ci/bundle_lock.py" + compiler.parent.mkdir(parents=True) + compiler.write_text("# Another checkout's independently reviewed compiler.\n") + locks = tmp_path / bundle_lock.LOCKS + locks.mkdir(parents=True) + (locks / "exceptions.json").write_text(json.dumps({"schema_version": 1, "targets": {}})) + bundles = tmp_path / bundle_lock.BUNDLES + bundles.mkdir(parents=True) + (bundles / "default.yaml").write_text('deps:\n demo: ">=1,<2"\n') + url = "https://files.pythonhosted.org/packages/demo-1.0-py3-none-any.whl" + sha = "a" * 64 + (tmp_path / "uv.lock").write_text( + 'version = 1\n[[package]]\nname = "demo"\nversion = "1.0"\n' + 'source = { registry = "https://pypi.org/simple" }\n' + f'wheels = [{{url = "{url}", hash = "sha256:{sha}"}}]\n' + ) + calls = [] + + def controlled_resolver(command, **kwargs): + calls.append(command) + if command == ["uv", "--version"]: + return SimpleNamespace(stdout="uv 0.9.28\n") + assert command[:3] == ["uv", "pip", "compile"] + directory = Path(kwargs["cwd"]) + assert (directory / "requirements.in").read_text() == "demo>=1,<2\n" + assert (directory / "constraints.txt").read_text() == "demo==1.0\n" + (directory / "pylock.toml").write_text( + 'lock-version = "1.0"\n[[packages]]\nname = "demo"\nversion = "1.0"\n' + f'wheels = [{{url = "{url}", hashes = {{sha256 = "{sha}"}}}}]\n' + ) + return SimpleNamespace(returncode=0) + + monkeypatch.setattr(bundle_lock.subprocess, "run", controlled_resolver) + bundle_lock.compile_target(tmp_path, target, "uv", "2026-10-18T00:00:00Z", None) + assert len(calls) == 2 + checked = bundle_lock.check_lock(locks, bundles, tmp_path / "uv.lock", target, compiler=compiler) + assert checked["manifest"]["policy_sha256"] == bundle_lock.policy_digest(compiler) + assert checked["manifest"]["policy_sha256"] != bundle_lock.policy_digest() + assert checked["packages"]["demo"]["version"] == "1.0" + with pytest.raises(ValueError, match="policy changed"): + bundle_lock.check_lock(locks, bundles, tmp_path / "uv.lock", target) + compiler.write_text("# Unreviewed change in the other checkout.\n") + with pytest.raises(ValueError, match="policy changed"): + bundle_lock.check_lock(locks, bundles, tmp_path / "uv.lock", target, compiler=compiler) + + def test_direct_platform_pins_keep_the_global_index_cutoff(tmp_path, monkeypatch): target = Target("cuda13", "sglang-cu130", "amd64") locks = tmp_path / bundle_lock.LOCKS