nc-gcode-interpreter 0.2.6__tar.gz → 0.2.7__tar.gz

{nc_gcode_interpreter-0.2.6 → nc_gcode_interpreter-0.2.7}/.github/workflows/build-and-release.yml

@@ -35,7 +35,9 @@ jobs:
         with:
           python-version: 3.13
       - name: Install Python linter
-        run: pip install ruff
+        # Pinned: an unpinned ruff silently widens its rule set on upgrade and
+        # turns the job red on code nobody touched. Bump deliberately.
+        run: pip install ruff==0.16.6
       - name: Lint Python code with ruff
         run: ruff check .
 

{nc_gcode_interpreter-0.2.6 → nc_gcode_interpreter-0.2.7}/CHANGELOG.md

@@ -4,6 +4,33 @@ Notable changes to **nc-gcode-interpreter**. The format loosely follows
 [Keep a Changelog](https://keepachangelog.com/); versions are git tags,
 released to PyPI.
 
+## [v0.2.7] - 2026-09-08
+
+### Changed
+
+- Local and editable builds now derive their version from `git describe`
+  instead of reporting the `0.0.0.dev0` placeholder: an editable checkout three
+  commits past `v0.2.6` reports `0.2.6.dev3+<sha>`. A small in-tree PEP 517
+  backend (`build_backend/nc_build_backend.py`) stamps the version onto the
+  `Cargo.toml` placeholder and hands off to maturin; the release CI, which
+  already writes the tag version into `Cargo.toml`, is untouched. Downstream
+  consumers installing this package editable now get a real version to pin
+  against and a signal that they are running a local edit (#65).
+- `nc-gcode-interpreter --version` now reports the actual build version. It was
+  a hard-coded `1.0` string literal that had never matched any release; a
+  `build.rs` now derives the same `git describe` version for plain `cargo`
+  builds (which don't go through the PEP 517 shim) and the CLI reads it, so a
+  dev build prints e.g. `0.2.6-dev.1+ge5f2306` and a release build prints the
+  tag.
+- Ruff's implicit default rule set widened in 0.16 and turned the lint job red
+  on 64 findings in untouched code. Pin the rule selection in `pyproject.toml`
+  and the ruff version in CI, so a linter upgrade adds rules only when asked,
+  and fix the findings. Mostly mechanical (`X | None`, `list`/`dict` builtins,
+  import sorting, explicit `zip(strict=)`). The rule set carries no `ignore`
+  list: the one rule that would have needed an exception, `FLY002`, is instead
+  satisfied by an `nc_lines(*blocks)` test helper, which keeps the NC test
+  programs one block per line with their explanatory comments intact.
+
 ## [v0.2.6] - 2026-07-09
 
 ### Added

{nc_gcode_interpreter-0.2.6 → nc_gcode_interpreter-0.2.7}/Cargo.lock

@@ -506,7 +506,7 @@ checksum = "88904434abc2901f197fe8cc55f0445e7ded921dba5911dad2e2b39b48e663c4"
 
 [[package]]
 name = "nc-gcode-interpreter"
-version = "0.2.6"
+version = "0.2.7"
 dependencies = [
  "arrow-array",
  "arrow-data",

{nc_gcode_interpreter-0.2.6 → nc_gcode_interpreter-0.2.7}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nc-gcode-interpreter"
-version = "0.2.6"
+version = "0.2.7"
 edition = "2021"
 readme = "README.md"
 

{nc_gcode_interpreter-0.2.6 → nc_gcode_interpreter-0.2.7}/Development.md

@@ -30,6 +30,33 @@ cargo build --release
 maturin develop --release --uv
 ```
 
+### Versioning
+
+`Cargo.toml` holds the placeholder version `0.0.0-dev`; the release workflow
+rewrites it from the git tag before building the wheels, so the released
+version always comes from the tag and never from a committed number.
+
+Local builds get a version too. `build_backend/nc_build_backend.py` is an
+in-tree PEP 517 backend that wraps maturin: when it sees the placeholder and
+finds a git checkout with tags, it stamps
+`git describe --tags --long --dirty` onto the `Cargo.toml` version as
+`0.2.6-dev.3+g<sha>` (maturin normalises that to the PEP 440
+`0.2.6.dev3+<sha>`), builds, then restores `Cargo.toml` and `Cargo.lock`. So an
+editable `uv sync` reports the commit it was built from rather than
+`0.0.0.dev0` - which is what lets a downstream consumer notice it is running a
+local edit of the interpreter rather than a release.
+
+Any non-placeholder version in `Cargo.toml` is left alone, so the CI release
+path is unaffected. Without git (an unpacked sdist, say) the placeholder
+stands.
+
+A plain `cargo build` doesn't go through that shim, so `build.rs` derives the
+same version independently and exposes it as `NC_GCODE_INTERPRETER_VERSION`,
+which is what the CLI's `--version` reports. It applies the same rules: an
+already-stamped `Cargo.toml` version wins, and without git the placeholder
+stands. The CLI therefore shows cargo's semver spelling
+(`0.2.6-dev.1+ge5f2306`), not maturin's PEP 440 normalisation of it.
+
 ### Release profile
 
 `[profile.release]` currently sets no `strip`/`lto` overrides. `strip = true` was

{nc_gcode_interpreter-0.2.6 → nc_gcode_interpreter-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nc-gcode-interpreter
-Version: 0.2.6
+Version: 0.2.7
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: 3.12

nc_gcode_interpreter-0.2.7/build.rs

@@ -0,0 +1,62 @@
+//! Give `nc-gcode-interpreter --version` a real version in local builds.
+//!
+//! `Cargo.toml` carries the placeholder version `0.0.0-dev`, which the release
+//! CI rewrites from the git tag. A plain `cargo build` in a checkout doesn't go
+//! through the PEP 517 shim in `build_backend/` that does the same for wheels,
+//! so without this the CLI would report `0.0.0-dev` for every dev build. Derive
+//! the same `git describe`-based version here and expose it as
+//! `NC_GCODE_INTERPRETER_VERSION`; fall back to the `Cargo.toml` version when
+//! there is no git checkout (an unpacked sdist) or the version is already
+//! stamped.
+
+use std::process::Command;
+
+const PLACEHOLDER: &str = "0.0.0-dev";
+
+fn main() {
+    // Re-derive when the checkout moves: HEAD (branch switch), the index
+    // (commits, staging) and the tags. A bare unstaged edit won't retrigger
+    // the build script, so a stale `.dirty` suffix is possible; it clears on
+    // the next `cargo build` that recompiles anything.
+    println!("cargo:rerun-if-changed=.git/HEAD");
+    println!("cargo:rerun-if-changed=.git/index");
+    println!("cargo:rerun-if-changed=.git/refs/tags");
+
+    let cargo_version = env!("CARGO_PKG_VERSION");
+    let version = if cargo_version == PLACEHOLDER {
+        git_version().unwrap_or_else(|| cargo_version.to_string())
+    } else {
+        cargo_version.to_string()
+    };
+    println!("cargo:rustc-env=NC_GCODE_INTERPRETER_VERSION={version}");
+}
+
+/// `v0.2.6-3-g1234abc[-dirty]` -> `0.2.6-dev.3+g1234abc[.dirty]`, or the bare
+/// tag when we are exactly on a clean tag.
+fn git_version() -> Option<String> {
+    let output = Command::new("git")
+        .args(["describe", "--tags", "--long", "--dirty", "--match", "v[0-9]*"])
+        .output()
+        .ok()?;
+    if !output.status.success() {
+        return None;
+    }
+    let described = String::from_utf8(output.stdout).ok()?;
+    let described = described.trim().strip_prefix('v')?;
+
+    let (described, dirty) = match described.strip_suffix("-dirty") {
+        Some(rest) => (rest, true),
+        None => (described, false),
+    };
+    // Split off the trailing `-<distance>-g<sha>`; the tag itself may contain
+    // `-`, so scan from the right.
+    let (rest, sha) = described.rsplit_once('-')?;
+    let (tag, distance) = rest.rsplit_once('-')?;
+    let distance: u32 = distance.parse().ok()?;
+
+    if distance == 0 && !dirty {
+        return Some(tag.to_string());
+    }
+    let local = if dirty { format!("{sha}.dirty") } else { sha.to_string() };
+    Some(format!("{tag}-dev.{distance}+{local}"))
+}

nc_gcode_interpreter-0.2.7/build_backend/nc_build_backend.py

@@ -0,0 +1,116 @@
+"""In-tree PEP 517 backend: give local builds a version from the git tag.
+
+`Cargo.toml` carries the placeholder version `0.0.0-dev`, which the release CI
+rewrites from the tag before building. Without this shim every non-release
+build -- notably an editable `uv sync` in a sibling checkout -- reports
+`0.0.0.dev0`, which is useless as a version floor and gives a downstream
+consumer no signal that its interpreter is a local edit rather than a release.
+
+So: when the placeholder is still in place and we are inside a git checkout
+with tags, rewrite it to a semver dev version derived from `git describe`
+(`0.2.6-dev.3+g1234abc`), which maturin normalises to the PEP 440
+`0.2.6.dev3+g1234abc`. Any other version in `Cargo.toml` is left alone, so the
+CI release path is untouched.
+"""
+
+from __future__ import annotations
+
+import re
+import subprocess
+from contextlib import contextmanager
+from pathlib import Path
+
+from maturin import build_editable as _maturin_build_editable
+from maturin import build_sdist as _maturin_build_sdist
+from maturin import build_wheel as _maturin_build_wheel
+
+# The hooks this module does not wrap are re-exported unchanged; the rest are
+# imported under an alias and overridden below.
+from maturin import (  # noqa: F401
+    get_requires_for_build_editable,
+    get_requires_for_build_sdist,
+    get_requires_for_build_wheel,
+)
+from maturin import (
+    prepare_metadata_for_build_editable as _maturin_prepare_metadata_for_build_editable,
+)
+from maturin import (
+    prepare_metadata_for_build_wheel as _maturin_prepare_metadata_for_build_wheel,
+)
+
+PLACEHOLDER = "0.0.0-dev"
+_VERSION_LINE = re.compile(r'^version = ".*"$', re.MULTILINE)
+# v0.2.6-3-g1234abc[-dirty]
+_DESCRIBE = re.compile(r"^v(?P<tag>.+)-(?P<distance>\d+)-g(?P<sha>[0-9a-f]+)(?P<dirty>-dirty)?$")
+
+
+def _git_version(root: Path) -> str | None:
+    """Semver dev version from `git describe`, or None if it can't be derived."""
+    try:
+        described = subprocess.run(
+            ["git", "describe", "--tags", "--long", "--dirty", "--match", "v[0-9]*"],
+            cwd=root,
+            capture_output=True,
+            text=True,
+            check=True,
+        ).stdout.strip()
+    except (OSError, subprocess.CalledProcessError):
+        return None
+    match = _DESCRIBE.match(described)
+    if not match:
+        return None
+    tag, distance, sha = match["tag"], int(match["distance"]), match["sha"]
+    if distance == 0 and not match["dirty"]:
+        return tag
+    local = sha if not match["dirty"] else f"{sha}.dirty"
+    return f"{tag}-dev.{distance}+{local}"
+
+
+@contextmanager
+def _versioned_cargo_toml():
+    root = Path(__file__).resolve().parent.parent
+    cargo_toml = root / "Cargo.toml"
+    cargo_lock = root / "Cargo.lock"
+    original = cargo_toml.read_text()
+    if f'version = "{PLACEHOLDER}"' not in original:
+        # CI already stamped the release version; nothing to do.
+        yield
+        return
+    version = _git_version(root)
+    if version is None:
+        yield
+        return
+    lock_original = cargo_lock.read_text() if cargo_lock.exists() else None
+    cargo_toml.write_text(_VERSION_LINE.sub(f'version = "{version}"', original, count=1))
+    try:
+        yield
+    finally:
+        cargo_toml.write_text(original)
+        # cargo rewrites the lock to match the patched version during the build.
+        if lock_original is not None:
+            cargo_lock.write_text(lock_original)
+
+
+def build_wheel(wheel_directory, config_settings=None, metadata_directory=None):
+    with _versioned_cargo_toml():
+        return _maturin_build_wheel(wheel_directory, config_settings, metadata_directory)
+
+
+def build_editable(wheel_directory, config_settings=None, metadata_directory=None):
+    with _versioned_cargo_toml():
+        return _maturin_build_editable(wheel_directory, config_settings, metadata_directory)
+
+
+def build_sdist(sdist_directory, config_settings=None):
+    with _versioned_cargo_toml():
+        return _maturin_build_sdist(sdist_directory, config_settings)
+
+
+def prepare_metadata_for_build_wheel(metadata_directory, config_settings=None):
+    with _versioned_cargo_toml():
+        return _maturin_prepare_metadata_for_build_wheel(metadata_directory, config_settings)
+
+
+def prepare_metadata_for_build_editable(metadata_directory, config_settings=None):
+    with _versioned_cargo_toml():
+        return _maturin_prepare_metadata_for_build_editable(metadata_directory, config_settings)

{nc_gcode_interpreter-0.2.6 → nc_gcode_interpreter-0.2.7}/ggroups/generate_g_commands.py

@@ -6,13 +6,13 @@
 #
 # Run from the repository root or this directory:
 #   python ggroups/generate_g_commands.py
-from pathlib import Path
 import json
+from pathlib import Path
 
 json_file = Path(__file__).parent.parent / "python/nc_gcode_interpreter/ggroups.json"
 out_file = Path(__file__).parent.parent / "src/modal_groups.rs"
 
-with open(json_file, "r") as file:
+with open(json_file) as file:
     g_groups = json.load(file)
 
 modal = [g["short_name"] for g in g_groups if g["effectiveness"] == "modal"]

{nc_gcode_interpreter-0.2.6 → nc_gcode_interpreter-0.2.7}/pyproject.toml

@@ -1,6 +1,10 @@
 [build-system]
 requires = ["maturin>=1.7,<2.0"]
-build-backend = "maturin"
+# In-tree shim around maturin: stamps a `git describe` version onto the
+# Cargo.toml placeholder so local/editable builds report e.g.
+# 0.2.6.dev3+g1234abc instead of 0.0.0.dev0. See build_backend/.
+build-backend = "nc_build_backend"
+backend-path = ["build_backend"]
 
 [project]
 name = "nc-gcode-interpreter"
@@ -51,6 +55,25 @@ Homepage = "https://github.com/CEAD-group/nc-gcode-interpreter"
 Repository = "https://github.com/CEAD-group/nc-gcode-interpreter.git"
 Documentation = "https://github.com/CEAD-group/nc-gcode-interpreter/blob/main/README.md"
 
+[tool.ruff]
+target-version = "py312"
+
+[tool.ruff.lint]
+# Pin the rule set explicitly. `ruff check .` previously ran on ruff's implicit
+# defaults, so when ruff 0.16 widened them the lint job went red on 64
+# pre-existing findings in code nobody had touched. An explicit select means a
+# ruff upgrade adds rules only when we ask for them.
+select = [
+    "E4", "E7", "E9", "F", # ruff's historical defaults
+    "I",                   # import sorting
+    "UP",                  # pyupgrade
+    "B",                   # bugbear
+    "C4",                  # comprehensions
+    "PIE",
+    "RUF",
+    "FLY",
+]
+
 [tool.mypy]
 # The viz extra's dependencies are optional: mypy runs in CI without them.
 [[tool.mypy.overrides]]

{nc_gcode_interpreter-0.2.6 → nc_gcode_interpreter-0.2.7}/python/nc_gcode_interpreter/__init__.py

@@ -1,14 +1,17 @@
-from typing import Protocol, Iterator
+import json
 import os
+from collections.abc import Callable, Iterator
+from pathlib import Path
+from typing import Any, Protocol, TypedDict
+
 import polars as pl
-from ._internal import nc_to_rows as _nc_to_rows
+
+from ._internal import (
+    NcError,
+    __doc__,  # noqa: F401
+)
 from ._internal import nc_to_batches as _nc_to_batches
-from ._internal import NcError
-from ._internal import __doc__  # noqa: F401
-import json
-from pathlib import Path
-from typing import TypedDict, TypeVar, Any, Generic
-from collections.abc import Callable
+from ._internal import nc_to_rows as _nc_to_rows
 
 
 # Define TextFileLike Protocol
@@ -17,12 +20,12 @@ class TextFileLike(Protocol):
 
 
 __all__ = [
+    "NcError",
+    "dataframe_to_nc",
+    "nc_to_batches",
     "nc_to_dataframe",
     "nc_to_rows",
-    "nc_to_batches",
     "sanitize_dataframe",
-    "dataframe_to_nc",
-    "NcError",
 ]
 
 # Batch size nc_to_dataframe uses internally when draining the batch stream it
@@ -171,14 +174,11 @@ def nc_to_dataframe(
     return pl.concat(frames, how="diagonal").select(frames[-1].columns), state
 
 
-_T = TypeVar("_T")
-
-
-class _classproperty(Generic[_T]):
-    def __init__(self, fget: Callable[[Any], _T]) -> None:
+class _classproperty[T]:
+    def __init__(self, fget: Callable[[Any], T]) -> None:
         self.fget = fget
 
-    def __get__(self, instance: Any, owner: type[Any]) -> _T:
+    def __get__(self, instance: Any, owner: type[Any]) -> T:
         return self.fget(owner)
 
 
@@ -295,10 +295,16 @@ def sanitize_dataframe(
     # Canonical column order.
     order: list[str] = []
     for name in (
-        ["N"] + modal + non_modal + known_axes
-        + sorted(c for c in value_columns if c not in known_axes and c not in block_addresses)
-        + block_addresses
-        + ["T", "M", "non_returning_function_call", "comment"]
+        "N",
+        *modal,
+        *non_modal,
+        *known_axes,
+        *sorted(c for c in value_columns if c not in known_axes and c not in block_addresses),
+        *block_addresses,
+        "T",
+        "M",
+        "non_returning_function_call",
+        "comment",
     ):
         if name in df.columns and name not in order:
             order.append(name)

{nc_gcode_interpreter-0.2.6 → nc_gcode_interpreter-0.2.7}/python/nc_gcode_interpreter/_internal.pyi

@@ -1,4 +1,5 @@
-from typing import Any, Iterator, Optional, List, Dict, Tuple
+from collections.abc import Iterator
+from typing import Any
 
 # Type stubs for the compiled Rust extension `nc_gcode_interpreter._internal`.
 # mypy cannot introspect the pyo3 module, so the public entry points the Python
@@ -13,39 +14,38 @@ class NcError(ValueError):
     #: ``"unexpected_axis"``, ``"undefined_variable"``), for branching without
     #: matching the formatted message.
     kind: str
-    line: Optional[int]
-    column: Optional[int]
-    context: Optional[str]
-    line_text: Optional[str]
+    line: int | None
+    column: int | None
+    context: str | None
+    line_text: str | None
 
 def nc_to_rows(
     input: str,
-    initial_state: Optional[str] = None,
-    axis_identifiers: Optional[List[str]] = None,
-    extra_axes: Optional[List[str]] = None,
+    initial_state: str | None = None,
+    axis_identifiers: list[str] | None = None,
+    extra_axes: list[str] | None = None,
     iteration_limit: int = 10000,
     forward_fill: bool = True,
     include_variables: bool = False,
-    axis_index_map: Optional[Dict[str, int]] = None,
+    axis_index_map: dict[str, int] | None = None,
     allow_undefined_variables: bool = False,
     input_is_path: bool = False,
-    flatten_tolerance: Optional[float] = None,
-) -> Iterator[Tuple[Any, ...]]:
+    flatten_tolerance: float | None = None,
+) -> Iterator[tuple[Any, ...]]:
     """Interpret an NC program lazily into ``(line_no, row[, variables])`` tuples."""
-    ...
 
 def nc_to_batches(
     input: str,
     batch_size: int = 500_000,
-    initial_state: Optional[str] = None,
-    axis_identifiers: Optional[List[str]] = None,
-    extra_axes: Optional[List[str]] = None,
+    initial_state: str | None = None,
+    axis_identifiers: list[str] | None = None,
+    extra_axes: list[str] | None = None,
     iteration_limit: int = 10000,
     disable_forward_fill: bool = False,
-    axis_index_map: Optional[Dict[str, int]] = None,
+    axis_index_map: dict[str, int] | None = None,
     allow_undefined_variables: bool = False,
     input_is_path: bool = False,
-    flatten_tolerance: Optional[float] = None,
+    flatten_tolerance: float | None = None,
     include_line_numbers: bool = False,
     include_variables: bool = False,
 ) -> Any:
@@ -56,6 +56,5 @@ def nc_to_batches(
     - when ``include_variables`` is set - ``variable_events`` (an Arrow batch of
     ``row_idx`` / ``name_id`` / ``value``) and ``variable_names`` (list[str]).
     """
-    ...
 
-__all__ = ["nc_to_rows", "nc_to_batches"]
+__all__ = ["nc_to_batches", "nc_to_rows"]

{nc_gcode_interpreter-0.2.6 → nc_gcode_interpreter-0.2.7}/python/nc_gcode_interpreter/cli.py

@@ -128,8 +128,9 @@ def main(argv: list[str] | None = None) -> int:
     args = build_parser().parse_args(argv)
 
     try:
-        from .viz import view_toolpath
         import threejs_viewer  # noqa: F401  - fail here, before interpreting
+
+        from .viz import view_toolpath
     except ImportError:
         print(
             "nc-view needs the viz extra: pip install 'nc-gcode-interpreter[viz]'",

{nc_gcode_interpreter-0.2.6 → nc_gcode_interpreter-0.2.7}/python/nc_gcode_interpreter/viz.py

@@ -84,7 +84,7 @@ def toolpath_arrays(
     bead_width: float | None = None,
     bead_height: float | None = None,
     default_feed: float = 1000.0,
-) -> "tuple[np.ndarray, np.ndarray | None]":
+) -> tuple[np.ndarray, np.ndarray | None]:
     """Convert an interpreter DataFrame to threejs-viewer toolpath arrays.
 
     Returns ``(data, colors)``: ``data`` is the ``(N, 6)`` float64

nc_gcode_interpreter-0.2.7/python/tests/nc_source.py

@@ -0,0 +1,11 @@
+"""Helper for writing multi-line NC programs in tests."""
+
+
+def nc_lines(*lines: str) -> str:
+    """Join NC blocks into a program, one block per line.
+
+    Written as varargs rather than `"\\n".join([...])` so each block can carry
+    its own trailing `#` comment explaining what it contributes to the expected
+    output - which is most of why these programs are written a line at a time.
+    """
+    return "\n".join(lines)