cozy-runtime 0.1.0__tar.gz

cozy_runtime-0.1.0/.dockerignore

@@ -0,0 +1,12 @@
+.git
+.worktrees
+.venv
+**/.venv
+**/__pycache__
+.mypy_cache
+.pytest_cache
+.ruff_cache
+.artifacts
+build
+dist
+*.pyc

cozy_runtime-0.1.0/.github/workflows/ci.yaml

@@ -0,0 +1,93 @@
+name: ci
+on: [push, pull_request]
+jobs:
+  # BUILD + LINT + TYPES + BOUNDARY SCANS. Nothing here asserts that a source file contains
+  # a particular string, and nothing here is a behaviour test — that is the `end-to-end` job.
+  checks:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v7
+      - run: uv python install 3.12
+      - run: uv sync
+      - run: >-
+          uv run python -c "import sys, sysconfig;
+          assert sys.implementation.name == 'cpython' and sys.version_info[:2] == (3, 12)
+          and sysconfig.get_config_var('Py_GIL_DISABLED') != 1"
+      - run: uv run ruff check .
+      # Formatting is a DETERMINISM check: one canonical rendering of the tree, so a diff is
+      # only ever a change of meaning. The generated `worker_pb2*` bindings are excluded in
+      # pyproject's `extend-exclude` — protoc's output is a copied artifact.
+      - run: uv run mypy
+      - run: uv run ruff format --check .
+      - name: Reproduce the CPython 3.12 Runtime wheel
+        run: |
+          set -euo pipefail
+          a=$(mktemp -d)
+          b=$(mktemp -d)
+          SOURCE_DATE_EPOCH=946684800 uv build --wheel --out-dir "$a"
+          SOURCE_DATE_EPOCH=946684800 uv build --wheel --out-dir "$b"
+          cmp "$a"/*.whl "$b"/*.whl
+      # AST import/dependency scans over the package boundaries, plus the frozen ES6 number
+      # vectors replayed through the real RFC 8785 writer.
+      - run: uv run python checks/architecture.py
+
+  # THE BEHAVIOUR GATE: two real runs against a real build, no mocks. The public CLI is
+  # installed from a freshly built wheel into a venv that has nothing else, then describes,
+  # replays the descriptor byte-for-byte, serves a request through the invocation kernel,
+  # walks the exit-code matrix, and runs a job through the real two-process worker.
+  end-to-end:
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v7
+      - run: uv python install 3.12
+      - run: uv sync
+      - run: uv run pytest
+
+  # THE VENDORED-DRIFT GATE (#536d). `src/cozy/worker/v1/` is a COPY of another repo's
+  # generated output, and a copy is only a copy while somebody compares the bytes.
+  #
+  # The checker is worker-protocol's own `scripts/vendored-diff.sh`, invoked rather than
+  # reimplemented: a drift checker with its own drifting generator would be its own
+  # punchline. It regenerates from the .proto with the pinned toolchain and byte-compares
+  # against what is vendored here.
+  #
+  # PINNED, not floating: `WORKER_PROTOCOL_SHA` is the protocol commit these bytes were
+  # generated from. Bumping it and re-copying `gen/python/cozy` over `src/cozy` is one
+  # change, and this job is what refuses the half of it that was forgotten.
+  drift:
+    runs-on: ubuntu-latest
+    env:
+      WORKER_PROTOCOL_SHA: 9a1e3eefdc94004a3053deedc497215422e83ac5
+    steps:
+      - uses: actions/checkout@v4
+      # SELF-ARMING, not skipped-by-default. worker-protocol-v2 is a private sibling and
+      # `github.token` is scoped to THIS repository, so the byte-diff needs a read
+      # credential only the owner can mint. Rather than sit red forever or hide behind a
+      # hand-flipped variable, the job detects the credential and runs the moment it
+      # exists — and says loudly, in the run's annotations, when it does not.
+      - id: credential
+        run: |
+          if [ -n "${{ secrets.WORKER_PROTOCOL_TOKEN }}" ]; then
+            echo "present=yes" >> "$GITHUB_OUTPUT"
+          else
+            echo "present=no" >> "$GITHUB_OUTPUT"
+            echo "::warning title=vendored-drift check not run::WORKER_PROTOCOL_TOKEN is not set, so cozy-creator/worker-protocol-v2 cannot be checked out and the byte-for-byte vendored-drift check did not run. Release validation must retain a recorded local drift check."
+          fi
+      - if: steps.credential.outputs.present == 'yes'
+        uses: actions/checkout@v4
+        with:
+          repository: cozy-creator/worker-protocol-v2
+          ref: ${{ env.WORKER_PROTOCOL_SHA }}
+          path: .worker-protocol
+          token: ${{ secrets.WORKER_PROTOCOL_TOKEN }}
+      - if: steps.credential.outputs.present == 'yes'
+        uses: astral-sh/setup-uv@v7
+      - if: steps.credential.outputs.present == 'yes'
+        uses: actions/setup-go@v5
+        with:
+          go-version: stable
+      - if: steps.credential.outputs.present == 'yes'
+        run: .worker-protocol/scripts/vendored-diff.sh src

cozy_runtime-0.1.0/.github/workflows/platform-macos-mps.yaml

@@ -0,0 +1,103 @@
+name: platform-macos-mps
+# cr-021's two macOS jobs. MANUALLY TRIGGERED ONLY — never on push/PR/schedule.
+# `probe` is the hardware probe: a live run on rented Apple Silicon that BANKS what the
+# machine actually exposes (chip class, MPS availability, allocator numbers, which dtypes
+# serve and which refuse) as an uploaded transcript. Every claim in cr-021's
+# AcceleratorFacts record is a line in that transcript or it is not a fact yet.
+on:
+  workflow_dispatch:
+    inputs:
+      runner:
+        description: >-
+          macos-15 = standard M1 3-core ($0.062/min); macos-15-xlarge = M2 Pro 5-core
+          ($0.102/min) and is the only class that can prove bf16.
+        type: choice
+        default: macos-15
+        options: [macos-15, macos-15-xlarge, macos-26, macos-26-xlarge]
+
+jobs:
+  probe:
+    runs-on: ${{ inputs.runner }}
+    timeout-minutes: 20
+    steps:
+      # No checkout: the subject is the MACHINE, not the tree. Keeping the probe independent
+      # of repo source also keeps it runnable while the source is being edited elsewhere.
+      - name: machine facts
+        run: |
+          set -x
+          uname -m
+          sw_vers
+          sysctl -n machdep.cpu.brand_string
+          sysctl -n hw.memsize
+          sysctl -n hw.ncpu
+          system_profiler SPDisplaysDataType
+
+      - name: install torch
+        run: |
+          curl -LsSf https://astral.sh/uv/install.sh | sh
+          export PATH="$HOME/.local/bin:$PATH"
+          uv python install 3.14
+          uv venv --python 3.14 .venv
+          uv pip install --python .venv/bin/python 'torch>=2.13,<3'
+          .venv/bin/python -c 'import torch; print(torch.__version__)'
+
+      - name: mps probe
+        run: |
+          export PATH="$HOME/.local/bin:$PATH"
+          cat > probe.py <<'PY'
+          import platform, sys, torch
+
+          def leg(name, fn):
+              # Every leg reports typed: SERVES with its value, or REFUSED with the exception
+              # class and message. A refusal is a RESULT here, not an error.
+              try:
+                  print(f"{name}: SERVES {fn()}")
+              except Exception as e:
+                  print(f"{name}: REFUSED {type(e).__name__}: {e}")
+
+          print("python:", sys.version.split()[0])
+          print("platform:", platform.platform(), platform.machine())
+          print("torch:", torch.__version__)
+          print("mps.is_built:", torch.backends.mps.is_built())
+          print("mps.is_available:", torch.backends.mps.is_available())
+          print("has torch.mps.Event:", hasattr(torch.mps, "Event"))
+          print("has torch.mps.Stream:", hasattr(torch.mps, "Stream"))
+          print("has set_per_process_memory_fraction:",
+                hasattr(torch.mps, "set_per_process_memory_fraction"))
+
+          d = "mps"
+          leg("fp32 matmul", lambda: (torch.randn(512, 512, device=d) @
+                                      torch.randn(512, 512, device=d)).sum().item())
+          leg("fp16 matmul", lambda: (torch.randn(512, 512, device=d, dtype=torch.float16) @
+                                      torch.randn(512, 512, device=d, dtype=torch.float16)).sum().item())
+          leg("bf16 matmul", lambda: (torch.randn(512, 512, device=d, dtype=torch.bfloat16) @
+                                      torch.randn(512, 512, device=d, dtype=torch.bfloat16)).sum().item())
+          leg("fp16 conv2d", lambda: torch.nn.Conv2d(4, 8, 3, padding=1).to(d, torch.float16)(
+              torch.randn(1, 4, 64, 64, device=d, dtype=torch.float16)).shape)
+          leg("fp16 sdpa", lambda: torch.nn.functional.scaled_dot_product_attention(
+              *[torch.randn(1, 4, 128, 64, device=d, dtype=torch.float16)] * 3).shape)
+          torch.mps.synchronize()
+
+          # The ledger's two axes collapse to one under unified memory; these are the exact
+          # allocator numbers cr-021 says the ledger reads.
+          for n in ("current_allocated_memory", "driver_allocated_memory",
+                    "recommended_max_memory"):
+              leg(f"mps.{n}", getattr(torch.mps, n))
+
+          # fp8 must refuse on MPS: the dtypes EXIST in torch, the op path does not.
+          for n in ("float8_e4m3fn", "float8_e5m2"):
+              print(f"dtype torch.{n} exists:", hasattr(torch, n))
+              leg(f"fp8 {n} on mps", lambda n=n: torch.zeros(
+                  16, 16, device=d, dtype=getattr(torch, n)).dtype)
+              leg(f"fp8 {n} matmul on mps", lambda n=n: torch._scaled_mm(
+                  torch.zeros(16, 16, device=d, dtype=getattr(torch, n)),
+                  torch.zeros(16, 16, device=d, dtype=getattr(torch, n)).t(),
+                  scale_a=torch.ones(1, device=d), scale_b=torch.ones(1, device=d)).dtype)
+          PY
+          .venv/bin/python probe.py 2>&1 | tee transcript.txt
+
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: macos-mps-transcript-${{ inputs.runner }}
+          path: transcript.txt

cozy_runtime-0.1.0/.github/workflows/platform-windows-cuda.yaml

@@ -0,0 +1,124 @@
+name: platform-windows-cuda
+# cr-020 hardware probe. MANUALLY TRIGGERED ONLY — never on push/PR/schedule. Not a test
+# suite: a live run on a Windows+NVIDIA machine that BANKS what it exposes — the driver model
+# (WDDM is the whole point of cr-020 item 6), the commit charge that makes Windows' free-RAM
+# number dishonest, the CUDA allocator numbers, and which rungs serve vs refuse typed.
+#
+# It targets a SELF-HOSTED label, so it runs on nothing until a rented box registers itself
+# under that label (see cr-020's provisioning script). Card tiers, all consumer — the class a
+# real Windows user actually owns:
+#   windows-4090-sm89   primary. sm89 → fp8 compute SERVES.
+#   windows-3090-sm86   sm86 → fp8 compute REFUSES typed. This is the consumer no-fp8 path.
+#   windows-5090-sm120  forward tier. sm120 → fp8 compute expected to serve; stock and Windows
+#                       image support are verified live at rent time, never assumed.
+# The fp8 verdict is asserted against the capability the CARD reports (>= sm89), so one file
+# proves the serve on two tiers and the refusal on the third without per-tier branching.
+on:
+  workflow_dispatch:
+    inputs:
+      runner_label:
+        description: 'Self-hosted label of the rented Windows box.'
+        type: choice
+        default: windows-4090-sm89
+        options: [windows-4090-sm89, windows-3090-sm86, windows-5090-sm120]
+      torch_index:
+        description: 'PyTorch wheel index. Cozy starts at CUDA 13.0.'
+        type: string
+        default: https://download.pytorch.org/whl/cu130
+
+jobs:
+  probe:
+    runs-on: ${{ inputs.runner_label }}
+    timeout-minutes: 60
+    defaults:
+      run:
+        shell: powershell
+    steps:
+      # No checkout: the subject is the MACHINE, not the tree.
+      - name: driver and WDDM facts
+        run: |
+          nvidia-smi
+          nvidia-smi --query-gpu=name,driver_version,compute_cap,memory.total --format=csv
+          # Driver model: WDDM levies a commit charge for ALL VRAM, TCC does not. cr-020 item 6
+          # prices host RAM off the commit-corrected number, so the model must be recorded, and
+          # the commit counters below are the measurement that replaces ComfyUI's constants.
+          nvidia-smi -q | Select-String -Pattern 'Driver Model','Current DM','Pending DM'
+          Get-CimInstance Win32_VideoController | Format-List Name,DriverVersion,AdapterRAM
+          Get-CimInstance Win32_OperatingSystem |
+            Format-List Caption,Version,TotalVisibleMemorySize,FreePhysicalMemory
+          "committed_bytes: " + (Get-Counter '\Memory\Committed Bytes').CounterSamples.CookedValue
+          "commit_limit: " + (Get-Counter '\Memory\Commit Limit').CounterSamples.CookedValue
+
+      - name: install torch
+        run: |
+          irm https://astral.sh/uv/install.ps1 | iex
+          $env:PATH = "$env:USERPROFILE\.local\bin;$env:PATH"
+          uv python install 3.14
+          uv venv --python 3.14 .venv
+          uv pip install --python .venv\Scripts\python.exe 'torch>=2.13,<3' --index-url ${{ inputs.torch_index }}
+          .venv\Scripts\python.exe -c "import torch; print(torch.__version__, torch.version.cuda)"
+
+      - name: cuda probe
+        run: |
+          $env:PATH = "$env:USERPROFILE\.local\bin;$env:PATH"
+          @'
+          import platform, sys, torch
+
+          def leg(name, fn):
+              # Typed both ways: SERVES with its value, or REFUSED with the exception class.
+              # A refusal is a RESULT here, not an error.
+              try:
+                  print(f"{name}: SERVES {fn()}")
+                  return True
+              except Exception as e:
+                  print(f"{name}: REFUSED {type(e).__name__}: {e}")
+                  return False
+
+          print("python:", sys.version.split()[0])
+          print("platform:", platform.platform(), platform.machine())
+          print("torch:", torch.__version__, "cuda:", torch.version.cuda)
+          print("cuda.is_available:", torch.cuda.is_available())
+          p = torch.cuda.get_device_properties(0)
+          cap = torch.cuda.get_device_capability(0)
+          print("device:", p.name, "capability:", cap, "total_bytes:", p.total_memory)
+          print("mem_get_info (free,total):", torch.cuda.mem_get_info(0))
+
+          d = "cuda"
+          leg("fp32 matmul", lambda: (torch.randn(1024, 1024, device=d) @
+                                      torch.randn(1024, 1024, device=d)).sum().item())
+          leg("fp16 matmul", lambda: (torch.randn(1024, 1024, device=d, dtype=torch.float16) @
+                                      torch.randn(1024, 1024, device=d, dtype=torch.float16)).sum().item())
+          leg("bf16 matmul", lambda: (torch.randn(1024, 1024, device=d, dtype=torch.bfloat16) @
+                                      torch.randn(1024, 1024, device=d, dtype=torch.bfloat16)).sum().item())
+          leg("fp16 conv2d", lambda: torch.nn.Conv2d(4, 8, 3, padding=1).to(d, torch.float16)(
+              torch.randn(1, 4, 128, 128, device=d, dtype=torch.float16)).shape)
+          torch.cuda.synchronize()
+
+          for n in ("memory_allocated", "max_memory_allocated", "memory_reserved"):
+              print(f"cuda.{n}:", getattr(torch.cuda, n)(0))
+
+          # The fp8 arm. The DTYPES exist on every build; the COMPUTE path is sm89+. Asserting
+          # the verdict against the reported capability is what makes 3090 vs 4090 a RESULT.
+          for n in ("float8_e4m3fn", "float8_e5m2"):
+              print(f"dtype torch.{n} exists:", hasattr(torch, n))
+              leg(f"fp8 {n} tensor", lambda n=n: torch.zeros(
+                  64, 64, device=d, dtype=getattr(torch, n)).dtype)
+
+          served = leg("fp8 e4m3 _scaled_mm", lambda: torch._scaled_mm(
+              torch.zeros(64, 64, device=d, dtype=torch.float8_e4m3fn),
+              torch.zeros(64, 64, device=d, dtype=torch.float8_e4m3fn).t(),
+              scale_a=torch.ones(1, device=d), scale_b=torch.ones(1, device=d),
+              out_dtype=torch.bfloat16).dtype)
+
+          expected = cap >= (8, 9)
+          print(f"VERDICT fp8_compute: expected={expected} observed={served} capability={cap}")
+          if served != expected:
+              raise SystemExit(f"fp8 compute verdict violated on capability {cap}")
+          '@ | Set-Content -Encoding utf8 probe.py
+          .venv\Scripts\python.exe probe.py 2>&1 | Tee-Object -FilePath transcript.txt
+
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: windows-cuda-transcript-${{ inputs.runner_label }}
+          path: transcript.txt

cozy_runtime-0.1.0/.github/workflows/publish.yaml

@@ -0,0 +1,48 @@
+name: Publish to PyPI
+
+# Publication IS the tag push (cozy-eval's pattern). No local publish —
+# this workflow is the single release procedure.
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    # Hang bound, not a work budget.
+    timeout-minutes: 20
+    permissions:
+      contents: read   # checkout on a private/org repo
+      id-token: write  # PyPI trusted publishing (OIDC)
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v7
+
+      - run: uv python install 3.12
+
+      # --locked: fail loudly if uv.lock drifts from pyproject.toml instead of
+      # silently resolving versions nothing ever saw.
+      - run: uv sync --locked
+
+      # ci.yaml owns lint + types + the behaviour gate on every push; the publish
+      # gate re-runs the architecture fences against the exact tagged tree rather
+      # than trusting that the tag points at a commit CI already saw.
+      - name: Fences
+        run: uv run python checks/architecture.py
+
+      - name: Version matches tag
+        run: |
+          TAG="${GITHUB_REF_NAME#v}"
+          VER="$(uv run python -c 'import tomllib;print(tomllib.load(open("pyproject.toml","rb"))["project"]["version"])')"
+          if [ "$TAG" != "$VER" ]; then
+            echo "tag v$TAG != pyproject version $VER"; exit 1
+          fi
+
+      - name: Build (sdist + pure-py wheel)
+        run: uv build
+
+      - name: Publish (trusted publishing)
+        uses: pypa/gh-action-pypi-publish@release/v1

cozy_runtime-0.1.0/.gitignore

@@ -0,0 +1,14 @@
+target/
+__pycache__/
+*.pyc
+.venv/
+dist/
+*.egg-info/
+corpus/.venv/
+results/
+corpus/package/imports/
+corpus/pipeline/imports/
+# tokenizer vocabularies: bundled package assets, staged by the harness, not committed
+corpus/pipeline/tokenizer/
+corpus/pipeline/tokenizer_2/
+outputs/

cozy_runtime-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12

cozy_runtime-0.1.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.5
+Name: cozy-runtime
+Version: 0.1.0
+Summary: Cozy v2 worker runtime: author surface, worker, executor
+Requires-Python: <3.13,>=3.12
+Requires-Dist: cryptography>=45
+Requires-Dist: grpcio>=1.76
+Requires-Dist: msgspec>=0.19
+Requires-Dist: packaging>=24
+Requires-Dist: pillow<13,>=12
+Requires-Dist: protobuf>=6.31
+Provides-Extra: corpus
+Requires-Dist: diffusers>=0.36; extra == 'corpus'
+Requires-Dist: torch<3,>=2.13; extra == 'corpus'
+Requires-Dist: transformers<5,>=4.40; extra == 'corpus'
+Provides-Extra: cuda-kernels
+Requires-Dist: cozy-runtime-cuda-kernels==0.1.0+torch2.13cu130; (sys_platform == 'linux' and platform_machine == 'x86_64') and extra == 'cuda-kernels'
+Provides-Extra: derive
+Requires-Dist: torch<3,>=2.13; extra == 'derive'
+Provides-Extra: media
+Requires-Dist: av<19,>=18.1; extra == 'media'
+Provides-Extra: model-execution
+Requires-Dist: tensorfs==0.0.8; extra == 'model-execution'