Make G-code parser handle standard and valve-encoded formats

The tool-path parser previously required X and Y together on every move
and classified print vs travel solely by G1 vs G0, which only matched
this app's own output. It now:

- tracks X/Y/Z independently and accepts any G0/G1 move with at least
one coordinate, so standard single-axis and Z-only moves parse
- classifies print vs travel by valve state (WAGO_ValveCommands) whenever
valve commands are present, since the valve physically controls flow;
falls back to G1/G0 only when no valve commands exist

This fixes external G-code that emits one axis per line, that conveys
extrusion only through the valve (all moves G1), or that has G0/G1
labels inverted relative to the valve. The app's own files and standard
slicer output are unaffected.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

gcode_viewer.py

@@ -8,17 +8,31 @@ import numpy as np
 import plotly.graph_objects as go
 
 
-_MOVE_RE = re.compile(
-    r"^\s*(G0|G1)\s+X(-?\d+(?:\.\d+)?)\s+Y(-?\d+(?:\.\d+)?)"
-    r"(?:\s+Z(-?\d+(?:\.\d+)?))?",
-    re.IGNORECASE,
-)
+# A move is any G0/G1 (or G00/G01) line. Coordinates may list any subset of
+# X/Y/Z in any order, mixed with other tokens (F feed rate, E extrusion); only
+# the axes named on a line change. This matches standard slicer/firmware G-code
+# as well as this app's own always-paired "X Y" output.
+_CMD_RE = re.compile(r"^G0*([01])(?![0-9])", re.IGNORECASE)
+_AXIS_RE = re.compile(r"([XYZ])\s*([-+]?(?:\d*\.\d+|\d+\.?))", re.IGNORECASE)
+# Pneumatic valve toggle: WAGO_ValveCommands(<valve>, <0=close|1=open>). Some
+# generators emit every move as G1 and convey extrusion only through the valve.
+_VALVE_RE = re.compile(r"WAGO_ValveCommands\(\s*(\d+)\s*,\s*(\d+)\s*\)", re.IGNORECASE)
 
 
 def parse_gcode_path(gcode_text: str) -> dict:
     relative = True
     x = y = z = 0.0
 
+    # Decide how to tell print from travel. The valve physically controls
+    # material flow, so when valve commands are present they are the ground
+    # truth: valve open = printing, valve closed = travel. This is correct for
+    # the app's own output (where valve state and G1/G0 agree) and for external
+    # generators whose G0/G1 labels are unreliable — some omit G0 entirely
+    # (every move G1), others invert G0/G1 relative to the valve. Only fall back
+    # to the G1 = print / G0 = travel convention when there is no valve to read.
+    use_valve = bool(_VALVE_RE.search(gcode_text))
+    open_valves: set[str] = set()
+
     print_segments: list[list[tuple[float, float, float]]] = []
     travel_segments: list[list[tuple[float, float, float]]] = []
     moves: list[dict] = []
@@ -43,7 +57,9 @@ def parse_gcode_path(gcode_text: str) -> dict:
             flush_segment()
             continue
 
-        upper = line.upper()
+        # Drop inline comments so axis letters in comment text are never read.
+        code = line.split(";", 1)[0].strip()
+        upper = code.upper()
         if upper.startswith("G90"):
             relative = False
             continue
@@ -51,29 +67,44 @@ def parse_gcode_path(gcode_text: str) -> dict:
             relative = True
             continue
 
-        match = _MOVE_RE.match(line)
-        if not match:
+        cmd_match = _CMD_RE.match(code)
+        if not cmd_match:
+            # Track valve open/close so all-G1 files can be split into
+            # print (valve open) and travel (valve closed) runs.
+            valve_match = _VALVE_RE.search(code)
+            if valve_match:
+                valve, state = valve_match.group(1), valve_match.group(2)
+                if state == "0":
+                    open_valves.discard(valve)
+                else:
+                    open_valves.add(valve)
             flush_segment()
             continue
 
-        gcmd = match.group(1).upper()
-        dx = float(match.group(2))
-        dy = float(match.group(3))
-        dz_match = match.group(4)
-        dz = float(dz_match) if dz_match is not None else 0.0
+        axes = {a.upper(): float(v) for a, v in _AXIS_RE.findall(code)}
+        if not axes:
+            # A G0/G1 with no coordinates (e.g. "G1 F1800") is not a move.
+            flush_segment()
+            continue
 
         prev_pos = (x, y, z)
 
         if relative:
-            x += dx
-            y += dy
-            z += dz
+            x += axes.get("X", 0.0)
+            y += axes.get("Y", 0.0)
+            z += axes.get("Z", 0.0)
         else:
-            x, y = dx, dy
-            if dz_match is not None:
-                z = dz
-
-        kind = "print" if gcmd == "G1" else "travel"
+            if "X" in axes:
+                x = axes["X"]
+            if "Y" in axes:
+                y = axes["Y"]
+            if "Z" in axes:
+                z = axes["Z"]
+
+        if use_valve:
+            kind = "print" if open_valves else "travel"
+        else:
+            kind = "print" if cmd_match.group(1) == "1" else "travel"
         moves.append({"kind": kind, "start": prev_pos, "end": (x, y, z)})
 
         if kind != current_kind: