nc-gcode-interpreter 0.1.12__tar.gz → 0.2.1__tar.gz

{nc_gcode_interpreter-0.1.12 → nc_gcode_interpreter-0.2.1}/.github/workflows/build-and-release.yml

@@ -30,8 +30,8 @@ jobs:
   lint:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
         with:
           python-version: 3.13
       - name: Install Python linter
@@ -39,6 +39,21 @@ jobs:
       - name: Lint Python code with ruff
         run: ruff check .
 
+  rust-test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      # Pin the toolchain and explicitly pull in rustfmt so `cargo fmt --check`
+      # does not depend on whatever components the runner image ships with.
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt
+      - uses: Swatinem/rust-cache@v2
+      - name: Check Rust formatting
+        run: cargo fmt --check
+      - name: Run Rust unit and integration tests
+        run: cargo test
+
   linux-x64:
     needs: [lint]
     runs-on: ${{ matrix.platform.runner }}
@@ -49,8 +64,8 @@ jobs:
             target: x86_64
         python-version: ["3.12", "3.13"]
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
       - name: Update Cargo.toml Version
@@ -79,12 +94,12 @@ jobs:
       matrix:
         python-version: ["3.12", "3.13"]
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - uses: actions/download-artifact@v4
         with:
           name: wheels-ubuntu-latest-x86_64-py${{ matrix.python-version }}-${{ github.sha }}
           path: dist
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
       - name: Install py_opw_kinematics
@@ -120,8 +135,8 @@ jobs:
             target: aarch64
         python-version: ["3.12", "3.13"]
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
       - name: Update Cargo.toml Version
@@ -159,8 +174,8 @@ jobs:
             target: x64
         python-version: ["3.12", "3.13"]
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
           architecture: ${{ matrix.platform.target }}
@@ -218,8 +233,8 @@ jobs:
             target: aarch64
         python-version: ["3.12", "3.13"]
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
       - name: Update Cargo.toml Version
@@ -250,8 +265,8 @@ jobs:
     needs: [lint, test]
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
         with:
           python-version: 3.12
       - name: Update Cargo.toml Version
@@ -286,13 +301,33 @@ jobs:
       contents: write
       attestations: write
     steps:
+      # Do NOT use `merge-multiple: true`. With `--find-interpreter`, every
+      # build matrix leg (py3.12 AND py3.13) produces cp312/cp313/cp314 wheels
+      # with identical filenames but non-identical bytes (sccache makes builds
+      # nondeterministic). Merging them into one directory makes
+      # download-artifact overwrite colliding paths concurrently, truncating
+      # the file mid-write and corrupting the ZIP central directory - which
+      # PyPI reports as "Trailing data" and `wheel unpack` as "Bad magic
+      # number for central directory". Instead download each artifact into its
+      # own subdirectory and collect one intact copy of each filename.
       - uses: actions/download-artifact@v4
         with:
-          merge-multiple: true
-          path: dist
-      - uses: actions/setup-python@v5
+          path: artifacts
+      - uses: actions/setup-python@v6
         with:
           python-version: 3.12
+      - name: Collect unique wheels and sdist
+        run: |
+          mkdir -p dist
+          # Each artifact is in its own subdir, so no path collides during
+          # download. Copy the first occurrence of each basename; duplicate
+          # filenames are the same wheel for the same platform tag, so either
+          # copy is a valid, complete ZIP.
+          find artifacts -type f \( -name '*.whl' -o -name '*.tar.gz' \) | while read -r f; do
+            b=$(basename "$f")
+            [ -e "dist/$b" ] || cp "$f" "dist/$b"
+          done
+          echo "Collected artifacts:" && ls -1 dist/
       - name: Generate artifact attestation
         uses: actions/attest-build-provenance@v1
         with:

{nc_gcode_interpreter-0.1.12 → nc_gcode_interpreter-0.2.1}/.gitignore

@@ -26,3 +26,19 @@ dist/
 __pycache__
 python/**/*.so
 python/**/*.pyc
+
+# macOS
+.DS_Store
+
+# local scratch
+tmp/
+
+# real-world NC files used for manual/local testing, not for CI
+test-data/
+
+# local exploration scripts
+python/example/plot_trace.py
+python/example/smooth_e.py
+
+# local field-test data (customer programs; never commit)
+test-data/

nc_gcode_interpreter-0.2.1/CHANGELOG.md

@@ -0,0 +1,251 @@
+# Changelog
+
+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.1] - 2026-07-07
+
+### Added
+
+- Optional `line_no` output column on the batch/dataframe path, enabled with
+  `include_line_numbers=True` on `nc_to_dataframe` / `nc_to_batches` (default
+  `False`, so the output schema is unchanged unless you ask for it). When
+  enabled it prepends a leading `Int64` column giving the 1-based source line
+  each output row came from - previously only the streaming `nc_to_rows`
+  exposed it. Loops repeat the value and jumps make it non-monotonic, matching
+  `nc_to_rows` row-for-row; flatten-generated samples keep the originating
+  block's line number; `dataframe_to_nc` ignores it (source provenance, not an
+  emittable word). Concatenating batches reconstructs the same per-row
+  `line_no` as the whole-file dataframe (#45)
+- Structured error locations: parse/interpret failures now raise
+  `nc_gcode_interpreter.NcError` (a `ValueError` subclass, so existing
+  `except ValueError` keeps working) carrying the position as data - `.line`,
+  `.column` (syntax errors), `.context`, and `.line_text` attributes (each an
+  int / str or `None`) - so a caller (e.g. an editor) can locate the offending
+  token without regex-parsing the message. `str(err)` is unchanged
+
+### Fixed
+
+- Arithmetic-function arity: added a regression test pinning that every
+  `SIN`/`COS`/`ATAN2`/`BOUND`/... call already validates its argument count
+  (`check_args`) before indexing `args[..]`, returning
+  `ParsingError::InvalidFunctionArity` instead of panicking on a wrong-arity
+  call (#16).
+
+### Documented
+
+- Pinned iterator-drop -> `ParsingError::StreamClosed` as the supported
+  cancel contract for `nc_to_rows`/`nc_to_batches` (README, docstrings) and
+  noted the release-profile `strip`/`lto` tradeoff in `Development.md` (#49).
+
+## [v0.2.0] - 2026-07-07
+
+### Added
+
+- `dwell` output column: F/S on a `G4` block is the dwell time (seconds /
+  spindle revolutions), a per-block parameter - it now lands in its own
+  never-forward-filled `dwell` column instead of polluting the modal F/S
+  columns (previously `G4 F0.01` set the feed to 0.01 mm/min for every
+  following block until the next real F word)
+- Loud warnings for known-but-uninterpreted constructs (never silently
+  butcher a statement): assignments to `AR`/`AP`/`RP` (opening-angle and
+  polar arc forms) warn once per run that the motion will be wrong; `G91`
+  warns once that incremental dimensioning is not applied; the flattener
+  warns per word for CIP/CT/POLY/thread/involute pass-through
+- `TURN` output column (block address, never forward-filled): additional
+  full helix turns on G2/G3 blocks; previously swallowed as a user variable
+- Curve flattening: `flatten_tolerance` on `nc_to_dataframe` / `nc_to_rows` /
+  `nc_to_batches` (CLI: `--flatten-tolerance`) converts G2/G3 arcs (I/J/K and
+  CR= forms, all planes, helical, full circles) and ASPLINE/BSPLINE/CSPLINE
+  splines (PW weights, SD degree) into runs of G1 rows within a single
+  max-deviation tolerance of the true curve; interpolation addresses are
+  consumed, source line numbers and auxiliary cells preserved; generated
+  samples carry a `flattened = 1` marker column so the original programmed
+  points remain distinguishable
+- Optional `viz` extra (threejs-viewer >= 0.0.41):
+  `nc_gcode_interpreter.viz.view_toolpath(df)` shows a toolpath in
+  threejs-viewer as an animated bead tube (feed-rate float64 time base,
+  programmed vs flattened point coloring), and the `nc-view` console command
+  interprets + flattens + animates an .mpf in one step, with a nozzle
+  marker riding the path tip, camera follow/look-at tracking, and travel
+  moves drawn natively as a thin line in lockstep with the bead
+
+- Program jumps and branches: `GOTOF`/`GOTOB`/`GOTO`/`GOTOC`/`GOTOS` and
+  `CASE ... OF ... DEFAULT`, with per-scope label/block-number resolution,
+  jumps out of IF bodies and loops, and alarm-14080 semantics for an
+  unresolved target (`GOTOC` warns and continues) (#29)
+- Streaming API `nc_to_rows(program)`: yields `(line_no, row)` lazily while
+  the interpreter runs on a background thread — batch-identical typing and
+  forward-fill, constant memory, early abort by dropping the iterator,
+  errors raised at the offending row, final state on the exhausted
+  iterator (#35)
+- `nc_to_rows(..., include_variables=True)` yields `(line_no, row,
+  variables)` with per-block variable-assignment deltas, exposing
+  variable-only blocks that the batch DataFrame prunes (#35)
+- Spline programming: `PW`/`SD`/`PL` block addresses become output columns
+  (not forward-filled, no `TRANS` offset) instead of being silently
+  swallowed (#18)
+- G2/G3 arc interpolation parameters `I`/`J`/`K`/`CR` become per-block output
+  columns (not forward-filled, no `TRANS` offset) instead of being silently
+  dropped — arcs previously came out as straight-line endpoints (#37)
+- `nc_to_batches(program, batch_size=...)`: interpret a program into a
+  stream of columnar polars DataFrames built on a worker thread and handed
+  over via the Arrow C data interface — bounded memory for programs too
+  large to fit in one DataFrame (#37)
+- Parsing: leading-underscore identifiers (`_WITH_M0`), assignment to
+  `$AC_*` system variables (`$AC_TIMER[1] = 0`), and the `NOT` logical
+  operator (#37)
+- `DEF STRING[n]` string-variable declarations and quoted-string
+  assignments; strings stay out of the numeric pipeline (a string in an
+  expression, or a type mismatch, is a hard error, never a silent 0.0).
+  String *processing* (`SPRINT`/`INDEX`/`<<`) remains out of scope and
+  fails loudly (#40)
+- Logic, comparison and bit operators in expressions (`AND`/`OR`/`XOR`,
+  `B_AND`/`B_OR`/`B_XOR`, `==`/`<>`/`<`/`>`/`<=`/`>=`) at the manual's
+  priorities, so conditions like `IF (A == 1 AND B == 1)` work and
+  comparison results are assignable (`R11 = R10 >= 100`) (#41)
+- `$AA_IW[<axis>]` / `$AA_IM[<axis>]` read the interpreted actual work /
+  machine position of an axis, so layer loops
+  (`REPEAT ... UNTIL $AA_IW[Z] > H`) terminate; reading before the axis is
+  positioned errors loudly and the variables are read-only (#42)
+- `nc-view` prints a corrected retry command on the classic new-machine
+  failures (missing `--axis-index-map`, undefined machine-parameter
+  variables) instead of a bare traceback
+- `docs/sinumerik-execution-model.md`: how a real control executes NC code
+  versus this interpreter, and why (#30)
+
+### Changed
+
+- Rust-side polars is gone. The Table -> Python DataFrame handoff no longer
+  builds a polars DataFrame in Rust (via `pyo3-polars`); it builds an Arrow
+  record batch with the minimal `arrow-array`/`arrow-schema`/`arrow-data`
+  crates and hands it to Python zero-copy through the Arrow PyCapsule
+  interface (`__arrow_c_array__`), where `pl.DataFrame(...)` wraps it. The
+  Python API is unchanged (still returns `polars.DataFrame`), needs no
+  `pyarrow`, and performance is unchanged. This drops ~60 crates from the
+  `python`-feature build (127 -> 64), cutting a clean release build ~4x
+  (83s -> 21s), and bumps PyO3 0.28 -> 0.29 (resolving the RUSTSEC pyo3
+  advisories).
+- **Breaking:** `I`/`J`/`K`/`CR` are now treated as arc interpolation-parameter
+  block addresses (output columns), so they can no longer be used as user
+  variable names: `I=5` followed by `X=I+1` was a variable read before and is
+  now an undefined-variable error. Matches Sinumerik address semantics (#37)
+- `nc_to_dataframe` is now the concatenation of the internal batch stream
+  rather than collecting every row up front: same output, but bounded
+  intermediate memory and interpretation overlapped with DataFrame assembly
+  (a 1.1 GB program went from ~209 s / 6 GB to ~33 s / 3.3 GB) (#37)
+- An executed `M2`/`M17`/`M30` now ends the program immediately, even
+  mid-file, instead of being ignored (#29)
+- Unknown G codes now error like Sinumerik alarm 12470 instead of silently
+  parsing as a subprogram call (#31)
+- Unsupported or unmodeled statements (parameterized `ROT`/`SCALE`/`MIRROR`
+  frames, and previously jumps/`LOOP` before #29 implemented them) raise a
+  clear `UnsupportedStatement` error instead of corrupting output; a frame
+  instruction following another statement in the same block errors (#20,
+  #32)
+- Frame semantics per the manual: absolute frame instructions (`TRANS`,
+  bare `ROT`/`SCALE`/`MIRROR`) substitute — deleting previously programmed
+  offsets — rather than accumulate (#20, #26)
+- Values are f64 end-to-end to match the control's 64-bit `REAL`:
+  coordinates are bit-exact for decimal literals, `DIV` truncates the real
+  result (`7 DIV 4.1 = 1`), and `==`/`<>`/`<=`/`>=` use the manual's 1e-12
+  relative tolerance (#23)
+- The ~488-command G vocabulary and its 60 G-groups moved out of the PEG
+  grammar into a Rust table generated from `ggroups.json`; the grammar
+  recognizes lexical shape only (#32)
+- Rust-side polars removed: the core returns a plain typed table and the
+  Python wrapper builds the DataFrame, so any Python polars version works;
+  CSV and DataFrame output are unchanged (#27)
+- Dependency refresh: pest 2.8.6, pyo3 0.28, clap 4.6, polars 1.42.1 (#28)
+
+### Fixed
+
+- The NC language is case-insensitive (manual 3.3.2): lowercase axis
+  words (`g1 x0 y0`) are axis moves rather than silently-dropped subprogram
+  calls, G/M values are normalized to uppercase, and user-variable
+  identifiers fold case (a program that declares `lAYER_HEIGHT` but assigns
+  `LAYER_HEIGHT` is one variable, not two) (#43)
+- The IC-before-position warning now states what actually happens ("axis
+  incremented with `IC()` before any absolute position was set; assuming it
+  starts at 0") instead of the vague "behavior may be indeterminate"
+- Expression evaluation: correct operator precedence (`2+3*4` is now 14,
+  not 20), degree-based trig per the manual, corrected `ATAN2` argument
+  order, and `DIV` by zero errors instead of panicking (#19)
+- `TRANS`/`ATRANS` translation is applied per row at output time under the
+  frame active at that block; fixes double-applied offsets on `IC()` moves
+  and axis movement as a parsing side effect (#26)
+- Unclosed or crossed `IF`/`WHILE`/`FOR`/`LOOP`/`REPEAT` structures are
+  reported at the (innermost) opener's own line instead of as a parse
+  failure at end-of-file (#33)
+- Parse errors are phrased for humans (no grammar-internal rule names),
+  mistyped axis words like `Y2O` warn, and unresolved jump targets get
+  did-you-mean suggestions — direction-aware when the label exists but only
+  in the other search direction (#31)
+
+### Performance
+
+- Stage-1 line triage: structure-free CAM programs run through a byte
+  decoder for the >99.9% trivial lines, per-line parses for the rest —
+  a 319k-line program drops from ~33 s to ~9 s in `nc_to_dataframe`
+  (`NC_STAGE1=0` disables) (#34)
+- Grammar restructuring: ~15% faster parsing, plus an ignored 1M-line
+  benchmark harness (#30); an earlier redundant-lookahead removal cut parse
+  time ~27% (#25)
+
+## [v0.1.12] - 2025-06-26
+
+- Added `allow_undefined_variables`: undefined variables initialize to 0.0
+  with a warning instead of erroring (#17)
+- Dependency updates
+
+## [v0.1.11] - 2025-06-25
+
+- Added arithmetic functions and `REPEAT ... UNTIL` (#15)
+- Added `axis_index_map` to map axis identifiers to array indices (e.g.
+  `FL[E]=10`)
+- Improved error messages and grammar edge cases (comments in `IF`
+  statements, relational-operator ordering)
+
+## [v0.1.10] - 2025-02-21
+
+- Updated supported Python versions and release versioning; no interpreter
+  changes
+
+## [v0.1.9] - 2024-10-25
+
+- Added `dataframe_to_nc`: write a polars DataFrame back out as NC G-code
+  (round-trip), with the `sanitize_dataframe` helper exposed (#13)
+
+## [v0.1.8] - 2024-10-22
+
+- Exposed G-code groups (ggroups) in the API (#12); added type hints (#11)
+
+## [v0.1.7] - 2024-10-17
+
+- Git-tag-based versioning; CI cleanup (minimum Python 3.11)
+
+## [v0.1.6] - 2024-10-16
+
+- Implemented tool selection (`T="..."`/`T5`); M and T matching is
+  case-insensitive; quoted strings are unquoted in output (#8)
+
+## [v0.1.5] - 2024-10-09
+
+- Reordered G-group parsing, roughly doubling parse performance (#7)
+
+## [v0.1.1] – [v0.1.4] - 2024-10-03
+
+- Packaging and CI: PyPI publishing via Trusted Publisher, contributing
+  guidelines, macOS builds, WASM and binary bindings disabled to fix the
+  Python package (#1–#3)
+
+## [v0.1] - 2024-09-26
+
+- Initial release: Rust (pest) interpreter for Sinumerik-flavored NC
+  G-code with a CLI (MPF → CSV) and Python bindings (MPF → polars
+  DataFrame + final state)
+- G-code groups and modal commands, `TRANS`/`ATRANS`, `WHILE`/`FOR`/
+  `IF`/`ELSE`, local variables and arrays, arithmetic, incremental moves
+  (`IC()`), custom/extra axes, initial-state file, iteration limit,
+  forward-fill toggle