fiberpath 0.3.0__py3-none-any.whl

fiberpath/__init__.py

@@ -0,0 +1,10 @@
+"""Core FiberPath tooling package."""
+
+from importlib import metadata
+
+try:
+    __version__ = metadata.version("fiberpath")
+except metadata.PackageNotFoundError:  # pragma: no cover
+    __version__ = "0.0.0"
+
+__all__ = ["__version__"]

fiberpath/config/__init__.py

@@ -0,0 +1,22 @@
+"""Configuration schemas and validators for FiberPath."""
+
+from .schemas import (
+    HelicalLayer,
+    HoopLayer,
+    MandrelParameters,
+    SkipLayer,
+    TowParameters,
+    WindDefinition,
+)
+from .validator import WindFileError, load_wind_definition
+
+__all__ = [
+    "HelicalLayer",
+    "HoopLayer",
+    "MandrelParameters",
+    "SkipLayer",
+    "TowParameters",
+    "WindDefinition",
+    "WindFileError",
+    "load_wind_definition",
+]

fiberpath/config/schemas.py

@@ -0,0 +1,72 @@
+"""Typed configuration models shared across the FiberPath toolchain."""
+
+from __future__ import annotations
+
+import json
+from typing import Annotated, Literal
+
+from pydantic import BaseModel, ConfigDict, Field, PositiveFloat, PositiveInt
+
+
+class BaseFiberPathModel(BaseModel):
+    """Base class that applies shared Pydantic configuration."""
+
+    model_config = ConfigDict(populate_by_name=True, str_strip_whitespace=True)
+
+
+class MandrelParameters(BaseFiberPathModel):
+    diameter: PositiveFloat
+    wind_length: PositiveFloat = Field(alias="windLength")
+
+
+class TowParameters(BaseFiberPathModel):
+    width: PositiveFloat
+    thickness: PositiveFloat
+
+
+class HoopLayer(BaseFiberPathModel):
+    wind_type: Literal["hoop"] = Field(alias="windType", default="hoop")
+    terminal: bool = False
+
+
+class HelicalLayer(BaseFiberPathModel):
+    wind_type: Literal["helical"] = Field(alias="windType", default="helical")
+    wind_angle: PositiveFloat = Field(alias="windAngle")
+    pattern_number: PositiveInt = Field(alias="patternNumber")
+    skip_index: PositiveInt = Field(alias="skipIndex")
+    lock_degrees: PositiveFloat = Field(alias="lockDegrees")
+    lead_in_mm: PositiveFloat = Field(alias="leadInMM")
+    lead_out_degrees: PositiveFloat = Field(alias="leadOutDegrees")
+    skip_initial_near_lock: bool | None = Field(default=None, alias="skipInitialNearLock")
+
+
+class SkipLayer(BaseFiberPathModel):
+    wind_type: Literal["skip"] = Field(alias="windType", default="skip")
+    mandrel_rotation: float = Field(alias="mandrelRotation")
+
+
+LayerModel = Annotated[
+    HoopLayer | HelicalLayer | SkipLayer,
+    Field(discriminator="wind_type"),
+]
+
+
+class WindDefinition(BaseFiberPathModel):
+    layers: list[LayerModel]
+    mandrel_parameters: Annotated[MandrelParameters, Field(alias="mandrelParameters")]
+    tow_parameters: Annotated[TowParameters, Field(alias="towParameters")]
+    default_feed_rate: PositiveFloat = Field(alias="defaultFeedRate")
+
+    def dump_header(self) -> str:
+        def _normalize(value: object) -> object:
+            if isinstance(value, float) and value.is_integer():
+                return int(value)
+            if isinstance(value, dict):
+                return {k: _normalize(v) for k, v in value.items()}
+            return value
+
+        payload = {
+            "mandrel": _normalize(self.mandrel_parameters.model_dump(by_alias=True)),
+            "tow": _normalize(self.tow_parameters.model_dump(by_alias=True)),
+        }
+        return f"; Parameters {json.dumps(payload, separators=(',', ':'))}"

fiberpath/config/validator.py

@@ -0,0 +1,31 @@
+"""Helpers for loading and validating FiberPath input files."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from pydantic import ValidationError
+
+from .schemas import WindDefinition
+
+
+class WindFileError(RuntimeError):
+    """Raised when a wind definition file cannot be parsed."""
+
+
+def load_wind_definition(path: str | Path) -> WindDefinition:
+    """Load, parse, and validate a ``.wind`` definition file."""
+
+    location = Path(path)
+    if not location.exists():
+        raise WindFileError(f"No wind definition found at {location}")
+    try:
+        payload = json.loads(location.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:  # pragma: no cover - extremely rare
+        raise WindFileError(f"Invalid JSON in {location}: {exc}") from exc
+
+    try:
+        return WindDefinition.model_validate(payload)
+    except ValidationError as exc:
+        raise WindFileError(f"Wind definition at {location} failed validation: {exc}") from exc

fiberpath/execution/__init__.py

@@ -0,0 +1,7 @@
+"""Execution helpers for streaming G-code to Marlin-based controllers."""
+
+from __future__ import annotations
+
+from .marlin import MarlinStreamer, StreamError, StreamProgress
+
+__all__ = ["MarlinStreamer", "StreamError", "StreamProgress"]

fiberpath/execution/marlin.py

@@ -0,0 +1,311 @@
+"""Utilities for streaming G-code to Marlin-based controllers."""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Callable, Iterator, Sequence
+from dataclasses import dataclass
+from typing import Protocol, cast
+
+DEFAULT_BAUD_RATE = 250_000
+DEFAULT_RESPONSE_TIMEOUT = 10.0  # Allow time for slow moves (e.g., large rotations)
+
+
+class StreamError(RuntimeError):
+    """Raised when streaming cannot proceed."""
+
+
+class SerialTransport(Protocol):
+    """Minimal interface expected by :class:`MarlinStreamer`."""
+
+    def write_line(self, data: str) -> None:
+        """Write a G-code line to the transport."""
+
+    def readline(self, timeout: float | None = None) -> str | None:
+        """Return a single response line or ``None`` on timeout."""
+
+    def close(self) -> None:
+        """Close the transport."""
+
+
+class PySerialTransport:
+    """Serial transport backed by :mod:`pyserial`."""
+
+    def __init__(self, port: str, baud_rate: int, timeout: float) -> None:
+        try:
+            import serial  # type: ignore
+        except ImportError as exc:  # pragma: no cover - dependency error surfaced to caller
+            raise StreamError(
+                "pyserial is required for live streaming; install fiberpath with the CLI extras"
+            ) from exc
+
+        self._serial = serial.serial_for_url(
+            port,
+            baudrate=baud_rate,
+            timeout=timeout,
+            write_timeout=timeout,
+        )
+
+    def write_line(self, data: str) -> None:
+        payload = (data + "\n").encode("utf-8")
+        self._serial.write(payload)
+        self._serial.flush()
+
+    def readline(self, timeout: float | None = None) -> str | None:
+        previous_timeout: float | None = None
+        if timeout is not None:
+            previous_timeout = self._serial.timeout
+            self._serial.timeout = timeout
+        raw = cast(bytes, self._serial.readline())
+        if timeout is not None and previous_timeout is not None:
+            self._serial.timeout = previous_timeout
+        if not raw:
+            return None
+        return raw.decode("utf-8", errors="ignore").strip()
+
+    def close(self) -> None:
+        self._serial.close()
+
+
+@dataclass(frozen=True)
+class StreamProgress:
+    """Per-command streaming progress."""
+
+    commands_sent: int
+    commands_total: int
+    command: str
+    dry_run: bool
+
+
+class MarlinStreamer:
+    """Queue and stream G-code to a Marlin controller."""
+
+    def __init__(
+        self,
+        *,
+        port: str | None = None,
+        baud_rate: int = DEFAULT_BAUD_RATE,
+        response_timeout_s: float = DEFAULT_RESPONSE_TIMEOUT,
+        log: Callable[[str], None] | None = None,
+        transport: SerialTransport | None = None,
+    ) -> None:
+        self._port = port
+        self._baud_rate = baud_rate
+        self._response_timeout = response_timeout_s
+        self._log = log
+        self._transport = transport
+        self._connected = False
+        self._startup_handled = transport is not None  # Mock transports skip startup
+
+        self._program: list[str] = []
+        self._cursor = 0
+        self._commands_sent = 0
+        self._total_commands = 0
+        self._paused = False
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+    def load_program(self, commands: Sequence[str]) -> None:
+        """Load and sanitize a G-code program for streaming."""
+
+        sanitized: list[str] = []
+        total = 0
+        for raw in commands:
+            line = raw.strip()
+            if not line:
+                continue
+            sanitized.append(line)
+            if not line.startswith(";"):
+                total += 1
+        if not sanitized:
+            raise StreamError("G-code program contained no commands")
+        self._program = sanitized
+        self._cursor = 0
+        self._commands_sent = 0
+        self._total_commands = total
+
+    def iter_stream(self, *, dry_run: bool = False) -> Iterator[StreamProgress]:
+        """Yield progress as commands are streamed."""
+
+        if not self._program:
+            raise StreamError("No program loaded")
+
+        while self._cursor < len(self._program):
+            line = self._program[self._cursor]
+            self._cursor += 1
+
+            if not line:
+                continue
+            if line.startswith(";"):
+                if self._log is not None:
+                    self._log(line[1:].strip())
+                continue
+
+            if not dry_run:
+                self._ensure_connection()
+                self._send_command(line)
+
+            self._commands_sent += 1
+            yield StreamProgress(
+                commands_sent=self._commands_sent,
+                commands_total=self._total_commands,
+                command=line,
+                dry_run=dry_run,
+            )
+
+    def pause(self) -> None:
+        """Send ``M0`` to request a pause."""
+
+        if self._paused:
+            raise StreamError("Stream is already paused")
+        self._ensure_connection()
+        self._send_command("M0")
+        self._paused = True
+
+    def resume(self) -> None:
+        """Send ``M108`` to resume after :meth:`pause`."""
+
+        if not self._paused:
+            raise StreamError("Stream is not paused")
+        self._ensure_connection()
+        self._send_command("M108")
+        self._paused = False
+
+    def reset_progress(self) -> None:
+        """Restart streaming from the first command."""
+
+        self._cursor = 0
+        self._commands_sent = 0
+        self._paused = False
+
+    def close(self) -> None:
+        """Close the underlying transport."""
+
+        if self._transport is not None:
+            self._transport.close()
+        self._connected = False
+        self._startup_handled = False
+
+    def __enter__(self) -> MarlinStreamer:
+        return self
+
+    def __exit__(self, *_exc: object) -> None:  # pragma: no cover - trivial
+        self.close()
+
+    # ------------------------------------------------------------------
+    # Properties
+    # ------------------------------------------------------------------
+    @property
+    def commands_total(self) -> int:
+        return self._total_commands
+
+    @property
+    def commands_sent(self) -> int:
+        return self._commands_sent
+
+    @property
+    def commands_remaining(self) -> int:
+        return max(self._total_commands - self._commands_sent, 0)
+
+    @property
+    def paused(self) -> bool:
+        return self._paused
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+    def _ensure_connection(self) -> None:
+        if self._connected and self._startup_handled:
+            return
+
+        if self._transport is None:
+            if self._port is None:
+                raise StreamError("Serial port is required for live streaming")
+            self._transport = PySerialTransport(self._port, self._baud_rate, self._response_timeout)
+
+        if not self._startup_handled:
+            self._wait_for_marlin_ready()
+            self._startup_handled = True
+
+        self._connected = True
+
+    def _wait_for_marlin_ready(self) -> None:
+        """Wait for Marlin to complete its startup sequence and become ready."""
+        assert self._transport is not None
+
+        if self._log is not None:
+            self._log("Waiting for Marlin to initialize...")
+
+        # Marlin sends a startup banner on connection. Wait for it to finish.
+        # The startup typically ends with configuration dump (M206, M200, etc.)
+        # We'll wait up to 5 seconds for the startup to complete, consuming all lines.
+        start_time = time.monotonic()
+        startup_timeout = 5.0
+        last_line_time = start_time
+        quiet_period = 0.5  # Wait for 0.5s of silence to confirm startup is done
+
+        startup_lines: list[str] = []
+        seen_first_line = False
+
+        while time.monotonic() - start_time < startup_timeout:
+            remaining = startup_timeout - (time.monotonic() - start_time)
+            # Use a shorter timeout for responsive checking
+            line = self._transport.readline(min(remaining, 0.05))
+
+            if line is not None and line.strip():
+                startup_lines.append(line.strip())
+                last_line_time = time.monotonic()
+                seen_first_line = True
+                if self._log is not None:
+                    self._log(f"[marlin startup] {line.strip()}")
+
+            # Only check for quiet period after we've seen the first line
+            # and enough time has passed since the last line
+            if seen_first_line:
+                time_since_last_line = time.monotonic() - last_line_time
+                if time_since_last_line >= quiet_period:
+                    if self._log is not None:
+                        self._log(f"Marlin ready (received {len(startup_lines)} startup lines)")
+                    return
+
+        # If we got here, we either saw no startup or timed out
+        if not startup_lines:
+            # No startup lines seen - might be already initialized, wrong port, or wrong baud rate
+            if self._log is not None:
+                self._log("No Marlin startup detected. Controller may already be initialized.")
+        else:
+            # We timed out while receiving startup - this could be problematic
+            if self._log is not None:
+                self._log(
+                    f"Warning: Startup timeout after {len(startup_lines)} lines. "
+                    "Proceeding, but stream may fail if controller is not ready."
+                )
+
+    def _send_command(self, command: str) -> None:
+        assert self._transport is not None  # for type checkers
+        self._transport.write_line(command)
+        self._await_ok()
+
+    def _await_ok(self) -> None:
+        assert self._transport is not None
+        deadline = time.monotonic() + self._response_timeout
+        while True:
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                raise StreamError("Timed out waiting for Marlin response")
+            line = self._transport.readline(remaining)
+            if line is None:
+                continue
+            line = line.strip()
+            if not line:
+                continue
+            if line == "ok":
+                return
+            if line.startswith("echo:busy"):
+                deadline = time.monotonic() + self._response_timeout
+                continue
+            if line.startswith("Error"):
+                raise StreamError(f"Marlin reported: {line}")
+            if self._log is not None:
+                self._log(f"[marlin] {line}")

fiberpath/gcode/__init__.py

@@ -0,0 +1,6 @@
+"""G-code utilities."""
+
+from .dialects import MarlinDialect
+from .generator import GCodeProgram, sanitize_program, write_gcode
+
+__all__ = ["GCodeProgram", "sanitize_program", "write_gcode", "MarlinDialect"]

fiberpath/gcode/dialects.py

@@ -0,0 +1,47 @@
+"""Dialects encapsulate controller-specific behavior."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(slots=True)
+class AxisMapping:
+    """Maps logical axes to G-code axis letters."""
+
+    carriage: str = "X"  # Linear motion along mandrel
+    mandrel: str = "Y"  # Mandrel rotation
+    delivery_head: str = "Z"  # Delivery head rotation
+
+    @property
+    def is_rotational_mandrel(self) -> bool:
+        """True if mandrel uses a rotational axis (A/B/C)."""
+        return self.mandrel in {"A", "B", "C"}
+
+    @property
+    def is_rotational_delivery(self) -> bool:
+        """True if delivery head uses a rotational axis (A/B/C)."""
+        return self.delivery_head in {"A", "B", "C"}
+
+
+@dataclass(slots=True)
+class MarlinDialect:
+    """G-code dialect configuration for Marlin controllers."""
+
+    units: str = "mm"
+    feed_mode: str = "G94"  # Units per minute
+    axis_mapping: AxisMapping = field(default_factory=AxisMapping)
+
+    def prologue(self) -> list[str]:
+        """Return G-code commands for controller initialization."""
+        return ["G21" if self.units == "mm" else "G20", self.feed_mode]
+
+
+# Predefined dialects
+MARLIN_XYZ_LEGACY = MarlinDialect(
+    axis_mapping=AxisMapping(carriage="X", mandrel="Y", delivery_head="Z"),
+)
+
+MARLIN_XAB_STANDARD = MarlinDialect(
+    axis_mapping=AxisMapping(carriage="X", mandrel="A", delivery_head="B"),
+)

fiberpath/gcode/generator.py

@@ -0,0 +1,31 @@
+"""Utilities for generating and persisting G-code programs."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(slots=True)
+class GCodeProgram:
+    commands: list[str]
+
+    def as_text(self) -> str:
+        return "\n".join(self.commands) + "\n"
+
+
+def sanitize_program(commands: Iterable[str]) -> list[str]:
+    sanitized: list[str] = []
+    for line in commands:
+        stripped = line.strip()
+        if stripped:
+            sanitized.append(stripped)
+    return sanitized
+
+
+def write_gcode(program: GCodeProgram | Sequence[str], destination: str | Path) -> Path:
+    target = Path(destination)
+    lines = program.commands if isinstance(program, GCodeProgram) else list(program)
+    target.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    return target

fiberpath/geometry/__init__.py

@@ -0,0 +1,13 @@
+"""Geometry helpers for FiberPath."""
+
+from .curves import CurveProfile, HelicalCurve
+from .intersections import IntersectionResult, intersect_curve_with_plane
+from .surfaces import CylindricalSurface
+
+__all__ = [
+    "CurveProfile",
+    "HelicalCurve",
+    "IntersectionResult",
+    "intersect_curve_with_plane",
+    "CylindricalSurface",
+]

fiberpath/geometry/curves.py

@@ -0,0 +1,16 @@
+"""Curve primitives for tow paths."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class CurveProfile:
+    axial_mm: float
+    mandrel_degrees: float
+
+
+@dataclass(slots=True)
+class HelicalCurve(CurveProfile):
+    delivery_head_angle: float

fiberpath/geometry/intersections.py

@@ -0,0 +1,23 @@
+"""Intersection helpers for slicing tow curves into machine segments."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(slots=True)
+class IntersectionResult:
+    axial_mm: float
+    mandrel_degrees: float
+
+
+def intersect_curve_with_plane(*args: Any, **kwargs: Any) -> IntersectionResult:
+    """Placeholder for the eventual intersection math.
+
+    Args:
+        *args: Positional arguments describing the curve and slicing plane.
+        **kwargs: Keyword arguments forwarded from callers (e.g., tolerances).
+    """
+
+    raise NotImplementedError("Intersection computation is not yet implemented")

fiberpath/geometry/surfaces.py

@@ -0,0 +1,17 @@
+"""Surface primitives used by the planner."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class CylindricalSurface:
+    """Represents a straight cylindrical mandrel."""
+
+    diameter_mm: float
+    length_mm: float
+
+    @property
+    def circumference_mm(self) -> float:
+        return self.diameter_mm * 3.141592653589793

fiberpath/math_utils.py

@@ -0,0 +1,20 @@
+"""Small math helpers shared across modules."""
+
+from __future__ import annotations
+
+import math
+
+
+def deg_to_rad(degrees: float) -> float:
+    return math.radians(degrees)
+
+
+def rad_to_deg(radians: float) -> float:
+    return math.degrees(radians)
+
+
+def strip_precision(value: float, digits: int = 6) -> str:
+    text = f"{value:.{digits}f}"
+    if "." in text:
+        text = text.rstrip("0").rstrip(".")
+    return text or "0"

fiberpath/planning/__init__.py

@@ -0,0 +1,13 @@
+"""Planning orchestration module."""
+
+from .exceptions import LayerValidationError, PlanningError
+from .planner import LayerMetrics, PlanOptions, PlanResult, plan_wind
+
+__all__ = [
+    "PlanOptions",
+    "PlanResult",
+    "LayerMetrics",
+    "plan_wind",
+    "PlanningError",
+    "LayerValidationError",
+]