cev-py 0.2.0__tar.gz

cev_py-0.2.0/.github/workflows/ci.yml

@@ -0,0 +1,36 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [macos-latest, ubuntu-latest]
+        python: ['3.11', '3.13']
+    runs-on: ${{ matrix.os }}
+    name: Python ${{ matrix.python }} on ${{ matrix.os }}
+    steps:
+      # The engine comes from crates.io (pinned in Cargo.lock).
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python }}
+      - run: rustup toolchain install stable --profile minimal && rustup default stable
+      - uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: cargo-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles('Cargo.lock') }}
+      - run: pip install uv
+      - run: uv sync --python ${{ matrix.python }}
+      - run: uv run pytest

cev_py-0.2.0/.github/workflows/publish.yml

@@ -0,0 +1,98 @@
+name: Publish to PyPI
+
+# Builds one abi3 wheel per platform (each covers every Python >= 3.11) and an
+# sdist, tests every wheel against the mock backend, then uploads them with
+# Trusted Publishing (OIDC): no PyPI token is stored in this repository. PyPI
+# is configured to trust this repo + workflow ("publish.yml") + environment
+# ("pypi") under the project's Publishing settings. A manual run only builds
+# and tests.
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+permissions: {}
+
+jobs:
+  wheels:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - target: macos-arm64
+            os: macos-latest
+          # manylinux_2_28 (glibc 2.28), so the wheels also load on older
+          # distributions than the runner's.
+          - target: linux-x86_64
+            os: ubuntu-latest
+            manylinux: '2_28'
+          - target: linux-aarch64
+            os: ubuntu-24.04-arm
+            manylinux: '2_28'
+    runs-on: ${{ matrix.os }}
+    name: ${{ matrix.target }}
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - uses: PyO3/maturin-action@v1
+        with:
+          command: build
+          args: --release --out dist
+          manylinux: ${{ matrix.manylinux || 'auto' }}
+      - name: Test the wheel
+        run: |
+          python -m pip install --upgrade pip pytest
+          python -m pip install dist/*.whl
+          python -m pytest tests
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheel-${{ matrix.target }}
+          path: dist/*.whl
+          if-no-files-found: error
+
+  sdist:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v5
+      - uses: PyO3/maturin-action@v1
+        with:
+          command: sdist
+          args: --out dist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: sdist
+          path: dist/*.tar.gz
+          if-no-files-found: error
+
+  publish:
+    needs: [wheels, sdist]
+    if: github.event_name == 'release'
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/cev-py/
+    permissions:
+      id-token: write # mint the OIDC token PyPI exchanges for upload access
+      contents: read
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/download-artifact@v4
+        with:
+          path: dist
+          merge-multiple: true
+      - name: Check the tag and the files
+        run: |
+          version=$(python3 -c 'import tomllib; print(tomllib.load(open("pyproject.toml", "rb"))["project"]["version"])')
+          test "v$version" = "$GITHUB_REF_NAME"
+          test -f "dist/cev_py-$version.tar.gz"
+          for plat in macosx_11_0_arm64 manylinux_2_28_x86_64 manylinux_2_28_aarch64; do
+            ls dist/cev_py-$version-cp311-abi3-*$plat*.whl
+          done
+          ls -l dist
+      - uses: pypa/gh-action-pypi-publish@release/v1

cev_py-0.2.0/.gitignore

@@ -0,0 +1,10 @@
+target/
+.venv/
+dist/
+__pycache__/
+*.so
+*.pyd
+*.db
+*.db-shm
+*.db-wal
+.pytest_cache/

cev_py-0.2.0/AGENTS.md

@@ -0,0 +1,75 @@
+# AGENTS.md
+
+Guidance for AI coding agents working in this repository.
+
+## What this is
+
+A Python binding for [cev](https://github.com/CarterCole/rust-cev). The
+engine, the decision log and the online learner are Rust crates in that
+repository (`cev-core`, `cev-model`, `cev-runtime`) and are published on their
+own. This repository holds only the glue: a PyO3 module and a typed Python
+package. Nothing from the engine is copied here. A change to prompts, model
+code, storage or learning belongs in rust-cev. The Node.js sibling,
+[node-cev](https://github.com/neopunisher/node-cev), has the same shape; keep
+the two APIs in step.
+
+## Layout
+
+- `src/lib.rs` — the native module `cev._native`: wraps `cev_runtime::Cev`
+  behind a class whose methods take and return JSON text, release the GIL, and
+  bound forward passes with `concurrency` permits. It also sizes rayon's global
+  pool (`threads`).
+- `python/cev/__init__.py` — the public API: `Cev`, `CevError`, `info()`.
+- `python/cev/_types.py` — `TypedDict`s for the wire format (cev's REST bodies).
+- `python/cev/_native.pyi` — stub for the compiled module.
+- `tests/test_cev.py` — pytest, against the mock backend.
+- `scripts/bench.py` — latency and throughput for one configuration.
+- `Cargo.toml` / `pyproject.toml` — the crate and the maturin build.
+
+## Commands
+
+```bash
+uv sync                              # build the module (release) into .venv; the engine comes from crates.io
+uv run pytest                        # no weights needed
+uv run maturin develop --release     # rebuild after changing src/lib.rs
+CEV_TEST_MODEL=Qwen/Qwen3-0.6B uv run pytest   # also run the real-model test
+uv run python scripts/bench.py --device cpu --threads 8
+```
+
+Run `uv run maturin develop --release && uv run pytest` before calling a
+change done.
+
+## Rules
+
+- No runtime dependencies beyond the standard library.
+- Python >= 3.11; the module is built against the stable ABI (`abi3-py311`).
+- Requests and responses keep cev's wire format so they match the REST API and
+  the exported training rows. A new `Cev.load` option needs a field in
+  `Options` (`src/lib.rs`), a keyword in `load` (and `mock` if it applies to
+  the runtime), a docstring line and a README options-table row.
+- Every native method that runs the model or touches SQLite goes through
+  `Cev::run`, which releases the GIL. Forward passes go through `Shared::pass`.
+- Native errors are `RuntimeError("<code>: <message>")`; `__init__.py` turns
+  the code into `CevError.code`. Keep the two lists of codes in step.
+- Tests must not need weights or the network: use `Cev.mock()`. Tests that
+  need a model are skipped unless `CEV_TEST_MODEL` is set.
+- Benchmark numbers in the README come from `scripts/bench.py` on the machine
+  named there. Re-measure rather than extrapolate when changing them.
+- User-visible changes get a `CHANGELOG.md` entry.
+
+## Releasing
+
+`.github/workflows/publish.yml` builds abi3 wheels (macOS arm64, manylinux_2_28
+x86_64 and aarch64) and an sdist, tests each wheel, and uploads them to PyPI
+as `cev-py` through Trusted Publishing when a GitHub release is published; no
+token is stored. PyPI trusts this repository, workflow `publish.yml` and
+environment `pypi`. To release: raise `version` in `pyproject.toml` and
+`Cargo.toml` (keep them equal), date the `CHANGELOG.md` heading, commit, then
+publish a release tagged `v<version>`; the job fails if the tag and version
+differ. A manual run of the workflow only builds and tests.
+
+The cev crates are on crates.io (pinned in `Cargo.lock`; take a new engine
+release with `cargo update -p cev-core -p cev-model -p cev-runtime`, raising
+the requirements in `Cargo.toml` first for a new minor version). To build
+against an engine checkout, see "Building from source" in the README. The PyPI
+names `cev` and `pycev` are taken; this distribution is `cev-py`.

cev_py-0.2.0/CHANGELOG.md

@@ -0,0 +1,46 @@
+# Changelog
+
+## 0.2.0 (2026-11-08)
+
+Takes cev 0.2.1, now from crates.io: building no longer needs a rust-cev
+checkout next to this repository. First version on PyPI, as `cev-py`, with
+wheels for macOS arm64 and Linux x86_64/aarch64.
+
+### Added
+- `Cev.load(model)` runs the open decision models natively: Bespoke Nimble,
+  Kev, d3, d1 and d1-omni, plus Qwen3.5 checkpoints. Short names work
+  (`"kev:0.8b"`, `"d1-omni"`, `"nimble-v3"`, ...); the family is detected from
+  the repository's files.
+- `images=` and `audio=` on `decide()`, and in `examples()`, as paths, bytes
+  or base64, for models that take them.
+- `cev.model["family"]` and `cev.model["modalities"]`.
+- Namespaces: `namespace=` on `decide()` and in `examples()` keeps feedback and
+  adapters apart. `tasks(namespace)`, `reset_task(task, namespace)`,
+  `decisions(namespace=)` and `export(namespace=)` read one namespace.
+- `Cev.mock(media=True)`, which accepts images and audio.
+
+### Changed
+- `debias` defaults to `"auto"`: `"full"` for zero-shot code readouts as
+  before, `"none"` for the trained decision models.
+
+### Fixed
+- The macOS module loads when built with Xcode 27: release builds are no
+  longer stripped, which made dyld reject the library ("mis-aligned LINKEDIT
+  string pool").
+
+## 0.1.0 (2026-10-03)
+
+First version: cev in-process for Python.
+
+### Added
+- `Cev.load()`: a Qwen3 checkpoint from a directory or the Hugging Face cache,
+  run by a native module over the cev Rust crates. Metal and Apple's Accelerate
+  BLAS on macOS, portable multi-threaded kernels elsewhere, CUDA as a build
+  feature. Every call releases the GIL.
+- `decide()`, `feedback()`, `examples()`, `tasks()`, `reset_task()`: typed
+  decisions, labels, and the online adapters that learn from them.
+- `decisions()`, `decision()`, `export()`, `export_ndjson()`, `stats()`: the
+  decision log, in memory or in a SQLite file (`db`).
+- `Cev.mock()`: the whole API without weights, for tests.
+- `threads` and `concurrency` options, `info()`, `TypedDict`s for the wire
+  format, and `scripts/bench.py`.

cev_py-0.2.0/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md