gantrix 0.1.0__py3-none-any.whl

gantrix/__init__.py

@@ -0,0 +1,5 @@
+from gantrix.job import Job
+from gantrix.transport import GrblTransport
+
+__all__ = ["Job", "GrblTransport"]
+__version__ = "0.1.0"

gantrix/cli.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import argparse
+
+from gantrix.design.text import layout_text
+from gantrix.job import Job
+from gantrix.tools.laser import LaserTool
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="gantrix", description="Drive a GRBL gantry.")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    text_cmd = sub.add_parser("text", help="Engrave text using the built-in stroke font.")
+    text_cmd.add_argument("text")
+    text_cmd.add_argument("--port", required=True)
+    text_cmd.add_argument("--power", type=int, default=600)
+    text_cmd.add_argument("--speed", type=int, default=500)
+    text_cmd.add_argument("--line-gap", type=float, default=0.25)
+    text_cmd.add_argument("--height", type=float, default=20.0)
+
+    qr_cmd = sub.add_parser("qr", help="Engrave a QR code.")
+    qr_cmd.add_argument("data")
+    qr_cmd.add_argument("--port", required=True)
+    qr_cmd.add_argument("--power", type=int, default=600)
+    qr_cmd.add_argument("--speed", type=int, default=500)
+    qr_cmd.add_argument("--cell-size", type=float, default=1.5, help="mm per QR module")
+
+    image_cmd = sub.add_parser("image", help="Engrave a raster image (logo, silhouette, photo).")
+    image_cmd.add_argument("path")
+    image_cmd.add_argument("--port", required=True)
+    image_cmd.add_argument("--power", type=int, default=600)
+    image_cmd.add_argument("--speed", type=int, default=500)
+    image_cmd.add_argument("--height", type=float, default=40.0)
+    image_cmd.add_argument("--cell-size", type=float, default=0.3, help="mm per pixel (resolution)")
+    image_cmd.add_argument("--threshold", type=int, default=128)
+    image_cmd.add_argument("--invert", action="store_true")
+
+    args = parser.parse_args()
+
+    if args.command == "text":
+        placed, total_w = layout_text(args.text.upper())
+        print(f"{args.text!r} — {total_w:.0f}mm wide x {args.height:.0f}mm tall")
+        tool = LaserTool(power=args.power, speed=args.speed)
+        Job(args.port, tool, placed, height=args.height, line_gap=args.line_gap).run()
+
+    elif args.command == "qr":
+        from gantrix.design.qrcode import layout_qr
+
+        placed, w, h, line_gap = layout_qr(args.data, cell_size=args.cell_size)
+        print(f"QR {args.data!r} — {w:.0f}mm x {h:.0f}mm, {args.cell_size}mm/module")
+        tool = LaserTool(power=args.power, speed=args.speed)
+        Job(args.port, tool, placed, height=h, line_gap=line_gap).run()
+
+    elif args.command == "image":
+        from gantrix.design.image import layout_image
+
+        placed, w, h = layout_image(
+            args.path, args.height, cell_size=args.cell_size,
+            threshold=args.threshold, invert=args.invert,
+        )
+        print(f"{args.path} — {w:.0f}mm x {h:.0f}mm, {args.cell_size}mm/pixel")
+        tool = LaserTool(power=args.power, speed=args.speed)
+        Job(args.port, tool, placed, height=h, line_gap=args.cell_size).run()
+
+
+if __name__ == "__main__":
+    main()

gantrix/design/image.py

@@ -0,0 +1,51 @@
+"""Arbitrary raster images (logos, photos, silhouettes) as engravable designs.
+
+Downsamples to one pixel per `cell_size` mm, thresholds to black/white, and
+exposes the result as a RasterShape — same fill-planner path as text and QR.
+"""
+from __future__ import annotations
+
+from PIL import Image
+
+from gantrix.design.shapes import RasterShape
+from gantrix.planner.fill import Placed
+
+
+def image_shape(
+    path: str,
+    height_mm: float,
+    cell_size: float = 0.3,
+    threshold: int = 128,
+    invert: bool = False,
+) -> RasterShape:
+    """Load an image and reduce it to a boolean fill grid.
+
+    `height_mm` is the desired physical output height; `cell_size` (mm) sets
+    the resolution (pixels per engraved dot) — smaller means finer detail
+    and more scanlines. Width is derived from the image's aspect ratio.
+    Pixels darker than `threshold` (0-255) are treated as fill; pass
+    `invert=True` if your source has a light subject on a dark background.
+    """
+    rows = max(1, round(height_mm / cell_size))
+    img = Image.open(path).convert("L")
+    cols = max(1, round(rows * img.width / img.height))
+    img = img.resize((cols, rows), Image.LANCZOS)
+
+    pixels = img.load()
+    grid = [
+        [(pixels[c, r] < threshold) != invert for c in range(cols)]
+        for r in range(rows)
+    ]
+    return RasterShape(grid, cell_size)
+
+
+def layout_image(
+    path: str,
+    height_mm: float,
+    cell_size: float = 0.3,
+    threshold: int = 128,
+    invert: bool = False,
+) -> tuple[list[Placed], float, float]:
+    """Convenience wrapper: returns (placed, total_width, total_height)."""
+    shape = image_shape(path, height_mm, cell_size, threshold, invert)
+    return [Placed(shape, x=0.0)], shape.width, shape.height

gantrix/design/qrcode.py

@@ -0,0 +1,29 @@
+"""QR codes as an engravable design: encode data, render as a RasterShape."""
+from __future__ import annotations
+
+import qrcode as _qrcode
+
+from gantrix.design.shapes import RasterShape
+from gantrix.planner.fill import Placed
+
+
+def qr_shape(data: str, cell_size: float = 1.5, border: int = 4) -> tuple[RasterShape, float]:
+    """Build a QR code shape for `data`.
+
+    `cell_size` is the physical size (mm) of one QR module — this should
+    also be used as the fill planner's `line_gap` so each module row gets
+    exactly one scanline pass (returned as the second element).
+    `border` is the quiet-zone width in modules (4 is the QR spec minimum).
+    """
+    qr = _qrcode.QRCode(border=border, box_size=1)
+    qr.add_data(data)
+    qr.make(fit=True)
+    grid = qr.get_matrix()  # list[list[bool]], already includes the border
+    shape = RasterShape(grid, cell_size)
+    return shape, cell_size
+
+
+def layout_qr(data: str, cell_size: float = 1.5, border: int = 4) -> tuple[list[Placed], float, float, float]:
+    """Convenience wrapper: returns (placed, total_width, total_height, recommended_line_gap)."""
+    shape, line_gap = qr_shape(data, cell_size, border)
+    return [Placed(shape, x=0.0)], shape.width, shape.height, line_gap

gantrix/design/shapes.py

@@ -0,0 +1,39 @@
+"""Generic bitmap-grid Shape: a design as a grid of filled/empty cells.
+
+QR codes and thresholded raster images are both "a grid of dark cells at
+some physical cell size" — this one class backs both, each row of the
+grid becoming one scanline's worth of fill spans.
+"""
+from __future__ import annotations
+
+
+class RasterShape:
+    def __init__(self, grid: list[list[bool]], cell_size: float):
+        assert grid, "grid must have at least one row"
+        self.grid = grid
+        self.cell_size = cell_size
+        self.n_rows = len(grid)
+        self.n_cols = len(grid[0])
+        self.height = self.n_rows * cell_size
+        self.width = self.n_cols * cell_size
+
+    def spans_at_y(self, y: float) -> list[tuple[float, float]]:
+        if not (-0.001 <= y <= self.height + 0.001):
+            return []
+        # local y is bottom-up (0 = bottom, matches the fill planner's
+        # convention); grid row 0 is the top row, so flip.
+        row_idx = self.n_rows - 1 - int(min(y, self.height - 1e-9) // self.cell_size)
+        row_idx = max(0, min(self.n_rows - 1, row_idx))
+        row = self.grid[row_idx]
+
+        spans: list[tuple[float, float]] = []
+        start = None
+        for col, filled in enumerate(row):
+            if filled and start is None:
+                start = col
+            elif not filled and start is not None:
+                spans.append((start * self.cell_size, col * self.cell_size))
+                start = None
+        if start is not None:
+            spans.append((start * self.cell_size, self.n_cols * self.cell_size))
+        return spans

gantrix/design/text.py

@@ -0,0 +1,93 @@
+"""Simple stroke-font text as a fill design source.
+
+Each letter is defined as rectangles plus tapered diagonals; this is the
+same scanline math the original one-off engraving script used, now
+implementing the `Shape` protocol so it plugs into the generic fill planner.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from gantrix.planner.fill import Placed
+
+H = 20.0  # default letter height (mm)
+S = 3.0   # default stroke thickness (mm)
+W = 12.0  # default standard letter width (mm)
+
+
+@dataclass(frozen=True)
+class Letter:
+    width: float
+    rects: list[tuple[float, float, float, float]] = field(default_factory=list)
+    diags: list[dict] = field(default_factory=list)
+
+    def spans_at_y(self, y: float) -> list[tuple[float, float]]:
+        raw = []
+        for x1, y1, x2, y2 in self.rects:
+            if y1 - 0.001 <= y <= y2 + 0.001:
+                raw.append((min(x1, x2), max(x1, x2)))
+        for d in self.diags:
+            yt, yb = d.get("yt", H), d.get("yb", 0)
+            if not (yb - 0.001 <= y <= yt + 0.001):
+                continue
+            span = yt - yb
+            t = (y - yb) / span if span > 0 else 1.0
+            xc = d["xb"] + (d["xt"] - d["xb"]) * t
+            raw.append((max(0, xc - d["hw"]), min(self.width, xc + d["hw"])))
+        if not raw:
+            return []
+        raw.sort()
+        merged = [list(raw[0])]
+        for x1, x2 in raw[1:]:
+            if x1 <= merged[-1][1] + 0.001:
+                merged[-1][1] = max(merged[-1][1], x2)
+            else:
+                merged.append([x1, x2])
+        return [(a, b) for a, b in merged]
+
+
+FONT: dict[str, Letter] = {
+    "M": Letter(15.0, rects=[(0, 0, S, H), (15 - S, 0, 15, H)], diags=[
+        {"xt": S / 2, "xb": 7.5, "hw": S / 2, "yt": H, "yb": H / 2},
+        {"xt": 15 - S / 2, "xb": 7.5, "hw": S / 2, "yt": H, "yb": H / 2},
+    ]),
+    "A": Letter(W, rects=[(0, H * 0.32 - S / 2, W, H * 0.32 + S / 2)], diags=[
+        {"xt": W / 2, "xb": 0, "hw": S / 2, "yt": H, "yb": 0},
+        {"xt": W / 2, "xb": W, "hw": S / 2, "yt": H, "yb": 0},
+    ]),
+    "D": Letter(W, rects=[
+        (0, 0, S, H), (0, H - S, 11, H), (0, 0, 11, S), (11 - S, S, 11, H - S),
+    ]),
+    "H": Letter(W, rects=[
+        (0, 0, S, H), (W - S, 0, W, H), (0, H / 2 - S / 2, W, H / 2 + S / 2),
+    ]),
+    "V": Letter(W, diags=[
+        {"xt": S / 2, "xb": W / 2, "hw": S / 2, "yt": H, "yb": 0},
+        {"xt": W - S / 2, "xb": W / 2, "hw": S / 2, "yt": H, "yb": 0},
+    ]),
+    "F": Letter(W, rects=[
+        (0, 0, S, H), (0, H - S, W, H), (0, H / 2 - S / 2, W * 0.75, H / 2 + S / 2),
+    ]),
+    "U": Letter(W, rects=[(0, S, S, H), (W - S, S, W, H), (0, 0, W, S)]),
+    "S": Letter(W, rects=[
+        (0, H - S, W, H), (0, H / 2 + S / 2, S, H - S),
+        (0, H / 2 - S / 2, W, H / 2 + S / 2),
+        (W - S, S, W, H / 2 - S / 2), (0, 0, W, S),
+    ]),
+    "I": Letter(8.0, rects=[(0, H - S, 8, H), (4 - S / 2, 0, 4 + S / 2, H), (0, 0, 8, S)]),
+    "O": Letter(W, rects=[(0, 0, S, H), (W - S, 0, W, H), (0, H - S, W, H), (0, 0, W, S)]),
+    "N": Letter(W, rects=[(0, 0, S, H), (W - S, 0, W, H)], diags=[
+        {"xt": S / 2, "xb": W - S / 2, "hw": S / 2, "yt": H, "yb": 0},
+    ]),
+}
+
+
+def layout_text(text: str, start_x: float = 0.0, gap: float = 3.0) -> tuple[list[Placed], float]:
+    """Lay out `text` left to right. Returns (placed shapes, total width)."""
+    placed = []
+    cx = start_x
+    for ch in text:
+        letter = FONT[ch]
+        placed.append(Placed(letter, cx))
+        cx += letter.width + gap
+    return placed, cx - gap - start_x

gantrix/gui/app.py

@@ -0,0 +1,332 @@
+"""Minimal toolpath preview + job-control server.
+
+Lets you preview a design as SVG, connect to a serial device, and run a
+job against it — all from the browser, no CLI needed. Preview never
+touches hardware; connect/run do, so those are explicit user actions.
+"""
+from __future__ import annotations
+
+import serial
+from fastapi import FastAPI, HTTPException, Query
+from fastapi.responses import HTMLResponse, JSONResponse, Response
+from pydantic import BaseModel
+
+from gantrix.design.text import layout_text
+from gantrix.gui import connection, job_runner
+from gantrix.job import Job
+from gantrix.planner.fill import FillSegment, plan_fill
+from gantrix.tools.laser import LaserTool
+from gantrix.transport import GrblError
+
+app = FastAPI(title="gantrix preview")
+
+
+class ConnectRequest(BaseModel):
+    port: str
+    baud: int = 115200
+
+
+class RunTextRequest(BaseModel):
+    text: str
+    line_gap: float = 0.25
+    height: float = 20.0
+    power: int = 600
+    speed: int = 500
+
+
+class RunQrRequest(BaseModel):
+    data: str
+    cell_size: float = 1.5
+    power: int = 600
+    speed: int = 500
+
+
+@app.get("/api/ports")
+def api_ports() -> list[dict]:
+    return connection.available_ports()
+
+
+@app.get("/api/status")
+def api_status() -> dict:
+    return connection.status()
+
+
+@app.post("/api/connect")
+def api_connect(req: ConnectRequest) -> JSONResponse:
+    try:
+        return JSONResponse(connection.connect(req.port, req.baud))
+    except serial.SerialException as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@app.post("/api/disconnect")
+def api_disconnect() -> dict:
+    return connection.disconnect()
+
+
+@app.post("/api/estop")
+def api_estop() -> dict:
+    """Immediate hardware halt — GRBL's real-time soft-reset, sent directly
+    regardless of whether a job is stuck waiting on a stalled command. Also
+    flags any running job to stop retrying once it does unblock."""
+    job_runner.cancel()
+    try:
+        return connection.emergency_stop()
+    except RuntimeError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@app.post("/api/home")
+def api_home() -> dict:
+    if job_runner.status()["running"]:
+        raise HTTPException(status_code=409, detail="a job is running — cancel it first")
+    transport = connection.get_transport()
+    if transport is None:
+        raise HTTPException(status_code=400, detail="not connected to a device")
+    try:
+        transport.home()
+    except GrblError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    return connection.status()
+
+
+@app.get("/api/job/status")
+def api_job_status() -> dict:
+    return job_runner.status()
+
+
+@app.post("/api/job/cancel")
+def api_job_cancel() -> dict:
+    job_runner.cancel()
+    return job_runner.status()
+
+
+@app.post("/api/run/text")
+def api_run_text(req: RunTextRequest) -> dict:
+    placed, _ = layout_text(req.text.upper())
+    tool = LaserTool(power=req.power, speed=req.speed)
+
+    def build_job(transport, on_progress, should_cancel):
+        return Job(
+            transport, tool, placed, height=req.height, line_gap=req.line_gap,
+            on_progress=on_progress, should_cancel=should_cancel,
+        )
+
+    try:
+        job_runner.start(f"text {req.text!r}", build_job)
+    except RuntimeError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    return job_runner.status()
+
+
+@app.post("/api/run/qr")
+def api_run_qr(req: RunQrRequest) -> dict:
+    from gantrix.design.qrcode import layout_qr  # optional dep: [design] extra
+
+    placed, _, h, line_gap = layout_qr(req.data, cell_size=req.cell_size)
+    tool = LaserTool(power=req.power, speed=req.speed)
+
+    def build_job(transport, on_progress, should_cancel):
+        return Job(
+            transport, tool, placed, height=h, line_gap=line_gap,
+            on_progress=on_progress, should_cancel=should_cancel,
+        )
+
+    try:
+        job_runner.start(f"qr {req.data!r}", build_job)
+    except RuntimeError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    return job_runner.status()
+
+
+def _segments_to_svg(segments: list[FillSegment], width: float, height: float) -> str:
+    lines = "".join(
+        f'<line x1="{s.x_start:.2f}" y1="{height - s.y:.2f}" '
+        f'x2="{s.x_end:.2f}" y2="{height - s.y:.2f}" stroke="red" stroke-width="0.15" />'
+        for s in segments
+    )
+    return (
+        f'<svg xmlns="http://www.w3.org/2000/svg" '
+        f'viewBox="-2 -2 {width + 4:.2f} {height + 4:.2f}" '
+        f'width="{(width + 4) * 8:.0f}" height="{(height + 4) * 8:.0f}">'
+        f'<rect x="-2" y="-2" width="{width + 4:.2f}" height="{height + 4:.2f}" fill="white" />'
+        f"{lines}</svg>"
+    )
+
+
+@app.get("/", response_class=HTMLResponse)
+def index() -> str:
+    return """
+    <html><body style="font-family: sans-serif; max-width: 700px; margin: 2rem auto;">
+      <h2>gantrix preview</h2>
+
+      <fieldset style="margin-bottom: 1.5rem;">
+        <legend>Serial connection</legend>
+        <select id="portSelect" style="min-width: 16rem;"></select>
+        <button type="button" onclick="refreshPorts()">Refresh</button>
+        <button type="button" onclick="doConnect()">Connect</button>
+        <button type="button" onclick="doDisconnect()">Disconnect</button>
+        <button type="button" onclick="doHome()">Home</button>
+        <button type="button" onclick="doEstop()"
+                style="background: #c00; color: white; font-weight: bold;">EMERGENCY STOP</button>
+        <div id="connStatus" style="margin-top: 0.5rem; font-family: monospace;">checking...</div>
+      </fieldset>
+
+      <fieldset style="margin-bottom: 1rem;">
+        <legend>Text</legend>
+        <input id="textInput" value="HAND" />
+        <input id="textLineGap" value="0.5" size="4" title="line gap (mm)" />
+        <input id="textPower" value="600" size="4" title="power 0-1000" />
+        <input id="textSpeed" value="500" size="4" title="speed mm/min" />
+        <button type="button" onclick="previewText()">Preview</button>
+        <button type="button" onclick="runText()">Print</button>
+      </fieldset>
+
+      <fieldset style="margin-bottom: 1.5rem;">
+        <legend>QR code</legend>
+        <input id="qrData" value="https://example.com" style="width: 16rem;" />
+        <input id="qrCellSize" value="1.5" size="4" title="mm per module" />
+        <input id="qrPower" value="600" size="4" title="power 0-1000" />
+        <input id="qrSpeed" value="500" size="4" title="speed mm/min" />
+        <button type="button" onclick="previewQr()">Preview</button>
+        <button type="button" onclick="runQr()">Print</button>
+      </fieldset>
+
+      <fieldset>
+        <legend>Job</legend>
+        <div id="jobStatus" style="font-family: monospace;">idle</div>
+        <button type="button" onclick="cancelJob()">Cancel</button>
+      </fieldset>
+
+      <script>
+        function previewText() {
+          const t = encodeURIComponent(document.getElementById('textInput').value);
+          const g = encodeURIComponent(document.getElementById('textLineGap').value);
+          window.open(`/preview?text=${t}&line_gap=${g}`, '_blank');
+        }
+        function previewQr() {
+          const d = encodeURIComponent(document.getElementById('qrData').value);
+          const c = encodeURIComponent(document.getElementById('qrCellSize').value);
+          window.open(`/preview/qr?data=${d}&cell_size=${c}`, '_blank');
+        }
+
+        async function refreshPorts() {
+          const ports = await (await fetch('/api/ports')).json();
+          const sel = document.getElementById('portSelect');
+          const prev = sel.value;
+          sel.innerHTML = '';
+          if (ports.length === 0) {
+            sel.innerHTML = '<option value="">(no ports found)</option>';
+          }
+          for (const p of ports) {
+            const opt = document.createElement('option');
+            opt.value = p.device;
+            opt.textContent = p.description ? `${p.device} — ${p.description}` : p.device;
+            sel.appendChild(opt);
+          }
+          if ([...sel.options].some(o => o.value === prev)) sel.value = prev;
+        }
+
+        async function refreshStatus() {
+          const s = await (await fetch('/api/status')).json();
+          const el = document.getElementById('connStatus');
+          el.textContent = s.connected ? `connected: ${s.port}` : 'disconnected';
+        }
+
+        async function doConnect() {
+          const port = document.getElementById('portSelect').value;
+          if (!port) { alert('No port selected'); return; }
+          const r = await fetch('/api/connect', {
+            method: 'POST',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({port}),
+          });
+          if (!r.ok) alert((await r.json()).detail || 'connect failed');
+          await refreshStatus();
+        }
+
+        async function doDisconnect() {
+          await fetch('/api/disconnect', {method: 'POST'});
+          await refreshStatus();
+        }
+
+        async function doHome() {
+          const r = await fetch('/api/home', {method: 'POST'});
+          if (!r.ok) alert((await r.json()).detail || 'home failed');
+          await refreshStatus();
+        }
+
+        async function doEstop() {
+          const r = await fetch('/api/estop', {method: 'POST'});
+          if (!r.ok) alert((await r.json()).detail || 'estop failed');
+          await refreshStatus();
+          await pollJob();
+        }
+
+        async function postJson(url, body) {
+          const r = await fetch(url, {
+            method: 'POST',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify(body),
+          });
+          if (!r.ok) alert((await r.json()).detail || 'request failed');
+          return r;
+        }
+
+        function runText() {
+          postJson('/api/run/text', {
+            text: document.getElementById('textInput').value,
+            line_gap: parseFloat(document.getElementById('textLineGap').value),
+            power: parseInt(document.getElementById('textPower').value),
+            speed: parseInt(document.getElementById('textSpeed').value),
+          });
+        }
+
+        function runQr() {
+          postJson('/api/run/qr', {
+            data: document.getElementById('qrData').value,
+            cell_size: parseFloat(document.getElementById('qrCellSize').value),
+            power: parseInt(document.getElementById('qrPower').value),
+            speed: parseInt(document.getElementById('qrSpeed').value),
+          });
+        }
+
+        function cancelJob() {
+          fetch('/api/job/cancel', {method: 'POST'});
+        }
+
+        async function pollJob() {
+          const s = await (await fetch('/api/job/status')).json();
+          const el = document.getElementById('jobStatus');
+          if (s.running) {
+            el.textContent = `running ${s.label}: ${s.done}/${s.total} segments`;
+          } else if (s.error) {
+            el.textContent = `error: ${s.error}`;
+          } else {
+            el.textContent = 'idle';
+          }
+        }
+
+        refreshPorts();
+        refreshStatus();
+        setInterval(refreshStatus, 3000);
+        setInterval(pollJob, 1000);
+      </script>
+    </body></html>
+    """
+
+
+@app.get("/preview")
+def preview(text: str = Query("HAND"), line_gap: float = Query(0.5), height: float = Query(20.0)) -> Response:
+    placed, total_w = layout_text(text.upper())
+    segments = plan_fill(placed, height, line_gap)
+    return Response(content=_segments_to_svg(segments, total_w, height), media_type="image/svg+xml")
+
+
+@app.get("/preview/qr")
+def preview_qr(data: str = Query("https://example.com"), cell_size: float = Query(1.5)) -> Response:
+    from gantrix.design.qrcode import layout_qr  # optional dep: [design] extra
+
+    placed, w, h, line_gap = layout_qr(data, cell_size=cell_size)
+    segments = plan_fill(placed, h, line_gap)
+    return Response(content=_segments_to_svg(segments, w, h), media_type="image/svg+xml")

gantrix/gui/connection.py

@@ -0,0 +1,73 @@
+"""Holds the single GRBL serial connection the GUI process manages.
+
+The preview server is otherwise stateless (each request just computes a
+toolpath). A serial connection is different — it has to persist across
+requests until the user disconnects, so it lives in one process-wide,
+lock-guarded slot rather than being opened per-request.
+"""
+from __future__ import annotations
+
+import threading
+
+from serial.tools import list_ports
+
+from gantrix.transport import GrblTransport
+
+_lock = threading.Lock()
+_transport: GrblTransport | None = None
+
+
+def available_ports() -> list[dict]:
+    return [{"device": p.device, "description": p.description} for p in list_ports.comports()]
+
+
+def _status_locked() -> dict:
+    """Compute status; caller must already hold `_lock`."""
+    connected = _transport is not None and _transport.is_connected
+    return {"connected": connected, "port": _transport.port if connected else None}
+
+
+def status() -> dict:
+    with _lock:
+        return _status_locked()
+
+
+def connect(port: str, baud: int = 115200) -> dict:
+    global _transport
+    with _lock:
+        if _transport is not None and _transport.is_connected:
+            if _transport.port == port:
+                return _status_locked()
+            _transport.disconnect()
+        _transport = GrblTransport(port, baud)
+        _transport.connect()  # raises serial.SerialException or GrblError on failure
+        return _status_locked()
+
+
+def disconnect() -> dict:
+    global _transport
+    with _lock:
+        if _transport is not None:
+            _transport.disconnect()
+        return _status_locked()
+
+
+def get_transport() -> GrblTransport | None:
+    """The live transport, if connected — for job-control endpoints."""
+    with _lock:
+        return _transport if (_transport is not None and _transport.is_connected) else None
+
+
+def emergency_stop() -> dict:
+    """Write GRBL's real-time soft-reset byte directly, bypassing the normal
+    command queue. Deliberately does NOT touch `_transport`'s open/closed
+    state here — a job thread may be mid-read on the same handle, and
+    closing it out from under that read is its own hazard. The connection
+    is left open in a post-reset (alarm-locked) state; reconnect to run the
+    unlock handshake again before sending further commands.
+    """
+    with _lock:
+        if _transport is None or not _transport.is_connected:
+            raise RuntimeError("not connected to a device")
+        _transport.emergency_stop()
+        return _status_locked()

gantrix/gui/job_runner.py

@@ -0,0 +1,60 @@
+"""Runs a Job in a background thread so an HTTP request doesn't block for
+the full engrave duration, and exposes progress for the page to poll.
+
+Only one job at a time — this is a single physical device, not a queue.
+"""
+from __future__ import annotations
+
+import threading
+from typing import Callable
+
+from gantrix.gui import connection
+from gantrix.job import Job
+from gantrix.transport import GrblTransport
+
+_lock = threading.Lock()
+_cancel_event = threading.Event()
+_thread: threading.Thread | None = None
+_state = {"running": False, "done": 0, "total": 0, "label": None, "error": None}
+
+
+def status() -> dict:
+    with _lock:
+        return dict(_state)
+
+
+def start(label: str, build_job: Callable[[GrblTransport, Callable, Callable], Job]) -> None:
+    """`build_job(transport, on_progress, should_cancel)` must return a Job
+    wired up to run on the given transport."""
+    global _thread
+    with _lock:
+        if _state["running"]:
+            raise RuntimeError("a job is already running")
+        transport = connection.get_transport()
+        if transport is None:
+            raise RuntimeError("not connected to a device")
+        _cancel_event.clear()
+        _state.update(running=True, done=0, total=0, label=label, error=None)
+
+    def on_progress(done: int, total: int) -> None:
+        with _lock:
+            _state["done"] = done
+            _state["total"] = total
+
+    def _run() -> None:
+        try:
+            job = build_job(transport, on_progress, _cancel_event.is_set)
+            job.run()
+        except Exception as e:
+            with _lock:
+                _state["error"] = str(e)
+        finally:
+            with _lock:
+                _state["running"] = False
+
+    _thread = threading.Thread(target=_run, daemon=True)
+    _thread.start()
+
+
+def cancel() -> None:
+    _cancel_event.set()

gantrix/job.py

@@ -0,0 +1,105 @@
+"""Orchestrates a design + tool + transport into a running gantry job."""
+from __future__ import annotations
+
+from typing import Callable
+
+from gantrix.planner.fill import Placed, plan_fill
+from gantrix.tools.base import Tool
+from gantrix.transport import GrblTransport
+
+
+class Job:
+    """A raster-fill job: sweep `placed` shapes and trace each fill segment
+    with `tool` engaged. Works for any tool implementing engage/disengage —
+    area-filling (laser) or drag-style (a held-down scoring pin). A future
+    tool that only acts at discrete points (e.g. a stamp) would need a
+    different job type driving the tool directly, since this one assumes
+    continuous engagement across each segment.
+
+    `port_or_transport` is either a serial port string — the Job opens and
+    closes its own connection, homing at the start (the CLI's usage) — or
+    an already-connected `GrblTransport` that the caller owns and keeps
+    open across jobs (the GUI's usage, once a device is connected).
+    """
+
+    def __init__(
+        self,
+        port_or_transport: str | GrblTransport,
+        tool: Tool,
+        placed: list[Placed],
+        height: float,
+        line_gap: float = 0.25,
+        start_x: float = 5.0,
+        start_y: float = 5.0,
+        baud: int = 115200,
+        on_progress: Callable[[int, int], None] | None = None,
+        should_cancel: Callable[[], bool] | None = None,
+    ):
+        if isinstance(port_or_transport, str):
+            self.transport = GrblTransport(port_or_transport, baud)
+            self._owns_transport = True
+        else:
+            # Anything non-string is assumed to be an already-connected
+            # transport (duck-typed, not an isinstance check, so fakes in
+            # tests work the same as a real GrblTransport).
+            self.transport = port_or_transport
+            self._owns_transport = False
+        self.tool = tool
+        self.placed = placed
+        self.height = height
+        self.line_gap = line_gap
+        self.start_x = start_x
+        self.start_y = start_y
+        self.on_progress = on_progress
+        self.should_cancel = should_cancel
+
+    def run(self) -> None:
+        segments = plan_fill(self.placed, self.height, self.line_gap)
+        if not segments:
+            print("Nothing to engrave — design produced no fill segments.")
+            return
+
+        if self._owns_transport:
+            self.transport.connect()
+        try:
+            self._run_on(self.transport, segments)
+        finally:
+            if self._owns_transport:
+                self.transport.disconnect()
+
+    def _run_on(self, t: GrblTransport, segments) -> None:
+        print("Homing...")
+        t.home()
+        t.send("G90")
+        t.send("G21")
+        t.send(f"G0 X{self.start_x:.3f} Y{self.start_y:.3f} F{self.tool.travel_feed()}")
+
+        tool_on = False
+        cancelled = False
+        for i, seg in enumerate(segments):
+            if self.should_cancel is not None and self.should_cancel():
+                cancelled = True
+                break
+
+            xa = self.start_x + seg.x_start
+            xb = self.start_x + seg.x_end
+            ya = self.start_y + seg.y
+
+            if tool_on:
+                self.tool.disengage(t)
+                tool_on = False
+            t.send(f"G0 X{xa:.3f} Y{ya:.3f} F{self.tool.travel_feed()}")
+            self.tool.engage(t)
+            tool_on = True
+            t.send(f"G1 X{xb:.3f} Y{ya:.3f} F{self.tool.work_feed()}")
+
+            if self.on_progress is not None:
+                self.on_progress(i + 1, len(segments))
+            if (i + 1) % 60 == 0:
+                print(f"  {i + 1}/{len(segments)} segments")
+
+        if tool_on:
+            self.tool.disengage(t)
+        if not cancelled:
+            t.send(f"G0 X0 Y0 F{self.tool.travel_feed()}")
+        print("Cancelled." if cancelled else "Done.")

gantrix/planner/fill.py

@@ -0,0 +1,86 @@
+"""Boustrophedon (zigzag raster) fill planning.
+
+Generalized from a font-fill scanner: given anything that can report which
+x-spans it occupies at a given y (a "Shape"), sweep scanlines across a
+design and emit merged, direction-alternating fill segments that minimize
+travel between them.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable, Protocol
+
+
+class Shape(Protocol):
+    """Anything that can report its horizontal extents at a given y."""
+
+    def spans_at_y(self, y: float) -> list[tuple[float, float]]:
+        """Return (x1, x2) fill spans at local y, x1 < x2, already merged."""
+        ...
+
+
+@dataclass(frozen=True)
+class Placed:
+    """A shape positioned at an (x, y) offset within a larger design."""
+
+    shape: Shape
+    x: float
+    y: float = 0.0
+
+
+def _merge(spans: list[tuple[float, float]], tol: float = 0.01) -> list[list[float]]:
+    if not spans:
+        return []
+    spans = sorted(spans)
+    merged = [list(spans[0])]
+    for x1, x2 in spans[1:]:
+        if x1 <= merged[-1][1] + tol:
+            merged[-1][1] = max(merged[-1][1], x2)
+        else:
+            merged.append([x1, x2])
+    return merged
+
+
+def scanline_ys(height: float, line_gap: float) -> list[float]:
+    ys, y = [], 0.0
+    while y <= height + 0.001:
+        ys.append(round(y, 4))
+        y += line_gap
+    return ys
+
+
+@dataclass(frozen=True)
+class FillSegment:
+    """One engrave pass: move from (x_start, y) to (x_end, y) with tool on."""
+
+    x_start: float
+    x_end: float
+    y: float
+
+
+def plan_fill(placed: Iterable[Placed], height: float, line_gap: float) -> list[FillSegment]:
+    """Sweep the design bottom-to-top, alternating direction each active line."""
+    placed = list(placed)
+    segments: list[FillSegment] = []
+    direction = 1
+
+    for yv in scanline_ys(height, line_gap):
+        raw = []
+        for p in placed:
+            local_y = yv - p.y
+            for x1, x2 in p.shape.spans_at_y(local_y):
+                raw.append((p.x + x1, p.x + x2))
+        if not raw:
+            continue
+
+        merged = _merge(raw)
+        if direction == -1:
+            merged.reverse()
+
+        for x1, x2 in merged:
+            xa, xb = (x1, x2) if direction == 1 else (x2, x1)
+            segments.append(FillSegment(xa, xb, yv))
+
+        direction *= -1
+
+    return segments

gantrix/tools/__init__.py

@@ -0,0 +1,4 @@
+from gantrix.tools.base import Tool
+from gantrix.tools.laser import LaserTool
+
+__all__ = ["Tool", "LaserTool"]

gantrix/tools/base.py

@@ -0,0 +1,32 @@
+"""Tool plugin interface: anything mounted on the gantry head."""
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from gantrix.transport import GrblTransport
+
+
+class Tool(ABC):
+    """A device mounted on the gantry that acts at points along a path.
+
+    `fills_area` tells the planner whether to raster-fill enclosed regions
+    (laser, spray head) or just trace outlines (solenoid stamp, pen, embosser).
+    """
+
+    fills_area: bool = True
+
+    @abstractmethod
+    def engage(self, transport: GrblTransport) -> None:
+        """Activate the tool (laser on, solenoid extend, pen down, ...)."""
+
+    @abstractmethod
+    def disengage(self, transport: GrblTransport) -> None:
+        """Deactivate the tool."""
+
+    def travel_feed(self) -> int:
+        """Feed rate (mm/min) for moves with the tool off."""
+        return 4000
+
+    def work_feed(self) -> int:
+        """Feed rate (mm/min) for moves with the tool engaged."""
+        return 500

gantrix/tools/laser.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from gantrix.transport import GrblTransport
+from gantrix.tools.base import Tool
+
+
+class LaserTool(Tool):
+    """Continuous-power laser (M3/M5), fills enclosed regions."""
+
+    fills_area = True
+
+    def __init__(self, power: int = 600, speed: int = 500, travel: int = 4000):
+        assert 0 <= power <= 1000, "power is 0-1000 per GRBL's $30 max spindle speed"
+        self.power = power
+        self.speed = speed
+        self.travel = travel
+
+    def engage(self, transport: GrblTransport) -> None:
+        transport.send(f"M3 S{self.power}")
+
+    def disengage(self, transport: GrblTransport) -> None:
+        transport.send("M5")
+
+    def travel_feed(self) -> int:
+        return self.travel
+
+    def work_feed(self) -> int:
+        return self.speed

gantrix/transport.py

@@ -0,0 +1,108 @@
+"""Serial transport to a GRBL-speaking controller."""
+from __future__ import annotations
+
+import time
+
+import serial
+
+
+class GrblError(RuntimeError):
+    pass
+
+
+class GrblTransport:
+    """Owns the serial connection and command/response handshake with GRBL."""
+
+    def __init__(self, port: str, baud: int = 115200, boot_delay: float = 4.0):
+        self.port = port
+        self.baud = baud
+        self.boot_delay = boot_delay
+        self._ser: serial.Serial | None = None
+
+    @property
+    def is_connected(self) -> bool:
+        return self._ser is not None and self._ser.is_open
+
+    def connect(self) -> None:
+        if self.is_connected:
+            return
+        self._ser = serial.Serial(self.port, self.baud, timeout=2)
+        try:
+            time.sleep(self.boot_delay)  # let the controller finish booting after DTR reset
+            self._ser.flushInput()
+            self._ser.write(b"\r\n\r\n")
+            time.sleep(0.5)
+            self._ser.flushInput()
+
+            # Safety: force the tool off before touching alarm state or homing.
+            # If a previous run crashed mid-job, GRBL holds whatever tool state
+            # it last had — the host process dying does NOT turn the tool off.
+            self.send("M5", timeout=5)
+
+            self.send("$X", timeout=5)  # clear alarm lock
+        except Exception:
+            # Don't leave a half-initialized handle open — a retry needs a
+            # clean slate, not a leaked fd that looks "connected" but isn't.
+            self._ser.close()
+            self._ser = None
+            raise
+
+    def disconnect(self) -> None:
+        if self._ser is not None:
+            try:
+                self.send("M5", timeout=5)  # tool off no matter how we're exiting
+            except GrblError:
+                pass  # the link may already be dead — still close it below
+            finally:
+                self._ser.close()
+                self._ser = None
+
+    def emergency_stop(self) -> None:
+        """Immediate, best-effort hardware halt: GRBL's real-time soft-reset
+        byte, sent directly — bypasses the normal line-by-line command queue
+        entirely, so it works even while another thread is blocked waiting
+        on a response to a stuck command. Turns the tool off as a side
+        effect of resetting GRBL's state, but leaves the connection open in
+        a post-reset (alarm-locked) state — reconnect to re-run the unlock
+        handshake before sending further commands.
+        """
+        assert self._ser is not None, "transport used outside a `with` block"
+        self._ser.write(b"\x18")  # Ctrl-X, GRBL real-time soft reset
+
+    def __enter__(self) -> "GrblTransport":
+        self.connect()
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        self.disconnect()
+
+    def home(self, timeout: float = 60.0) -> None:
+        self.send("$H", timeout=timeout)
+
+    def send(self, cmd: str, timeout: float = 30.0) -> bool:
+        assert self._ser is not None, "transport used outside a `with` block"
+        self._ser.write((cmd.strip() + "\n").encode())
+        ok, reason = self._wait_ok(timeout)
+        if not ok:
+            raise GrblError(f"no response to {cmd!r} ({reason})")
+        return True
+
+    def _wait_ok(self, timeout: float) -> tuple[bool, str]:
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            line = self._ser.readline().decode(errors="replace").strip()
+            if line == "ok":
+                return True, "ok"
+            if line.startswith("error"):
+                print(f"  GRBL error: {line}")
+                return False, line
+            if line.startswith("Grbl") or "['$' for help]" in line:
+                # controller rebooted (soft reset, brownout, ...) mid-command —
+                # no point waiting out the full timeout for a reply that will
+                # never come from the command we sent before the reboot
+                print(f"  GRBL: controller reset mid-command ({line})")
+                return False, "controller reset"
+            if line and not line.startswith("<"):
+                print(f"  GRBL: {line}")
+        print(f"  GRBL: timed out waiting for 'ok' after {timeout}s")
+        return False, f"timed out after {timeout}s"

gantrix-0.1.0.dist-info/METADATA

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: gantrix
+Version: 0.1.0
+Summary: A framework for controlling gantry-based (GRBL) devices with swappable tool heads — laser, solenoid, pen, and more.
+Author: devk-op
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyserial>=3.5
+Provides-Extra: gui
+Requires-Dist: fastapi>=0.110; extra == "gui"
+Requires-Dist: uvicorn>=0.29; extra == "gui"
+Provides-Extra: design
+Requires-Dist: Pillow>=10.0; extra == "design"
+Requires-Dist: qrcode>=7.4; extra == "design"
+Requires-Dist: svgpathtools>=1.6; extra == "design"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: httpx>=0.27; extra == "dev"
+Dynamic: license-file
+
+# gantrix
+
+A small framework for driving GRBL-based gantry devices with swappable tool
+heads — laser engraver today, whatever else you bolt to the carriage later
+(solenoid stamp, pen plotter, spray head, ...). Grew out of a one-off laser
+text-engraving script; generalized so the same motion/fill planning works
+for any tool, without being locked to the laser.
+
+## Layout
+
+- `gantrix.transport` — serial connection to GRBL, command/ack handshake,
+  homes with the tool forced off first (a previous crashed run can leave a
+  tool physically engaged even after the host process dies). A command
+  that gets no reply at all (dead link, controller reset) raises `GrblError`
+  rather than being silently swallowed; a mid-command controller reboot is
+  detected from its boot banner instead of waiting out the full timeout.
+  `emergency_stop()` sends GRBL's real-time soft-reset byte directly,
+  bypassing the normal command queue, so it works even while another
+  thread is blocked waiting on a stuck command.
+- `gantrix.tools` — the `Tool` plugin interface (`engage`/`disengage` +
+  feed rates). `LaserTool` (M3/M5 with power) is the only concrete
+  implementation shipped so far; new device types are added by subclassing
+  `Tool` (see `src/gantrix/tools/laser.py` as the reference).
+- `gantrix.design` — turns a design into `Shape`s the planner can sweep.
+  `design.text` is a small stroke font (rects + tapered diagonals).
+  `design.shapes.RasterShape` is a generic bitmap-grid `Shape`, backing both
+  `design.qrcode` (any QR-encodable data) and `design.image` (any image —
+  logo, silhouette, photo — thresholded to black/white at a configurable
+  resolution). True vector/SVG import (arbitrary curves, not just bitmaps)
+  is the natural next addition here.
+- `gantrix.planner.fill` — generic boustrophedon (zigzag raster) fill:
+  given anything exposing `spans_at_y(y)`, sweeps scanlines and emits
+  direction-alternating segments that minimize travel.
+- `gantrix.job` — wires a design + tool + transport into a runnable job.
+  Accepts either a port string (opens/closes its own connection — CLI
+  usage) or an already-connected transport (keeps it open — GUI usage).
+- `gantrix.gui.app` — preview a design as SVG, connect/disconnect a serial
+  port, and run a job — all from the browser. `gantrix.gui.connection`
+  holds the one live serial connection the process manages;
+  `gantrix.gui.job_runner` runs a `Job` in a background thread (so the
+  HTTP request returns immediately) and exposes progress + cancellation
+  for the page to poll. Only one job at a time — it's a single physical
+  device, not a queue. Two ways to stop: **Cancel** is cooperative (checked
+  between fill segments — fine for "I want a different design," not fast
+  enough to rely on if something's actually wrong); **EMERGENCY STOP** hits
+  the hardware directly via `emergency_stop()` and works regardless of
+  whether a command is stuck. **Home** manually re-homes ($H) when
+  connected and no job is running.
+
+## Quickstart
+
+```bash
+pip install -e ".[dev,gui,design]"
+pytest                                  # no hardware needed
+
+# preview a design in the browser (no hardware needed)
+uvicorn gantrix.gui.app:app --reload
+# open http://127.0.0.1:8000
+
+# run it for real
+gantrix text HAND --port /dev/cu.usbserial-XXXXXX
+gantrix qr "https://example.com" --port /dev/cu.usbserial-XXXXXX --cell-size 1.5
+gantrix image logo.png --port /dev/cu.usbserial-XXXXXX --height 40 --cell-size 0.3
+```
+
+## Adding a new device
+
+Swapping tools without touching the design or planner is the point of the
+`Tool` split. To support a new actuator, subclass `Tool` and implement
+`engage`/`disengage` (see `src/gantrix/tools/laser.py`):
+
+```python
+class MyTool(Tool):
+    def engage(self, transport):
+        transport.send("M62 P1")   # e.g. a GRBL digital output pin
+
+    def disengage(self, transport):
+        transport.send("M63 P1")
+```
+
+Then use it exactly like `LaserTool` — same `layout_text`/`layout_qr`
+output, same `Job`, just a different tool instance passed in.
+
+## Status
+
+Early scaffold. Laser path is validated against a working engrave script.
+QR fill segments have been round-trip verified (reconstructing the module
+grid from planned segments reproduces the source matrix exactly) and
+rendered to confirm the code is well-formed. Only one concrete `Tool`
+(laser) ships so far — the interface is there for more, none built yet.
+Vector/SVG import and shape-drawing in the GUI (not just text/QR forms) are
+not built yet either. The GUI can connect/disconnect, run a job (text or
+QR), Cancel, Home, and hardware-level EMERGENCY STOP. A real incident
+during testing (the controller stopped responding mid-job) surfaced that
+failures weren't being surfaced at all — `send()` used to return `False`
+on a dead link and nothing checked it, so the job just kept retrying into
+the void with no visible error. Fixed: failures now raise and show up in
+the job's `error` field instead of hanging silently.

gantrix-0.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+gantrix/__init__.py,sha256=Bjwv6Ju8fZCItIYflNAnLAZLUT4pBkt1GDA0JH_A7UY,130
+gantrix/cli.py,sha256=6_7ifkTiIyStt9Wn-Iu4ax5A1ac1dsnxRocUSZ9KWqQ,2972
+gantrix/job.py,sha256=GTtfz7b86SVLy9nEFza_GlT-itm41aC2tTI7s3406d0,3855
+gantrix/transport.py,sha256=xRAjLT3ffw_WF_QUyUj4i7C5qIAHTAhi5HDMXaC4UMk,4275
+gantrix/design/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gantrix/design/image.py,sha256=FnS10PgSwT_zMRgYT3kOF3_KWONKCXI9V3IVKwrr7x4,1735
+gantrix/design/qrcode.py,sha256=Sch_f_PhhZo6HYPOd4E7jvxFTyGKQS-ZMvV5uD6UibQ,1240
+gantrix/design/shapes.py,sha256=Tnrw6ZyIMBwgSs28qSEbgar5IeZT-10JZf70wEkZAf4,1582
+gantrix/design/text.py,sha256=AntqQhwGBNI2wV2TDplguDDuEzS_IVGVnhqktl408tY,3580
+gantrix/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gantrix/gui/app.py,sha256=Ekrq8svXSemNR1VFbJthu4d5w1l1VwRw9-0GifDyJzQ,11950
+gantrix/gui/connection.py,sha256=_-tDQXQbeBC_jqevyDygYCov8gpz1UP-UKjVLdE5jlE,2507
+gantrix/gui/job_runner.py,sha256=S7QOwwUcdeLR91KqoFCIiips34sgGqinePAn7zbWWvU,1831
+gantrix/planner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gantrix/planner/fill.py,sha256=nwtresA3rFuU-KLxcL7UPhXsqfEI0iC2b8QQAqPmBew,2344
+gantrix/tools/__init__.py,sha256=Y0PmMZ4mQV2cYwfyHmRVwjezrzATgt-58wxTrGDXWbg,111
+gantrix/tools/base.py,sha256=J5s9W_vrogxAhwaxlHheScjXd8yYyh3vLyY5s3C89_M,970
+gantrix/tools/laser.py,sha256=t6ohu7ll6EWq6lWT2czvhQtvrxSCdZH_ZtaDHAigUTM,791
+gantrix-0.1.0.dist-info/licenses/LICENSE,sha256=ggbjvAzg-9eXLZvwwupSZcbEWHvnHk0o_Qw-w0pphOc,1064
+gantrix-0.1.0.dist-info/METADATA,sha256=58QO_YC1ro1mAy6lW5L0VIpXEP47afPqrdmDus1PSLc,5732
+gantrix-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+gantrix-0.1.0.dist-info/entry_points.txt,sha256=2azwDnwE1rBvcNYfvYVDzZBuv38qlyUJTqDRKyXp-0I,45
+gantrix-0.1.0.dist-info/top_level.txt,sha256=VabMlu9x_W-tQ_VwWsEYthFDbvBgr3ANSNDtAcn9xxM,8
+gantrix-0.1.0.dist-info/RECORD,,

gantrix-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

gantrix-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gantrix = gantrix.cli:main

gantrix-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 devk-op
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gantrix-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+gantrix