nc-gcode-interpreter 0.2.9__tar.gz → 0.2.10__tar.gz

{nc_gcode_interpreter-0.2.9 → nc_gcode_interpreter-0.2.10}/.github/workflows/build-and-release.yml

@@ -80,7 +80,7 @@ jobs:
         uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.platform.target }}
-          args: --release --out dist --find-interpreter
+          args: --release --out dist -i python3.12 -i python3.13 -i python3.14 -i python3.14t -i python3.15 -i python3.15t
           sccache: 'true'
           manylinux: auto
       - name: Upload wheels
@@ -156,8 +156,8 @@ jobs:
         uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.platform.target }}
-          # Named interpreters: --find-interpreter also picks up the image's PyPy,
-          # which pyo3-ffi 0.29.0 fails to compile for.
+          # Every wheel job names its interpreters (the set 0.2.8 shipped per platform):
+          # --find-interpreter picks up whatever the image has, e.g. PyPy, which fails.
           args: --release --out dist -i python3.12 -i python3.13 -i python3.14 -i python3.14t
           sccache: 'true'
           manylinux: auto
@@ -216,7 +216,7 @@ jobs:
         uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.platform.target }}
-          args: --release --out dist --find-interpreter
+          args: --release --out dist -i python3.12 -i python3.13 -i python3.14
           sccache: 'true'
       - name: Upload wheels
         uses: actions/upload-artifact@v4
@@ -256,7 +256,7 @@ jobs:
         uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.platform.target }}
-          args: --release --out dist --find-interpreter
+          args: --release --out dist -i python3.12 -i python3.13 -i python3.14 -i python3.15
           sccache: 'true'
       - name: Upload wheels
         uses: actions/upload-artifact@v4
@@ -305,7 +305,7 @@ jobs:
       contents: write
       attestations: write
     steps:
-      # Do NOT use `merge-multiple: true`. With `--find-interpreter`, every
+      # Do NOT use `merge-multiple: true`. With a shared interpreter list, 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

{nc_gcode_interpreter-0.2.9 → nc_gcode_interpreter-0.2.10}/CHANGELOG.md

@@ -4,6 +4,41 @@ 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.10] - 2026-11-10
+
+### Changed
+
+- `nc_to_batches` and `nc_to_dataframe` do less work per output row. The
+  G-group columns are held as per-batch dictionary codes and written straight
+  to the Arrow string array, instead of one `String` per row per column that
+  the consumer thread then freed; the batch builder finds a cell's column
+  without hashing its name; the streaming driver reuses its decode buffers.
+  Python output is unchanged (same columns, `String` dtype, values and
+  `variable_events`). With `flatten_tolerance`, line numbers and variables on,
+  a 7.2M-row, 442 MiB linear program takes 3.3 s instead of 8.3 s and a
+  22M-row, 1.1 GB program 10.5 s instead of 24 s, at the same peak memory
+  (#89).
+
+- `flatten_tolerance` costs almost nothing on rows that are not curves: the
+  flattener tracked positions with an allocation and a lookup per configured
+  axis for every row, about 2 s on the 7.2M-row program above, now about
+  0.15 s. B-spline flattening reuses one working buffer per curve; a
+  5.4M-row, 380 MB spline program takes 8 s instead of 16 s (#89).
+
+- Rust API: `Column` has a new `Dict(DictColumn)` variant, used for the
+  G-group columns (`values` plus one `u32` code per row,
+  `DictColumn::NULL` for a null cell). Code that matches `Column`
+  exhaustively needs one more arm; `DictColumn::iter` yields the cells as
+  `Option<&str>` (#89).
+
+### Fixed
+
+- A numeric tool selection (`T2`, `T=3`, `T=R1`) now reaches the output table.
+  It is written to the same string `T` column as `T="name"`, as the number's
+  text (`"2"`), on the row of the block that programs it. Before, only named
+  tools appeared and a numeric one was dropped without a warning. The value is
+  still stored as the variable `T` in the final state, as before (#101).
+
 ## [v0.2.9] - 2026-11-01
 
 ### Changed

{nc_gcode_interpreter-0.2.9 → nc_gcode_interpreter-0.2.10}/Cargo.lock

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

{nc_gcode_interpreter-0.2.9 → nc_gcode_interpreter-0.2.10}/Cargo.toml

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

{nc_gcode_interpreter-0.2.9 → nc_gcode_interpreter-0.2.10}/PKG-INFO

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

{nc_gcode_interpreter-0.2.9 → nc_gcode_interpreter-0.2.10}/README.md

@@ -178,7 +178,7 @@ Measure a local program with
 --threads 4 --samples 1 --batch-size 4096 --allow-undefined --axis-index-e 4
 --axis-index-elx 5 --output tmp/memory.json`.
 
-**Cancellation.** Dropping the iterator is the supported way to cancel a `nc_to_rows`/`nc_to_batches` run — leaving a `for` loop early or `del`-ing it drops it immediately; relying on garbage collection works too but only whenever the runtime happens to collect it, so it is not prompt on all interpreters: the background interpreter thread's next attempt to send a row hits a closed channel and returns internally via `ParsingError::StreamClosed`, so the thread unwinds promptly instead of running the rest of the program to completion. No explicit `.close()`/`.cancel()` call is needed or provided — drop is the whole contract, and downstreams (e.g. ribweaver's `/sim` live-edit reinterpret) rely on it for latest-wins cancellation.
+**Cancellation.** Dropping the iterator is the supported way to cancel a `nc_to_rows`/`nc_to_batches` run — leaving a `for` loop early or `del`-ing it drops it immediately; relying on garbage collection works too but only whenever the runtime happens to collect it, so it is not prompt on all interpreters: the background interpreter thread's next attempt to send a row hits a closed channel and returns internally via `ParsingError::StreamClosed`, so the thread unwinds promptly instead of running the rest of the program to completion. No explicit `.close()`/`.cancel()` call is needed or provided — drop is the whole contract, and downstreams (for example a live-edit re-interpret in an editor) rely on it for latest-wins cancellation.
 
 Additionally, conversion from a Polars DataFrame back to an MPF (NC) program is also supported:
 

{nc_gcode_interpreter-0.2.9 → nc_gcode_interpreter-0.2.10}/docs/resumable-interpretation-design.md

@@ -15,7 +15,7 @@ Expose a resumable interpretation handle:
 - `resume(token, patched_text)` — restart interpretation from a checkpoint,
   against an edited program.
 
-Consumer: ribweaver `/sim` phase-E *incremental re-interpret* for multi-million-row
+Consumer: a live-edit *incremental re-interpret* in a G-code editor, for multi-million-row
 loop expansions. When the user edits source line *L*, it resumes from the last
 checkpoint whose block cursor precedes *L* instead of re-running the whole program.
 Downstream is evidence-gated: debounced-full re-interpret is fine below ~10⁵ rows,

{nc_gcode_interpreter-0.2.9 → nc_gcode_interpreter-0.2.10}/python/tests/test_batches.py

@@ -208,3 +208,20 @@ def test_include_line_numbers_survives_flattening():
     assert per_line.count(2) > 5
     stream_lines = [line for line, *_ in nc_to_rows(program, flatten_tolerance=0.1)]
     assert per_line == stream_lines
+
+
+def test_g_group_columns_stay_plain_strings():
+    # The interpreter holds G-group columns as dictionary codes internally;
+    # Python must keep seeing String columns with the same values.
+    program = "G1 G64 X1\nX2\nG4 F0.5\nG0 X3\nG17 X4\nM30\n"
+    frames = list(nc_to_batches(program, batch_size=2))
+    assert [f.height for f in frames] == [2, 2, 2]
+    for frame in frames:
+        for name in frame.columns:
+            if name.startswith("gg"):
+                assert frame[name].dtype == pl.String, name
+    df = pl.concat(frames, how="diagonal")
+    assert df["gg01_motion"].to_list() == ["G1", "G1", "G1", "G0", "G0", "G0"]
+    assert df["gg10_exact_stop_mode"].to_list() == ["G64"] * 6
+    assert df["gg02_wait"].to_list() == [None, None, "G4", None, None, None]
+    assert df["gg06_plane_select"].to_list() == [None, None, None, None, "G17", "G17"]

{nc_gcode_interpreter-0.2.9 → nc_gcode_interpreter-0.2.10}/python/tests/test_stage1.py

@@ -159,3 +159,20 @@ def test_fast_path_matches_on_real_corpus(mpf):
         extra_axes=["ELX"],
         allow_undefined_variables=True,
     )
+
+
+@pytest.mark.parametrize(
+    "program, expected",
+    [
+        ("G1 X0\nT2\nX1", [None, "2", None]),
+        ("G1 X0\nT=3\nX1", [None, "3", None]),
+        ("G1 X0\nt4\nX1", [None, "4", None]),
+        ("R1=7\nG1 X0\nT=R1\nX1", [None, "7", None]),
+        ('G1 X0\nT="NOZ_A"\nT5 X1', [None, "NOZ_A", "5"]),
+    ],
+    ids=["T2", "T=3", "lowercase", "expression", "mixed with a named tool"],
+)
+def test_numeric_tool_selection_reaches_the_t_column(program, expected):
+    """A numeric tool selection lands in the same string T column as a named one (#101)."""
+    df = run_both(program)
+    assert df["T"].to_list() == expected

{nc_gcode_interpreter-0.2.9 → nc_gcode_interpreter-0.2.10}/src/flatten.rs

@@ -67,9 +67,8 @@
 //!   than being misread).
 
 use crate::errors::ParsingError;
-use crate::output::{intern_column, CellMap, Row, FLATTENED_COLUMN};
+use crate::output::{intern_column, key_eq, CellMap, Row, FLATTENED_COLUMN};
 use crate::state::emit_warning;
-use crate::state::FxMap;
 use crate::types::Value;
 use std::collections::HashMap;
 
@@ -136,8 +135,9 @@ pub struct Flattener {
     /// Geometric axis columns (configured axis identifiers minus the
     /// non-geometric value columns), interned.
     geometric_axes: Vec<&'static str>,
-    /// Last known machine coordinate per geometric axis column.
-    positions: FxMap<&'static str, f64>,
+    /// Last known machine coordinate per geometric axis, indexed like
+    /// `geometric_axes` (a row updates a few slots, with no hashing).
+    positions: Vec<Option<f64>>,
     motion: Motion,
     plane: Plane,
     /// Buffered blocks of the active spline, in program order. Non-empty
@@ -145,7 +145,7 @@ pub struct Flattener {
     spline_buffer: Vec<SplineItem>,
     /// Snapshot of `positions` taken when the spline was selected: the
     /// spline's start point.
-    spline_start: FxMap<&'static str, f64>,
+    spline_start: Vec<Option<f64>>,
     /// Current B-spline degree (`SD=`, modal within the spline).
     spline_degree: usize,
     /// Curve motion words already warned about (CIP, CT, POLY, ...): one
@@ -160,8 +160,8 @@ impl Flattener {
     /// point even though the interpreter does.
     pub fn seed_position(&mut self, axis: &str, machine_value: f64) {
         let key = intern_column(&axis.to_uppercase());
-        if self.geometric_axes.contains(&key) {
-            self.positions.insert(key, machine_value);
+        if let Some(slot) = self.axis_slot(key) {
+            self.positions[slot] = Some(machine_value);
         }
     }
 
@@ -171,7 +171,7 @@ impl Flattener {
                 message: format!("flatten tolerance must be a positive number, got {}", tolerance),
             });
         }
-        let geometric_axes = axis_identifiers
+        let geometric_axes: Vec<&'static str> = axis_identifiers
             .iter()
             .map(|a| a.to_uppercase())
             .filter(|a| !NON_GEOMETRIC_AXES.contains(&a.as_str()))
@@ -179,12 +179,12 @@ impl Flattener {
             .collect();
         Ok(Flattener {
             tolerance,
+            positions: vec![None; geometric_axes.len()],
             geometric_axes,
-            positions: FxMap::default(),
             motion: Motion::Linear,
             plane: G17,
             spline_buffer: Vec::new(),
-            spline_start: FxMap::default(),
+            spline_start: Vec::new(),
             spline_degree: 3,
             warned_motions: Vec::new(),
         })
@@ -267,10 +267,23 @@ impl Flattener {
         !self.spline_buffer.is_empty()
     }
 
+    /// Index of `name` in `geometric_axes`.
+    fn axis_slot(&self, name: &str) -> Option<usize> {
+        self.geometric_axes.iter().position(|&axis| key_eq(axis, name))
+    }
+
+    /// Last known machine coordinate of a geometric axis.
+    fn position(&self, axis: &str) -> Option<f64> {
+        self.axis_slot(axis).and_then(|slot| self.positions[slot])
+    }
+
     fn track_positions(&mut self, row: &Row) {
-        for &axis in &self.geometric_axes {
-            if let Some(Value::Float(v)) = row.cells.get(axis) {
-                self.positions.insert(axis, *v);
+        // Walk the row's few cells, not every configured axis.
+        for (&key, value) in row.cells.iter() {
+            if let Value::Float(v) = value {
+                if let Some(slot) = self.axis_slot(key) {
+                    self.positions[slot] = Some(*v);
+                }
             }
         }
     }
@@ -310,7 +323,7 @@ impl Flattener {
             return;
         }
 
-        let (Some(su), Some(sv)) = (self.positions.get(u_axis).copied(), self.positions.get(v_axis).copied()) else {
+        let (Some(su), Some(sv)) = (self.position(u_axis), self.position(v_axis)) else {
             self.pass_through_with_warning(row, "arc start position is unknown", out);
             return;
         };
@@ -412,8 +425,8 @@ impl Flattener {
                 continue;
             }
             if let Some(end) = cell_float(&row, axis) {
-                let start = match self.positions.get(axis) {
-                    Some(&start) => start,
+                let start = match self.position(axis) {
+                    Some(start) => start,
                     None => {
                         // First-ever position of this axis: there is nothing
                         // to ramp from, so the channel holds its end value
@@ -502,17 +515,19 @@ impl Flattener {
         let mut current: Vec<f64> = channels
             .iter()
             .map(|&c| {
-                start.get(c).copied().unwrap_or_else(|| {
-                    // Channel never positioned before the spline: start it at
-                    // its first programmed value (a zero-length lead-in).
-                    items
-                        .iter()
-                        .find_map(|item| match item {
-                            SplineItem::Point(row) => cell_float(row, c),
-                            _ => None,
-                        })
-                        .unwrap_or(0.0)
-                })
+                self.axis_slot(c)
+                    .and_then(|slot| start.get(slot).copied().flatten())
+                    .unwrap_or_else(|| {
+                        // Channel never positioned before the spline: start it at
+                        // its first programmed value (a zero-length lead-in).
+                        items
+                            .iter()
+                            .find_map(|item| match item {
+                                SplineItem::Point(row) => cell_float(row, c),
+                                _ => None,
+                            })
+                            .unwrap_or(0.0)
+                    })
             })
             .collect();
         points.push(current.clone());
@@ -957,6 +972,9 @@ struct BSpline {
     knots: Vec<f64>,
     ctrl: Vec<Vec<f64>>,
     channels: usize,
+    /// de Boor working rows, `(p + 1) * (channels + 1)` values, reused by
+    /// every `eval` (the flattener evaluates several times per control point).
+    scratch: std::cell::RefCell<Vec<f64>>,
 }
 
 impl BSpline {
@@ -985,6 +1003,7 @@ impl BSpline {
             knots,
             ctrl,
             channels: points[0].len(),
+            scratch: std::cell::RefCell::new(Vec::new()),
         }
     }
 
@@ -999,7 +1018,13 @@ impl BSpline {
         } else {
             p + t as usize
         };
-        let mut d: Vec<Vec<f64>> = (0..=p).map(|j| self.ctrl[j + k - p].clone()).collect();
+        // Row j of `d` is control point j + k - p.
+        let width = channels + 1;
+        let mut d = self.scratch.borrow_mut();
+        d.clear();
+        for j in 0..=p {
+            d.extend_from_slice(&self.ctrl[j + k - p]);
+        }
         for r in 1..=p {
             for j in (r..=p).rev() {
                 let i = j + k - p;
@@ -1009,17 +1034,14 @@ impl BSpline {
                 } else {
                     (t - knots[i]) / denom
                 };
-                // Indexing two rows of `d` at once: a plain indexed loop is
-                // clearer than a split_at_mut dance.
-                #[allow(clippy::needless_range_loop)]
                 for c in 0..=channels {
-                    let previous = d[j - 1][c];
-                    d[j][c] = (1.0 - alpha) * previous + alpha * d[j][c];
+                    let previous = d[(j - 1) * width + c];
+                    d[j * width + c] = (1.0 - alpha) * previous + alpha * d[j * width + c];
                 }
             }
         }
-        let w = d[p][channels];
-        d[p][..channels].iter().map(|v| v / w).collect()
+        let w = d[p * width + channels];
+        d[p * width..p * width + channels].iter().map(|v| v / w).collect()
     }
 
     /// Greville abscissa of control point `i`, the mean of the `p` knots

{nc_gcode_interpreter-0.2.9 → nc_gcode_interpreter-0.2.10}/src/interpret_rules.rs

@@ -2514,6 +2514,9 @@ fn interpret_statement(element: Pair<Rule>, output: &mut Output, state: &mut Sta
                     }
                     None => {
                         state.warn_unsupported_address(&key, line_no);
+                        if key.eq_ignore_ascii_case("T") {
+                            last.insert("T", Value::Str(crate::output::tool_number_text(local_value)));
+                        }
                         output.record_variable_change(&key, local_value);
                     }
                 }

{nc_gcode_interpreter-0.2.9 → nc_gcode_interpreter-0.2.10}/src/interpreter.rs

@@ -1478,6 +1478,7 @@ mod tests {
         let strs = |name: &str| -> Vec<Option<String>> {
             match &table.columns.iter().find(|(n, _)| n == name).unwrap().1 {
                 Column::Str(v) => v.clone(),
+                Column::Dict(v) => v.iter().map(|cell| cell.map(str::to_string)).collect(),
                 other => panic!("column {name} is not a str column: {other:?}"),
             }
         };

{nc_gcode_interpreter-0.2.9 → nc_gcode_interpreter-0.2.10}/src/lib.rs

@@ -162,6 +162,19 @@ mod python_bindings {
                     // build of the offset + value buffers.
                     Arc::new(v.into_iter().collect::<StringArray>()),
                 ),
+                Column::Dict(column) => {
+                    // Same Utf8 array as a `Column::Str`, written from the codes.
+                    let lengths: Vec<usize> = column.values.iter().map(String::len).collect();
+                    let bytes: usize = column.codes.iter().filter_map(|&code| lengths.get(code as usize)).sum();
+                    let mut builder = StringBuilder::with_capacity(column.codes.len(), bytes);
+                    for &code in &column.codes {
+                        match column.values.get(code as usize) {
+                            Some(value) => builder.append_value(value),
+                            None => builder.append_null(),
+                        }
+                    }
+                    (DataType::Utf8, Arc::new(builder.finish()))
+                }
                 Column::StrList(v) => {
                     let values_cap: usize = v.iter().filter_map(|c| c.as_ref()).map(|l| l.len()).sum();
                     let mut builder = ListBuilder::with_capacity(StringBuilder::new(), v.len())

{nc_gcode_interpreter-0.2.9 → nc_gcode_interpreter-0.2.10}/src/line_driver.rs

@@ -123,6 +123,14 @@ enum LineExec<'a, 'i> {
     Blank,
 }
 
+/// A numeric tool selection (`T2`, `T=3`) goes to the row's `T` column, like `T="name"`.
+fn record_tool_number(key: &str, value: f64, output: &mut Output) {
+    if key == "T" {
+        let last = output.last_mut().expect("row was just pushed");
+        last.insert("T", Value::Str(crate::output::tool_number_text(value)));
+    }
+}
+
 /// One type per name (mirrors `interpret_assignment`): assigning a number to
 /// an existing STRING variable is a hard error, also on the fast path.
 fn reject_string_variable(key: &str, state: &State, line_no: usize) -> Result<(), ParsingError> {
@@ -406,7 +414,10 @@ fn interpret_streaming(input: &str, output: &mut Output, state: &mut State) -> R
     // for the decode the indexed driver runs in parallel.
     std::thread::scope(|scope| {
         let (sender, receiver) = std::sync::mpsc::sync_channel::<DecodedChunk>(2);
-        scope.spawn(move || decode_chunks(input, sender));
+        // Executed chunks go back to the decode thread, which refills their
+        // buffers instead of allocating and freeing three per chunk.
+        let (spent_sender, spent) = std::sync::mpsc::channel::<DecodedChunk>();
+        scope.spawn(move || decode_chunks(input, sender, spent));
         // Returning early drops `receiver`, which stops the decode thread.
         for chunk in receiver {
             for (offset, (decoded, line)) in chunk.results.iter().zip(&chunk.lines).enumerate() {
@@ -415,6 +426,7 @@ fn interpret_streaming(input: &str, output: &mut Output, state: &mut State) -> R
                     return Ok(flow);
                 }
             }
+            let _ = spent_sender.send(chunk);
         }
         Ok(BlockFlow::Continue)
     })
@@ -432,16 +444,30 @@ struct DecodedChunk<'a> {
     arena: Vec<Word<'a>>,
 }
 
-fn decode_chunks<'a>(input: &'a str, sender: std::sync::mpsc::SyncSender<DecodedChunk<'a>>) {
+fn decode_chunks<'a>(
+    input: &'a str,
+    sender: std::sync::mpsc::SyncSender<DecodedChunk<'a>>,
+    spent: std::sync::mpsc::Receiver<DecodedChunk<'a>>,
+) {
     let mut lines = input.lines().peekable();
     let mut first_line = 0;
     while lines.peek().is_some() {
-        let mut chunk = DecodedChunk {
-            first_line,
-            lines: lines.by_ref().take(STREAM_CHUNK_LINES).collect(),
-            results: Vec::with_capacity(STREAM_CHUNK_LINES),
-            arena: Vec::with_capacity(STREAM_CHUNK_LINES * 4),
+        let mut chunk = match spent.try_recv() {
+            Ok(mut chunk) => {
+                chunk.lines.clear();
+                chunk.results.clear();
+                chunk.arena.clear();
+                chunk
+            }
+            Err(_) => DecodedChunk {
+                first_line: 0,
+                lines: Vec::with_capacity(STREAM_CHUNK_LINES),
+                results: Vec::with_capacity(STREAM_CHUNK_LINES),
+                arena: Vec::with_capacity(STREAM_CHUNK_LINES * 4),
+            },
         };
+        chunk.first_line = first_line;
+        chunk.lines.extend(lines.by_ref().take(STREAM_CHUNK_LINES));
         for (offset, line) in chunk.lines.iter().enumerate() {
             chunk
                 .results
@@ -614,6 +640,7 @@ fn execute_decoded(
                         let key = key.to_uppercase();
                         reject_string_variable(&key, state, line.line_no)?;
                         output.record_variable_change(&key, *value);
+                        record_tool_number(&key, *value, output);
                         state.symbol_table.insert(key, *value);
                     }
                 }
@@ -701,6 +728,7 @@ fn execute_decoded(
                         reject_string_variable(&key, state, line.line_no)?;
                         let local_value = increment_local(state, &key, value);
                         output.record_variable_change(&key, local_value);
+                        record_tool_number(&key, local_value, output);
                         state.symbol_table.insert(key, local_value);
                     }
                 }