OpenJobDescription
diff --git a/‎.github/scripts/get_latest_changelog.py‎
Lines changed: 1 addition & 0 deletions b/‎.github/scripts/get_latest_changelog.py‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎.github/workflows/rust_quality.yml‎
Lines changed: 77 additions & 0 deletions b/‎.github/workflows/rust_quality.yml‎
Lines changed: 77 additions & 0 deletions
diff --git a/‎.gitignore‎
Lines changed: 15 additions & 0 deletions b/‎.gitignore‎
Lines changed: 15 additions & 0 deletions
diff --git a/‎AGENTS.md‎
Lines changed: 292 additions & 0 deletions b/‎AGENTS.md‎
Lines changed: 292 additions & 0 deletions
diff --git a/‎Cargo.toml‎
Lines changed: 3 additions & 0 deletions b/‎Cargo.toml‎
Lines changed: 3 additions & 0 deletions
diff --git a/‎_build_backend.py‎
Lines changed: 124 additions & 0 deletions b/‎_build_backend.py‎
Lines changed: 124 additions & 0 deletions
diff --git a/‎hatch.toml‎
Lines changed: 11 additions & 2 deletions b/‎hatch.toml‎
Lines changed: 11 additions & 2 deletions
@@ -29,6 +29,7 @@
 
 ```
 """
+
 import re
 
 h2 = r"^##\s.*$"
 
@@ -0,0 +1,77 @@
+name: Rust Quality
+
+# Build, lint, and test the Rust bindings crate at rust-bindings/.
+#
+# The existing Python-side code_quality workflow covers Python tests and
+# transitively builds the Rust extension via `maturin develop`, but does
+# not run `cargo test` (which covers doctests and any pure-Rust unit
+# tests added to the bindings crate).
+#
+# The bindings' `openjd-*` dependencies come from crates.io at the
+# versions pinned in `rust-bindings/Cargo.toml`. There is no sibling
+# repository requirement — local-development overrides are documented
+# in a commented-out `[patch.crates-io]` block at the bottom of that
+# file.
+
+on:
+  pull_request:
+    branches: [ mainline, release, 'patch_*' ]
+  workflow_call:
+    inputs:
+      branch:
+        required: false
+        type: string
+      tag:
+        required: false
+        type: string
+
+jobs:
+  rust_quality:
+    name: Rust (${{ matrix.os }})
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    permissions:
+      contents: read
+
+    steps:
+      - name: Checkout openjd-model-for-python
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.branch || inputs.tag || github.ref }}
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy, rustfmt
+
+      - name: Cache Cargo registry and build artifacts
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: cargo-${{ matrix.os }}-${{ hashFiles('Cargo.lock', 'rust-bindings/Cargo.toml') }}
+          restore-keys: |
+            cargo-${{ matrix.os }}-
+
+      - name: cargo fmt --check
+        run: cargo fmt --manifest-path rust-bindings/Cargo.toml --check
+
+      - name: cargo build
+        run: cargo build --manifest-path rust-bindings/Cargo.toml --all-targets
+
+      - name: cargo clippy
+        run: cargo clippy --manifest-path rust-bindings/Cargo.toml --all-targets -- -D warnings
+
+      - name: cargo test
+        run: cargo test --manifest-path rust-bindings/Cargo.toml
+
+      - name: cargo test --doc
+        # Runs separately from `cargo test` above so a docstring regression
+        # (e.g. a Python example rustdoc tries to compile as Rust) is
+        # clearly visible in the CI log.
+        run: cargo test --manifest-path rust-bindings/Cargo.toml --doc
@@ -1,6 +1,7 @@
 *~
 *#
 *.swp
+*.pdb
 
 *.DS_Store
 
@@ -22,3 +23,17 @@ __pycache__/
 /build
 /dist
 _version.py
+
+# scripts/maturin_build.py backup file
+/pyproject.toml.vcs-bak
+
+# Rust build artifacts
+/target/
+/rust-bindings/target/
+Cargo.lock
+
+# Compiled extension modules
+*.so
+*.pyd
+*.dylib
+.hypothesis/
@@ -0,0 +1,3 @@
+[workspace]
+members = ["rust-bindings"]
+resolver = "2"
@@ -0,0 +1,124 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+"""
+In-tree PEP 517 build backend that wraps `maturin` to inject a
+VCS-derived version.
+
+Why this exists: maturin reads the wheel version from
+`[project].version` in pyproject.toml (or `[package].version` in
+Cargo.toml when `dynamic = ["version"]` is set). It has no built-in
+mechanism to derive the version from git, the way hatchling+hatch-vcs
+does. This wrapper:
+
+  1. Computes the same VCS version as `scripts/generate_version.py`
+     (via setuptools_scm with the same config as `[tool.hatch.version]`).
+  2. Writes `src/openjd/model/_version.py` so the in-Python
+     `__version__` matches the wheel.
+  3. Patches pyproject.toml in place — replaces `dynamic = ["version"]`
+     with a static `version = "<v>"`.
+  4. Delegates to maturin's PEP 517 hooks.
+  5. Restores pyproject.toml in `finally`.
+
+Wired in via:
+    [build-system]
+    requires = ["maturin>=1.0,<2.0", "setuptools_scm"]
+    build-backend = "_build_backend"
+    backend-path = ["."]
+
+The companion script `scripts/maturin_build.py` does the same patching
+around `maturin develop` / `maturin build` for users who prefer those
+direct commands. Either path produces wheels with the VCS version.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import shutil
+import sys
+from pathlib import Path
+
+import maturin
+
+REPO_ROOT = Path(__file__).resolve().parent
+PYPROJECT = REPO_ROOT / "pyproject.toml"
+PYPROJECT_BAK = REPO_ROOT / "pyproject.toml.vcs-bak"
+DYNAMIC_NEEDLE = 'dynamic = ["version"]'
+
+sys.path.insert(0, str(REPO_ROOT / "scripts"))
+from generate_version import compute_version, write_version_file  # noqa: E402
+
+
+def _recover_orphan_bak() -> None:
+    """If a previous build died before restoring pyproject.toml, recover."""
+    if PYPROJECT_BAK.exists():
+        sys.stderr.write(
+            f"WARN: {PYPROJECT_BAK.name} found from a prior interrupted build; restoring.\n"
+        )
+        shutil.move(str(PYPROJECT_BAK), str(PYPROJECT))
+
+
+@contextlib.contextmanager
+def _patched_pyproject():
+    """
+    Patch [project] to have a static VCS version. Restore on exit.
+
+    If the version cannot be computed (e.g. building from an sdist with
+    no .git directory), yield without patching — maturin will fall back
+    to the static [package].version in Cargo.toml, same as today.
+    """
+    _recover_orphan_bak()
+
+    try:
+        version = compute_version()
+    except SystemExit:
+        sys.stderr.write(
+            "WARN: setuptools_scm could not derive a version (no git? no setuptools_scm?). "
+            "Falling back to static version from Cargo.toml.\n"
+        )
+        yield None
+        return
+
+    write_version_file(version)
+    original = PYPROJECT.read_text(encoding="utf-8")
+    if DYNAMIC_NEEDLE not in original:
+        sys.stderr.write(
+            f"WARN: expected {DYNAMIC_NEEDLE!r} in pyproject.toml but did not find it; "
+            "skipping version patch.\n"
+        )
+        yield version
+        return
+
+    shutil.copy2(PYPROJECT, PYPROJECT_BAK)
+    try:
+        patched = original.replace(DYNAMIC_NEEDLE, f'version = "{version}"', 1)
+        PYPROJECT.write_text(patched, encoding="utf-8")
+        yield version
+    finally:
+        shutil.move(str(PYPROJECT_BAK), str(PYPROJECT))
+
+
+def build_wheel(wheel_directory, config_settings=None, metadata_directory=None):
+    with _patched_pyproject():
+        return maturin.build_wheel(wheel_directory, config_settings, metadata_directory)
+
+
+def build_editable(wheel_directory, config_settings=None, metadata_directory=None):
+    with _patched_pyproject():
+        return maturin.build_editable(wheel_directory, config_settings, metadata_directory)
+
+
+def build_sdist(sdist_directory, config_settings=None):
+    with _patched_pyproject():
+        return maturin.build_sdist(sdist_directory, config_settings)
+
+
+def prepare_metadata_for_build_wheel(metadata_directory, config_settings=None):
+    with _patched_pyproject():
+        return maturin.prepare_metadata_for_build_wheel(metadata_directory, config_settings)
+
+
+prepare_metadata_for_build_editable = prepare_metadata_for_build_wheel
+
+# Pass-through hooks: no version patching needed for requirement queries.
+get_requires_for_build_wheel = maturin.get_requires_for_build_wheel
+get_requires_for_build_editable = maturin.get_requires_for_build_editable
+get_requires_for_build_sdist = maturin.get_requires_for_build_sdist
@@ -1,12 +1,21 @@
 [envs.default]
 pre-install-commands = [
+  "pip install maturin setuptools_scm",
+  "python scripts/maturin_build.py develop --manifest-path rust-bindings/Cargo.toml",
   "pip install -r requirements-testing.txt"
 ]
 
 [envs.default.scripts]
 sync = "pip install -r requirements-testing.txt"
-test = "pytest test/ --cov-config pyproject.toml --ignore=test/openjd/model/benchmark {args}"
-benchmark = "pytest test/openjd/model/benchmark --no-cov {args}"
+# `test` runs the canonical full test suite with the 94% coverage gate
+# enforced. CI invokes this. For ad-hoc subset runs during local
+# development (e.g. `hatch run test-subset test/openjd/expr`), use
+# `test-subset`, which collects coverage but does not enforce the gate
+# (the gate only makes sense against a full-suite run that touches every
+# coverable source tree).
+test = "pytest test/ --cov-config pyproject.toml --cov-fail-under=94 --ignore=test/openjd/model_v0/benchmark --ignore=test/openjd/model_v1/benchmark {args}"
+test-subset = "pytest --cov-config pyproject.toml --ignore=test/openjd/model_v0/benchmark --ignore=test/openjd/model_v1/benchmark {args}"
+benchmark = "pytest test/openjd/model_v0/benchmark test/openjd/model_v1/benchmark --no-cov {args}"
 typing = "mypy {args:src test}"
 style = [
   "ruff check {args:src test}",
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+[workspace]`
	`2`	`+members = ["rust-bindings"]`
	`3`	`+resolver = "2"`