fiberpath 0.3.0__py3-none-any.whl

fiberpath_api/main.py

@@ -0,0 +1,19 @@
+"""Entry point for the FiberPath FastAPI service."""
+
+from __future__ import annotations
+
+from fastapi import FastAPI
+
+from .routes import plan, simulate, stream, validate
+
+
+def create_app() -> FastAPI:
+    application = FastAPI(title="FiberPath API", version="0.2.0")
+    application.include_router(plan.router, prefix="/plan", tags=["planning"])
+    application.include_router(simulate.router, prefix="/simulate", tags=["simulation"])
+    application.include_router(validate.router, prefix="/validate", tags=["validation"])
+    application.include_router(stream.router, prefix="/stream", tags=["stream"])
+    return application
+
+
+app = create_app()

fiberpath_api/routes/__init__.py

@@ -0,0 +1 @@
+"""Route modules for the FiberPath API."""

fiberpath_api/routes/plan.py

@@ -0,0 +1,41 @@
+"""Planning endpoints."""
+
+from __future__ import annotations
+
+from dataclasses import asdict
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+from fiberpath.config import WindFileError, load_wind_definition
+from fiberpath.gcode import write_gcode
+from fiberpath.gcode.dialects import MARLIN_XAB_STANDARD, MARLIN_XYZ_LEGACY
+from fiberpath.planning import PlanOptions, plan_wind
+
+from ..schemas import FilePathRequest, PlanLayer, PlanResponse
+
+router = APIRouter()
+
+
+@router.post("/from-file", response_model=PlanResponse)
+def plan_from_file(payload: FilePathRequest) -> PlanResponse:
+    file_path = Path(payload.path)
+    try:
+        definition = load_wind_definition(file_path)
+    except WindFileError as exc:  # pragma: no cover - HTTP glue
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    # Select dialect based on axis format
+    dialect = MARLIN_XAB_STANDARD if payload.axis_format == "xab" else MARLIN_XYZ_LEGACY
+    options = PlanOptions(verbose=payload.verbose, dialect=dialect)
+
+    result = plan_wind(definition, options)
+    temp_file = write_gcode(result.commands, file_path.with_suffix(".gcode"))
+    layers = [PlanLayer(**asdict(metric)) for metric in result.layers]
+    return PlanResponse(
+        commands=len(result.commands),
+        output=str(temp_file),
+        timeSeconds=result.total_time_s,
+        towMeters=result.total_tow_m,
+        axisFormat=payload.axis_format,
+        layers=layers,
+    )

fiberpath_api/routes/simulate.py

@@ -0,0 +1,29 @@
+"""Simulation endpoints."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+from fiberpath.simulation import simulate_program
+
+from ..schemas import FilePathRequest, SimulationResponse
+
+router = APIRouter()
+
+
+@router.post("/from-file", response_model=SimulationResponse)
+def simulate_from_file(payload: FilePathRequest) -> SimulationResponse:
+    target = Path(payload.path)
+    if not target.exists():
+        raise HTTPException(status_code=404, detail=f"No file found at {payload.path}")
+    commands = target.read_text(encoding="utf-8").splitlines()
+    result = simulate_program(commands)
+    return SimulationResponse(
+        commands=result.commands_executed,
+        moves=result.moves,
+        estimated_time_s=result.estimated_time_s,
+        total_distance_mm=result.total_distance_mm,
+        tow_length_mm=result.tow_length_mm,
+        average_feed_rate_mmpm=result.average_feed_rate_mmpm,
+    )

fiberpath_api/routes/stream.py

@@ -0,0 +1,49 @@
+"""Serial streaming endpoints."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException
+from fiberpath.execution import MarlinStreamer, StreamError
+from pydantic import BaseModel, Field
+
+router = APIRouter()
+
+
+class StreamRequest(BaseModel):
+    gcode: str = Field(..., description="Raw G-code to stream, newline separated.")
+    port: str | None = Field(
+        default=None,
+        description="Serial port or pyserial URL. Required when dry_run is false.",
+    )
+    baud_rate: int = Field(default=250_000, ge=1, description="Controller baud rate.")
+    dry_run: bool = Field(default=True, description="Skip serial I/O and only count commands.")
+
+
+class StreamResponse(BaseModel):
+    commands_streamed: int
+    total_commands: int
+    dry_run: bool
+
+
+@router.post("/", response_model=StreamResponse)
+def start_stream(payload: StreamRequest) -> StreamResponse:
+    if not payload.dry_run and payload.port is None:
+        raise HTTPException(status_code=400, detail="port is required when dry_run is false")
+
+    commands = payload.gcode.splitlines()
+    streamer = MarlinStreamer(port=payload.port, baud_rate=payload.baud_rate)
+    streamer.load_program(commands)
+
+    try:
+        for _update in streamer.iter_stream(dry_run=payload.dry_run):
+            pass
+    except StreamError as exc:  # pragma: no cover - exercised via API test
+        raise HTTPException(status_code=502, detail=f"Streaming failed: {exc}") from exc
+    finally:
+        streamer.close()
+
+    return StreamResponse(
+        commands_streamed=streamer.commands_sent,
+        total_commands=streamer.commands_total,
+        dry_run=payload.dry_run,
+    )

fiberpath_api/routes/validate.py

@@ -0,0 +1,21 @@
+"""Validation endpoints."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+from fiberpath.config import WindFileError, load_wind_definition
+
+from ..schemas import FilePathRequest, ValidateResponse
+
+router = APIRouter()
+
+
+@router.post("/from-file", response_model=ValidateResponse)
+def validate_from_file(payload: FilePathRequest) -> ValidateResponse:
+    try:
+        load_wind_definition(Path(payload.path))
+    except WindFileError as exc:  # pragma: no cover - HTTP glue
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    return ValidateResponse(status="ok", path=payload.path)

fiberpath_api/schemas.py

@@ -0,0 +1,50 @@
+"""Pydantic schemas shared by API routes."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+class FilePathRequest(BaseModel):
+    path: str = Field(..., description="Absolute or workspace path to an input file.")
+    axis_format: Literal["xyz", "xab"] = Field(
+        default="xab",
+        description="Axis coordinate format: xyz (legacy) or xab (standard rotational)",
+    )
+    verbose: bool = Field(default=False, description="Emit verbose planner output")
+
+
+class PlanLayer(BaseModel):
+    index: int
+    wind_type: str
+    commands: int
+    time_s: float
+    cumulative_time_s: float
+    tow_m: float
+    cumulative_tow_m: float
+    terminal: bool
+
+
+class PlanResponse(BaseModel):
+    commands: int
+    output: str
+    timeSeconds: float
+    towMeters: float
+    axisFormat: str
+    layers: list[PlanLayer]
+
+
+class SimulationResponse(BaseModel):
+    commands: int
+    moves: int
+    estimated_time_s: float
+    total_distance_mm: float
+    tow_length_mm: float
+    average_feed_rate_mmpm: float
+
+
+class ValidateResponse(BaseModel):
+    status: str
+    path: str

fiberpath_cli/__init__.py

@@ -0,0 +1,5 @@
+"""CLI entry-points built on Typer."""
+
+from .main import app
+
+__all__ = ["app"]

fiberpath_cli/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running fiberpath_cli as a module with `python -m fiberpath_cli`."""
+
+from .main import app
+
+if __name__ == "__main__":
+    app()

fiberpath_cli/main.py

@@ -0,0 +1,27 @@
+"""FiberPath command line interface."""
+
+from __future__ import annotations
+
+import typer
+
+from .plan import plan_command
+from .plot import plot_command
+from .simulate import simulate_command
+from .stream import stream_command
+from .validate import validate_command
+
+app = typer.Typer(
+    name="FiberPath",
+    help="FiberPath utilities for planning and executing filament winding jobs.",
+)
+
+
+app.command("plan")(plan_command)
+app.command("plot")(plot_command)
+app.command("simulate")(simulate_command)
+app.command("validate")(validate_command)
+app.command("stream")(stream_command)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    app()

fiberpath_cli/output.py

@@ -0,0 +1,14 @@
+"""Utilities for CLI output modes."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import typer
+
+
+def echo_json(payload: Any) -> None:
+    """Pretty-print payload as JSON."""
+
+    typer.echo(json.dumps(payload, indent=2))

fiberpath_cli/plan.py

@@ -0,0 +1,100 @@
+"""CLI plan command."""
+
+from __future__ import annotations
+
+from dataclasses import asdict
+from pathlib import Path
+
+import typer
+from fiberpath.config import WindFileError, load_wind_definition
+from fiberpath.gcode import write_gcode
+from fiberpath.gcode.dialects import MARLIN_XAB_STANDARD, MARLIN_XYZ_LEGACY
+from fiberpath.planning import PlanOptions, plan_wind
+from rich.console import Console
+from rich.table import Table
+
+from .output import echo_json
+
+console = Console()
+
+WIND_FILE_ARGUMENT = typer.Argument(..., exists=True, readable=True, help="Input .wind file")
+OUTPUT_OPTION = typer.Option(
+    Path("output.gcode"), "--output", "-o", help="Destination for generated G-code"
+)
+VERBOSE_OPTION = typer.Option(False, "--verbose", "-v", help="Emit verbose planner output")
+JSON_OPTION = typer.Option(
+    False,
+    "--json",
+    help="Emit machine-readable JSON instead of human-readable text.",
+)
+AXIS_FORMAT_OPTION = typer.Option(
+    "xab",
+    "--axis-format",
+    help="Axis coordinate format: xyz (legacy) or xab (standard rotational)",
+)
+
+
+def plan_command(
+    wind_file: Path = WIND_FILE_ARGUMENT,
+    output: Path = OUTPUT_OPTION,
+    verbose: bool = VERBOSE_OPTION,
+    json_output: bool = JSON_OPTION,
+    axis_format: str = AXIS_FORMAT_OPTION,
+) -> None:
+    # Validate axis format
+    if axis_format not in {"xyz", "xab"}:
+        typer.echo(f"Invalid axis format: {axis_format}. Must be 'xyz' or 'xab'.", err=True)
+        raise typer.Exit(code=1)
+
+    # Select dialect based on axis format
+    dialect = MARLIN_XAB_STANDARD if axis_format == "xab" else MARLIN_XYZ_LEGACY
+
+    try:
+        wind_definition = load_wind_definition(wind_file)
+    except WindFileError as exc:  # pragma: no cover - CLI glue
+        raise typer.BadParameter(str(exc)) from exc
+
+    try:
+        result = plan_wind(wind_definition, PlanOptions(verbose=verbose, dialect=dialect))
+    except Exception as exc:  # pragma: no cover - defensive guard
+        typer.echo(f"Planning failed: {exc}", err=True)
+        raise typer.Exit(code=1) from exc
+
+    destination = write_gcode(result.commands, output)
+
+    summary = {
+        "output": str(destination),
+        "commands": len(result.commands),
+        "timeSeconds": result.total_time_s,
+        "towMeters": result.total_tow_m,
+        "axisFormat": axis_format,
+        "layers": [asdict(metric) for metric in result.layers],
+    }
+
+    if json_output:
+        echo_json(summary)
+        return
+
+    console.print(f"[green]Wrote[/green] {summary['commands']} commands to {destination}")
+    console.print(f"[dim]Axis format: {axis_format.upper()}[/dim]")
+
+    if verbose:
+        table = Table(title="Layer metrics", expand=False)
+        table.add_column("#", justify="right")
+        table.add_column("Type")
+        table.add_column("Cmds", justify="right")
+        table.add_column("Δt (s)", justify="right")
+        table.add_column("Tow (m)", justify="right")
+        for metric in result.layers:
+            table.add_row(
+                str(metric.index),
+                metric.wind_type,
+                str(metric.commands),
+                f"{metric.time_s:.2f}",
+                f"{metric.tow_m:.3f}",
+            )
+        console.print(table)
+        console.print(
+            f"[cyan]Totals[/cyan] time={result.total_time_s:.2f}s tow={result.total_tow_m:.3f}m"
+        )
+        console.print(wind_definition.model_dump(mode="json"))

fiberpath_cli/plot.py

@@ -0,0 +1,37 @@
+"""CLI plot command for PNG previews."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from fiberpath.visualization.plotter import PlotConfig, PlotError, render_plot
+from rich.console import Console
+
+console = Console()
+
+GCODE_ARGUMENT = typer.Argument(..., exists=True, readable=True, help="Input G-code file")
+OUTPUT_OPTION = typer.Option(Path("plot.png"), "--output", "-o", help="PNG destination")
+SCALE_OPTION = typer.Option(
+    1.0, "--scale", help="Pixels per millimeter along carriage axis", min=0.1, max=5.0
+)
+
+
+def plot_command(
+    gcode_file: Path = GCODE_ARGUMENT,
+    output: Path = OUTPUT_OPTION,
+    scale: float = SCALE_OPTION,
+) -> None:
+    program = gcode_file.read_text(encoding="utf-8").splitlines()
+    try:
+        result = render_plot(program, PlotConfig(scale=scale))
+    except PlotError as exc:  # pragma: no cover - parameter validation
+        raise typer.BadParameter(str(exc)) from exc
+
+    output.parent.mkdir(parents=True, exist_ok=True)
+    result.image.save(output, format="PNG")
+    console.print(
+        "[green]Rendered[/green] preview to",
+        output,
+        f"({result.metadata.mandrel_length_mm:.1f} mm × {result.metadata.tow_width_mm:.1f} mm tow)",
+    )

fiberpath_cli/simulate.py

@@ -0,0 +1,36 @@
+"""CLI simulate command."""
+
+from __future__ import annotations
+
+from dataclasses import asdict
+from pathlib import Path
+
+import typer
+from fiberpath.simulation import SimulationError, simulate_program
+
+from .output import echo_json
+
+GCODE_ARGUMENT = typer.Argument(..., exists=True, readable=True)
+JSON_OPTION = typer.Option(False, "--json", help="Emit machine-readable JSON summary")
+
+
+def simulate_command(gcode_file: Path = GCODE_ARGUMENT, json_output: bool = JSON_OPTION) -> None:
+    commands = Path(gcode_file).read_text(encoding="utf-8").splitlines()
+    try:
+        result = simulate_program(commands)
+    except SimulationError as exc:
+        typer.echo(f"Simulation failed: {exc}", err=True)
+        raise typer.Exit(code=1) from exc
+
+    if json_output:
+        echo_json(asdict(result))
+        return
+
+    typer.echo(
+        "Simulated "
+        f"{result.commands_executed} commands / {result.moves} moves in "
+        f"{result.estimated_time_s:.2f}s\n"
+        f"  distance: {result.total_distance_mm:.1f} mm"
+        f"  tow: {result.tow_length_mm / 1000.0:.3f} m"
+        f"  avg feed: {result.average_feed_rate_mmpm:.0f} mm/min"
+    )

fiberpath_cli/stream.py

@@ -0,0 +1,123 @@
+"""CLI command for streaming G-code to a Marlin controller."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from fiberpath.execution import MarlinStreamer, StreamError, StreamProgress
+
+from .output import echo_json
+
+GCODE_ARGUMENT = typer.Argument(..., exists=True, readable=True)
+PROGRESS_INTERVAL = 25
+
+
+def stream_command(
+    gcode_file: Path = GCODE_ARGUMENT,
+    port: str | None = typer.Option(
+        None,
+        "--port",
+        "-p",
+        help="Serial port or pyserial URL (required unless --dry-run).",
+    ),
+    baud_rate: int = typer.Option(250_000, "--baud-rate", "-b", help="Marlin baud rate."),
+    response_timeout: float = typer.Option(
+        10.0,
+        "--timeout",
+        "-t",
+        help="Response timeout in seconds for slow moves.",
+    ),
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        help="Skip serial I/O and just report what would be streamed.",
+    ),
+    verbose: bool = typer.Option(False, "--verbose", help="Print every streamed command."),
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        help="Emit final summary as JSON (progress lines suppressed).",
+    ),
+) -> None:
+    """Stream the provided G-code file to a Marlin device."""
+
+    if not dry_run and port is None:
+        raise typer.BadParameter("--port is required for live streaming", param_hint="--port")
+
+    commands = gcode_file.read_text(encoding="utf-8").splitlines()
+    log_callback = None if json_output else (typer.echo if verbose else None)
+    streamer = MarlinStreamer(
+        port=port, baud_rate=baud_rate, response_timeout_s=response_timeout, log=log_callback
+    )
+    streamer.load_program(commands)
+
+    progress_verbose = verbose or dry_run
+
+    try:
+        while streamer.commands_sent < streamer.commands_total:
+            try:
+                for update in streamer.iter_stream(dry_run=dry_run):
+                    if not json_output and _should_print_progress(update, verbose=progress_verbose):
+                        typer.echo(_format_progress(update))
+                break
+            except KeyboardInterrupt:  # pragma: no cover - user-driven flow
+                if dry_run:
+                    raise
+                typer.echo("\nPause requested (Ctrl+C). Sending M0 ...")
+                _pause_and_prompt(streamer)
+                continue
+    except StreamError as exc:
+        typer.echo(f"Streaming failed: {exc}", err=True)
+        raise typer.Exit(code=1) from exc
+    finally:
+        streamer.close()
+
+    summary = {
+        "status": "dry-run" if dry_run else "live",
+        "commands": streamer.commands_sent,
+        "total": streamer.commands_total,
+        "baudRate": baud_rate,
+        "dryRun": dry_run,
+    }
+
+    if json_output:
+        echo_json(summary)
+        return
+
+    status = "Dry-run" if dry_run else "Streamed"
+    typer.echo(
+        f"{status} {streamer.commands_sent}/{streamer.commands_total} commands at {baud_rate} baud."
+    )
+
+
+def _should_print_progress(progress: StreamProgress, *, verbose: bool) -> bool:
+    if verbose:
+        return True
+    if progress.commands_sent in {1, progress.commands_total}:
+        return True
+    if progress.commands_total <= PROGRESS_INTERVAL:
+        return False
+    return progress.commands_sent % PROGRESS_INTERVAL == 0
+
+
+def _format_progress(progress: StreamProgress) -> str:
+    phase = "dry-run" if progress.dry_run else "live"
+    return f"[{progress.commands_sent}/{progress.commands_total}] ({phase}) {progress.command}"
+
+
+def _pause_and_prompt(streamer: MarlinStreamer) -> None:
+    try:
+        streamer.pause()
+    except StreamError as exc:
+        raise typer.Exit(code=1) from exc
+
+    if not typer.confirm("Resume streaming?", default=True):
+        typer.echo("Stopping stream without resuming.")
+        raise typer.Exit(code=0)
+
+    typer.echo("Resuming (sending M108)...")
+    try:
+        streamer.resume()
+    except StreamError as exc:
+        raise typer.Exit(code=1) from exc

fiberpath_cli/validate.py

@@ -0,0 +1,26 @@
+"""CLI validate command."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from fiberpath.config import WindFileError, load_wind_definition
+
+from .output import echo_json
+
+WIND_FILE_ARGUMENT = typer.Argument(..., exists=True, readable=True)
+JSON_OPTION = typer.Option(False, "--json", help="Emit machine-readable JSON summary")
+
+
+def validate_command(wind_file: Path = WIND_FILE_ARGUMENT, json_output: bool = JSON_OPTION) -> None:
+    try:
+        load_wind_definition(wind_file)
+    except WindFileError as exc:  # pragma: no cover - CLI glue
+        raise typer.BadParameter(str(exc)) from exc
+
+    if json_output:
+        echo_json({"status": "ok", "path": str(wind_file)})
+        return
+
+    typer.echo(f"{wind_file} is valid.")