Over-Extrusion Understanding A Beginner-Friendly Breakdown

corrected_e_steps = current_e_steps × (measured_wall_thickness / desired_wall_thickness)

#!/usr/bin/env python3
"""
E-Step Calibration Tool for Marlin/Klipper printers.
Connects via serial, reads current e-steps, performs measurement,
and outputs the corrected value.

Requirements: pip install pyserial
Usage: python3 calibrate_esteps.py --port /dev/ttyUSB0 --baud 115200
"""

import argparse
import re
import serial
import serial.tools.list_ports
import sys
import time
from dataclasses import dataclass
from typing import Optional


@dataclass
class CalibrationResult:
    """Holds the result of an e-step calibration run."""
    current_steps: float
    measured_width: float
    target_width: float
    corrected_steps: float
    correction_pct: float
    passes_threshold: bool


class PrinterConnectionError(Exception):
    """Raised when the printer cannot be reached."""
    pass


class CalibrationError(Exception):
    """Raised when calibration encounters an unexpected state."""
    pass


def find_serial_port(preferred: Optional[str] = None) -> str:
    """
    Locate the serial port for the 3D printer.
    If a preferred port is given, use it directly.
    Otherwise, scan for common patterns (USB serial devices).
    """
    if preferred:
        return preferred

    ports = serial.tools.list_ports.comports()
    candidates = [
        p.device for p in ports
        if 'USB' in p.description.upper() or 'CH340' in p.hwid.upper()
    ]
    if not candidates:
        raise PrinterConnectionError(
            "No printer found. Connect via USB or specify --port."
        )
    if len(candidates) > 1:
        print(f"Warning: Multiple serial devices found: {candidates}")
        print(f"Using first: {candidates[0]}")
    return candidates[0]


def send_command(ser: serial.Serial, cmd: str, timeout: float = 5.0) -> str:
    """
    Send a G-code command and read the response.
    Strips comments, handles ok/error lines.
    """
    ser.write(f"{cmd}\n".encode())
    ser.flush()
    deadline = time.time() + timeout
    response_lines = []
    while time.time() < deadline:
        if ser.in_waiting:
            line = ser.readline().decode('utf-8', errors='replace').strip()
            if not line:
                continue
            # Skip echo and ok lines
            if line.startswith('echo:') or line == 'ok':
                continue
            if line.startswith('Error'):
                raise CalibrationError(f"Printer error: {line}")
            response_lines.append(line)
        if response_lines and len(response_lines) >= 3:
            break
        time.sleep(0.05)
    return '\n'.join(response_lines)


def read_current_esteps(ser: serial.Serial, axis: str = 'E') -> float:
    """
    Query current steps/mm for the specified axis.
    Works with both M503 (Marlin) and DUMP_TMC (Klipper with stepper config).
    """
    response = send_command(ser, f"M503")
    # Marlin format: echo: M92 E93.0
    pattern = rf'{axis.upper()}\s*(-?\d+\.?\d*)'
    match = re.search(pattern, response)
    if not match:
        raise CalibrationError(
            f"Could not parse e-steps from response: {response[:200]}"
        )
    return float(match.group(1))


def calculate_corrected_steps(
    current_steps: float,
    measured_width: float,
    target_width: float,
    nozzle_diameter: float,
) -> CalibrationResult:
    """
    Compute corrected e-steps based on measured single-wall thickness.
    Applies a safety clamp: correction is capped at ±25% per iteration
    to prevent runaway values from bad measurements.
    """
    if measured_width <= 0:
        raise CalibrationError(f"Measured width must be positive, got {measured_width}")
    if target_width <= 0:
        raise CalibrationError(f"Target width must be positive, got {target_width}")

    correction_ratio = measured_width / target_width
    corrected = current_steps * correction_ratio
    correction_pct = (correction_ratio - 1.0) * 100.0

    # Safety clamp: refuse corrections larger than 25%
    # If exceeded, warn the user to re-measure
    max_correction = 0.25
    passes_threshold = abs(correction_pct) <= (max_correction * 100)

    return CalibrationResult(
        current_steps=current_steps,
        measured_width=measured_width,
        target_width=target_width,
        corrected_steps=round(corrected, 2),
        correction_pct=round(correction_pct, 2),
        passes_threshold=passes_threshold,
    )


def main():
    parser = argparse.ArgumentParser(
        description="Calibrate e-steps for FDM 3D printers."
    )
    parser.add_argument(
        '--port', '-p', type=str, default=None,
        help='Serial port (e.g., /dev/ttyUSB0). Auto-detected if omitted.'
    )
    parser.add_argument(
        '--baud', '-b', type=int, default=115200,
        help='Baud rate (default: 115200)'
    )
    parser.add_argument(
        '--measured', '-m', type=float, required=True,
        help='Measured single-wall width in mm (use calipers)'
    )
    parser.add_argument(
        '--target', '-t', type=float, default=None,
        help='Target wall thickness in mm (default: equals nozzle diameter)'
    )
    parser.add_argument(
        '--nozzle', '-n', type=float, default=0.4,
        help='Nozzle diameter in mm (default: 0.4)'
    )
    args = parser.parse_args()

    target = args.target if args.target else args.nozzle

    # 1. Connect
    port = find_serial_port(args.port)
    print(f"Connecting to {port} at {args.baud} baud...")
    try:
        ser = serial.Serial(port, args.baud, timeout=2)
        time.sleep(3)  # Allow printer to initialize
    except serial.SerialException as e:
        raise PrinterConnectionError(f"Failed to open {port}: {e}")

    # 2. Read current e-steps
    try:
        current = read_current_esteps(ser)
        print(f"Current E steps/mm: {current}")
    except CalibrationError as e:
        ser.close()
        print(f"Error reading e-steps: {e}")
        sys.exit(1)

    # 3. Calculate correction
    result = calculate_corrected_steps(
        current_steps=current,
        measured_width=args.measured,
        target_width=target,
        nozzle_diameter=args.nozzle,
    )

    # 4. Report
    print(f"\n{'='*50}")
    print(f"  CALIBRATION RESULT")
    print(f"{'='*50}")
    print(f"  Measured width:     {result.measured_width:.2f} mm")
    print(f"  Target width:       {result.target_width:.2f} mm")
    print(f"  Current e-steps:    {result.current_steps:.2f}")
    print(f"  Corrected e-steps:  {result.corrected_steps:.2f}")
    print(f"  Correction:         {result.correction_pct:+.2f}%")
    if not result.passes_threshold:
        print(f"  ⚠️  WARNING: Correction exceeds 25%. Re-measure before applying.")
    else:
        print(f"  ✅ Correction within safe range.")
        print(f"\n  To apply on Marlin, send:")
        print(f"    M92 E{result.corrected_steps}")
        print(f"    M500")

    ser.close()
    print(f"{'='*50}")


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
G-Code Extrusion Volume Analyzer.
Parses G-code files to detect over-extrusion by computing
per-layer extrusion volume and flagging anomalies.

Usage: python3 analyze_extrusion.py model.gcode --threshold 1.15
"""

import argparse
import csv
import math
import os
import sys
from dataclasses import dataclass, field
from typing import List, Optional


@dataclass
class ExtrusionSegment:
    """Represents a single extrusion move."""
    layer: int
    x: float = 0.0
    y: float = 0.0
    z: float = 0.0
    e: float = 0.0
    feedrate: float = 0.0
    extruded_volume_mm3: float = 0.0


@dataclass
class LayerStats:
    """Aggregated statistics for a single layer."""
    layer_index: int
    z_height: float = 0.0
    total_extrusion_mm3: float = 0.0
    total_e_input_mm: float = 0.0
    segment_count: int = 0
    avg_extrusion_rate: float = 0.0
    is_over_extruding: bool = False


@dataclass
class AnalysisReport:
    """Full analysis of a G-code file."""
    filename: str
    filament_diameter_mm: float
    nozzle_diameter_mm: float
    layer_height_mm: float
    total_extrusion_mm3: float = 0.0
    total_e_input_mm: float = 0.0
    layer_stats: List[LayerStats] = field(default_factory=list)
    flagged_layers: List[int] = field(default_factory=list)
    estimated_part_weight_g: float = 0.0


def parse_gcode(filepath: str) -> List[ExtrusionSegment]:
    """
    Parse G-code file and extract extrusion segments.
    Handles both absolute (G90) and relative (G91) extrusion modes.
    Supports standard G1 moves with E-axis parameters.
    """
    segments = []
    current_x, current_y, current_z = 0.0, 0.0, 0.0
    current_e = 0.0
    current_feedrate = 1500.0  # mm/min default
    current_layer = 0
    relative_extrusion = False
    layer_change_z = {}

    if not os.path.isfile(filepath):
        raise FileNotFoundError(f"G-code file not found: {filepath}")

    with open(filepath, 'r', encoding='utf-8', errors='replace') as f:
        for line_num, raw_line in enumerate(f, 1):
            line = raw_line.split(';')[0].strip()  # Strip comments
            if not line:
                continue

            tokens = line.split()
            if not tokens:
                continue

            # Track modal modes
            if 'G90' in line:
                relative_extrusion = False
            elif 'G91' in line:
                relative_extrusion = True

            # Only process G1 moves with extrusion
            if not tokens[0] in ('G0', 'G1', 'G17'):
                continue

            segment = ExtrusionSegment(layer=current_layer)
            has_movement = False

            for token in tokens[1:]:
                if not token:
                    continue
                param = token[0].upper()
                try:
                    value = float(token[1:])
                except (ValueError, IndexError):
                    continue

                if param == 'X':
                    current_x = value
                    has_movement = True
                elif param == 'Y':
                    current_y = value
                    has_movement = True
                elif param == 'Z':
                    current_z = value
                    has_movement = True
                    layer_change_z[current_layer] = current_z
                elif param == 'E':
                    if relative_extrusion:
                        segment.e = value
                        current_e += value
                    else:
                        delta_e = value - current_e
                        segment.e = max(delta_e, 0.0)
                        current_e = value
                elif param == 'F':
                    current_feedrate = value
                    segment.feedrate = value

            if segment.e > 0 and has_movement:
                segment.x = current_x
                segment.y = current_y
                segment.z = current_z
                segment.layer = current_layer
                segment.feedrate = current_feedrate
                segments.append(segment)

            # Detect layer changes (Z-axis increase)
            # This is a heuristic: track Z increments
            if has_movement and current_z > 0:
                expected_layer = int(round(current_z / 0.2))  # Assume 0.2mm default
                if expected_layer > current_layer:
                    current_layer = expected_layer

    return segments


def compute_segment_volumes(
    segments: List[ExtrusionSegment],
    filament_diameter: float,
) -> None:
    """
    Compute the extruded volume (in mm³) for each segment.
    Volume = cross_section_area × e_input_length.
    Cross section of filament = pi * (d/2)^2.
    """
    radius = filament_diameter / 2.0
    filament_area_mm2 = math.pi * radius * radius

    for seg in segments:
        seg.extruded_volume_mm3 = seg.e * filament_area_mm2


def aggregate_by_layer(
    segments: List[ExtrusionSegment],
    nozzle_diameter: float,
    layer_height: float,
) -> List[LayerStats]:
    """
    Aggregate extrusion data per layer.
    Compute expected vs actual extrusion rates.
    """
    # Group segments by layer
    layer_map: dict = {}
    for seg in segments:
        layer_map.setdefault(seg.layer, []).append(seg)

    layer_stats = []
    for layer_idx in sorted(layer_map.keys()):
        segs = layer_map[layer_idx]
        total_e = sum(s.e for s in segs)
        total_vol = sum(s.extruded_volume_mm3 for s in segs)
        z_height = segs[0].z if segs else 0.0

        # Expected line width ≈ nozzle_diameter * 1.2 (typical packing ratio)
        expected_line_width = nozzle_diameter * 1.2
        # For a single-wall perimeter, expected volume per mm of travel:
        # cross_section = layer_height * expected_line_width
        cross_section = layer_height * expected_line_width

        stats = LayerStats(
            layer_index=layer_idx,
            z_height=round(z_height, 3),
            total_extrusion_mm3=round(total_vol, 4),
            total_e_input_mm=round(total_e, 4),
            segment_count=len(segs),
        )
        layer_stats.append(stats)

    return layer_stats


def flag_over_extrusion(
    report: AnalysisReport,
    threshold_ratio: float,
) -> AnalysisReport:
    """
    Flag layers where extrusion volume exceeds the threshold.
    threshold_ratio of 1.15 means flag anything >15% above nominal.
    """
    if not report.layer_stats:
        return report

    # Compute median extrusion as baseline (robust against outliers)
    volumes = [ls.total_extrusion_mm3 for ls in report.layer_stats]
    volumes_sorted = sorted(volumes)
    mid = len(volumes_sorted) // 2
    median_volume = (
        volumes_sorted[mid]
        if len(volumes_sorted) % 2
        else (volumes_sorted[mid - 1] + volumes_sorted[mid]) / 2
    )

    for ls in report.layer_stats:
        if median_volume > 0:
            ratio = ls.total_extrusion_mm3 / median_volume
            ls.is_over_extruding = ratio > threshold_ratio
            ls.avg_extrusion_rate = round(ratio, 3)
            if ls.is_over_extruding:
                report.flagged_layers.append(ls.layer_index)

    return report


def estimate_weight(report: AnalysisReport) -> float:
    """
    Estimate printed part weight using PLA density (1.24 g/cm³).
    Converts mm³ to cm³ and multiplies by density.
    """
    density_pla_g_per_cm3 = 1.24
    volume_cm3 = report.total_extrusion_mm3 / 1000.0  # mm³ → cm³
    return round(volume_cm3 * density_pla_g_per_cm3, 2)


def export_csv(report: AnalysisReport, csv_path: str) -> None:
    """Export per-layer stats to CSV for further analysis."""
    with open(csv_path, 'w', newline='') as f:
        writer = csv.writer(f)
        writer.writerow([
            'layer', 'z_height_mm', 'extrusion_mm3',
            'e_input_mm', 'segments', 'over_extruding'
        ])
        for ls in report.layer_stats:
            writer.writerow([
                ls.layer_index,
                ls.z_height,
                ls.total_extrusion_mm3,
                ls.total_e_input_mm,
                ls.segment_count,
                ls.is_over_extruding,
            ])


def main():
    parser = argparse.ArgumentParser(
        description="Analyze G-code for over-extrusion."
    )
    parser.add_argument('filepath', help='Path to G-code file')
    parser.add_argument(
        '--filament-diameter', type=float, default=1.75,
        help='Filament diameter in mm (default: 1.75)'
    )
    parser.add_argument(
        '--nozzle-diameter', type=float, default=0.4,
        help='Nozzle diameter in mm (default: 0.4)'
    )
    parser.add_argument(
        '--layer-height', type=float, default=0.2,
        help='Layer height in mm (default: 0.2)'
    )
    parser.add_argument(
        '--threshold', type=float, default=1.15,
        help='Over-extrusion ratio threshold (default: 1.15 = 15%% above median)'
    )
    parser.add_argument(
        '--export-csv', type=str, default=None,
        help='Export per-layer data to CSV file'
    )
    args = parser.parse_args()

    # 1. Parse
    print(f"Parsing {args.filepath}...")
    try:
        segments = parse_gcode(args.filepath)
    except FileNotFoundError as e:
        print(f"Error: {e}")
        sys.exit(1)

    print(f"  Found {len(segments)} extrusion segments")
    if not segments:
        print("  No extrusion segments found. Check G-code file.")
        sys.exit(0)

    # 2. Compute volumes
    compute_segment_volumes(segments, args.filament_diameter)

    # 3. Aggregate
    layer_stats = aggregate_by_layer(
        segments, args.nozzle_diameter, args.layer_height
    )

    # 4. Build report
    report = AnalysisReport(
        filename=os.path.basename(args.filepath),
        filament_diameter_mm=args.filament_diameter,
        nozzle_diameter_mm=args.nozzle_diameter,
        layer_height_mm=args.layer_height,
        layer_stats=layer_stats,
        total_extrusion_mm3=round(
            sum(s.extruded_volume_mm3 for s in segments), 2
        ),
        total_e_input_mm=round(sum(s.e for s in segments), 2),
    )

    # 5. Flag over-extrusion
    report = flag_over_extrusion(report, args.threshold)
    report.estimated_part_weight_g = estimate_weight(report)

    # 6. Output
    print(f"\n{'='*60}")
    print(f"  EXTRUSION ANALYSIS REPORT")
    print(f"{'='*60}")
    print(f"  File:                {report.filename}")
    print(f"  Filament diameter:   {report.filament_diameter_mm} mm")
    print(f"  Nozzle diameter:     {report.nozzle_diameter_mm} mm")
    print(f"  Layer height:        {report.layer_height_mm} mm")
    print(f"  Total layers:        {len(report.layer_stats)}")
    print(f"  Total extrusion:     {report.total_extrusion_mm3:.2f} mm³")
    print(f"  Total E input:       {report.total_e_input_mm:.2f} mm")
    print(f"  Est. part weight:    {report.estimated_part_weight_g} g")
    print(f"  Flagged layers:      {len(report.flagged_layers)}")

    if report.flagged_layers:
        print(f"\n  ⚠️  OVER-EXTRUSION DETECTED ON LAYERS:")
        for idx in report.flagged_layers[:10]:
            ls = report.layer_stats[idx]
            print(f"    Layer {idx:>4d}  Z={ls.z_height:.2f}mm  "
                  f"volume={ls.total_extrusion_mm3:.2f}mm³  "
                  f"ratio={ls.avg_extrusion_rate:.3f}")
        if len(report.flagged_layers) > 10:
            print(f"    ... and {len(report.flagged_layers) - 10} more")
    else:
        print(f"\n  ✅ No over-extrusion detected within {args.threshold} threshold.")

    if args.export_csv:
        export_csv(report, args.export_csv)
        print(f"\n  CSV exported to {args.export_csv}")

    print(f"{'='*60}")


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
Slicer Profile Validator — detects over-extrusion-prone settings.
Validates PrusaSlicer / OrcaSlicer .ini config files.

Usage: python3 validate_profile.py my_profile.ini
"""

import argparse
import configparser
import json
import os
import sys
from dataclasses import dataclass, field
from typing import Dict, List, Tuple


# Safe operating ranges based on empirical testing with Ender 3,
# Prusa i3 MK3S+, and Bambu Lab X1C.
# Format: (min_safe, max_safe, unit, description)
EXTRUSION_PARAM_RANGES: Dict[str, Tuple[float, float, str, str]] = {
    'extrusion_multiplier':       (0.85, 1.10, '', 'Overall extrusion multiplier'),
    'perimeter_extrusion_width':  (0.35, 0.55, 'mm', 'Perimeter line width'),
    'external_perimeter_extrusion_width': (0.35, 0.55, 'mm', 'External perimeter width'),
    'infill_extrusion_width':     (0.40, 0.60, 'mm', 'Infill line width'),
    'solid_infill_extrusion_width': (0.35, 0.55, 'mm', 'Solid infill width'),
    'top_solid_infill_extrusion_width': (0.35, 0.55, 'mm', 'Top solid infill width'),
    'first_layer_extrusion_width': (0.40, 0.60, '', 'First layer width ratio'),
    'bridge_flow_ratio':          (0.80, 1.10, '', 'Bridge extrusion multiplier'),
    'small_perimeter_speed':      (5.0, 25.0, 'mm/s', 'Small perimeter speed'),
}

# Known filament-specific defaults
FILAMENT_DEFAULTS: Dict[str, Dict[str, float]] = {
    'PLA': {
        'extrusion_multiplier': 1.0,
        'temperature': 210,
    },
    'PETG': {
        'extrusion_multiplier': 0.98,
        'temperature': 235,
    },
    'ABS': {
        'extrusion_multiplier': 1.0,
        'temperature': 245,
    },
    'TPU': {
        'extrusion_multiplier': 0.95,
        'temperature': 220,
    },
}


@dataclass
class ValidationIssue:
    """A single validation finding."""
    severity: str  # 'WARN' or 'ERROR'
    parameter: str
    value: float
    safe_range: str
    message: str


@dataclass
class ProfileReport:
    """Full validation report for a slicer profile."""
    filename: str
    nozzle_diameter: float
    filament_type: str
    issues: List[ValidationIssue] = field(default_factory=list)
    total_checks: int = 0
    passed_checks: int = 0

    @property
    def pass_rate(self) -> float:
        if self.total_checks == 0:
            return 0.0
        return round(self.passed_checks / self.total_checks * 100, 1)

    @property
    def error_count(self) -> int:
        return sum(1 for i in self.issues if i.severity == 'ERROR')

    @property
    def warning_count(self) -> int:
        return sum(1 for i in self.issues if i.severity == 'WARN')


def load_profile(filepath: str) -> configparser.ConfigParser:
    """
    Load a slicer profile file.
    PrusaSlicer .ini files are standard configparser-compatible.
    For .3mf files, extraction would require zipfile handling;
    this version handles .ini profiles directly.
    """
    if not os.path.isfile(filepath):
        raise FileNotFoundError(f"Profile not found: {filepath}")

    if not filepath.endswith('.ini'):
        print(f"Warning: Expected .ini file. Attempting to parse {filepath} anyway.")

    config = configparser.ConfigParser(interpolation=None)
    try:
        config.read(filepath, encoding='utf-8')
    except configparser.Error as e:
        raise ValueError(f"Failed to parse profile: {e}")

    if 'preset' not in config and 'print' not in config:
        raise ValueError(
            "Profile does not appear to be a valid PrusaSlicer config. "
            "Expected [preset] or [print] sections."
        )
    return config


def extract_float(config: configparser.ConfigParser, section: str,
                  key: str, default: float = 0.0) -> float:
    """Safely extract a float from a config section."""
    try:
        raw = config.get(section, key, fallback=str(default))
        return float(raw.strip().rstrip('%'))
    except (ValueError, configparser.NoSectionError):
        return default


def validate_profile(config: configparser.ConfigParser,
                     filename: str) -> ProfileReport:
    """
    Run all extrusion-related validation checks on a loaded profile.
    Returns a structured report with issues.
    """
    # Detect nozzle size from config
    nozzle = extract_float(config, 'filament', 'nozzle_diameter', 0.4)
    filament = config.get('preset', 'filament_settings_id', fallback='unknown')
    # Strip quotes if present
    filament = filament.strip('"')

    report = ProfileReport(
        filename=filename,
        nozzle_diameter=nozzle,
        filament_type=filament,
    )

    for param_name, (lo, hi, unit, desc) in EXTRUSION_PARAM_RANGES.items():
        report.total_checks += 1
        value = extract_float(config, 'print', param_name, default=None)

        # Try filament section as fallback (PrusaSlicer stores some here)
        if value is None or value == 0.0:
            value = extract_float(config, 'filament', param_name, default=0.0)

        if value == 0.0:
            # Parameter not found — skip
            continue

        in_range = lo <= value <= hi
        range_str = f"{lo}–{hi}{' ' + unit if unit else ''}"

        if not in_range:
            severity = 'ERROR' if value > hi * 1.2 or value < lo * 0.8 else 'WARN'
            direction = 'above' if value > hi else 'below'
            report.issues.append(ValidationIssue(
                severity=severity,
                parameter=param_name,
                value=round(value, 3),
                safe_range=range_str,
                message=(
                    f"{desc} ({param_name}) = {value:.3f} is {direction} "
                    f"safe range {range_str}. "
                    f"Risk of over-extrusion."
                    if value > hi
                    else f"{desc} ({param_name}) = {value:.3f} is {direction} "
                         f"safe range {range_str}."
                ),
            ))
        else:
            report.passed_checks += 1

    # Cross-check: extrusion_multiplier vs filament defaults
    actual_multiplier = extract_float(config, 'print', 'extrusion_multiplier', 0.0)
    if filament in FILAMENT_DEFAULTS:
        expected = FILAMENT_DEFAULTS[filament]['extrusion_multiplier']
        deviation = abs(actual_multiplier - expected) / expected
        if deviation > 0.15:
            report.issues.append(ValidationIssue(
                severity='WARN',
                parameter='extrusion_multiplier',
                value=actual_multiplier,
                safe_range=f'~{expected} for {filament}',
                message=(
                    f"Extrusion multiplier {actual_multiplier:.3f} deviates "
                    f"{deviation*100:.0f}% from typical {filament} default "
                    f"({expected}). Verify with a single-wall test."
                ),
            ))
            report.total_checks += 1

    return report


def print_report(report: ProfileReport) -> None:
    """Pretty-print the validation report to stdout."""
    print(f"\n{'='*60}")
    print(f"  SLICER PROFILE VALIDATION")
    print(f"{'='*60}")
    print(f"  Profile:      {report.filename}")
    print(f"  Nozzle:       {report.nozzle_diameter} mm")
    print(f"  Filament:     {report.filament_type}")
    print(f"  Checks run:   {report.total_checks}")
    print(f"  Passed:       {report.passed_checks}")
    print(f"  Pass rate:    {report.pass_rate}%")
    print(f"  Errors:       {report.error_count}")
    print(f"  Warnings:     {report.warning_count}")

    if report.issues:
        print(f"\n  {'SEVERITY':<8} {'PARAMETER':<35} {'VALUE':<12} {'RANGE'}")
        print(f"  {'-'*8} {'-'*35} {'-'*12} {'-'*30}")
        for issue in sorted(report.issues, key=lambda i: i.severity):
            icon = '❌' if issue.severity == 'ERROR' else '⚠️ '
            print(f"  {icon} {issue.severity:<6} {issue.parameter:<35} "
                  f"{issue.value:<12} {issue.safe_range}")
            print(f"       → {issue.message}")
    else:
        print(f"\n  ✅ All extrusion parameters within safe ranges.")

    print(f"{'='*60}")


def main():
    parser = argparse.ArgumentParser(
        description="Validate slicer profiles for over-extrusion risks."
    )
    parser.add_argument('filepath', help='Path to slicer .ini profile')
    parser.add_argument(
        '--json', action='store_true',
        help='Output report as JSON'
    )
    args = parser.parse_args()

    try:
        config = load_profile(args.filepath)
    except (FileNotFoundError, ValueError) as e:
        print(f"Error: {e}")
        sys.exit(1)

    report = validate_profile(config, os.path.basename(args.filepath))

    if args.json:
        data = {
            'filename': report.filename,
            'nozzle_diameter': report.nozzle_diameter,
            'filament_type': report.filament_type,
            'total_checks': report.total_checks,
            'passed_checks': report.passed_checks,
            'pass_rate': report.pass_rate,
            'issues': [
                {
                    'severity': i.severity,
                    'parameter': i.parameter,
                    'value': i.value,
                    'safe_range': i.safe_range,
                    'message': i.message,
                }
                for i in report.issues
            ],
        }
        print(json.dumps(data, indent=2))
    else:
        print_report(report)


if __name__ == '__main__':
    main()

# Example start G-code snippet in PrusaSlicer
; Filament: Overture PLA Red
M92 E87.5          ; calibrated 2024-11-15, measured width 0.40mm
M104 S210          ; set temp
G28                ; home all

# .github/workflows/slicer-lint.yml
name: Slicer Profile Validation
on: pull_request
jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'
      - name: Install dependencies
        run: pip install pyserial
      - name: Validate profiles
        run: |
          python3 validate_profile.py profiles/pla_0.2.ini --json
          python3 validate_profile.py profiles/petg_0.16.ini --json

# Monthly calibration log (CSV)
# date,nozzle_mm,measured_width_mm,estimated_esteps,notes
2024-01-15,0.40,0.40,87.50,baseline
2024-02-15,0.40,0.41,87.10,slight drift
2024-03-15,0.40,0.41,87.10,stable
2024-04-15,0.40,0.43,86.05,increased drift
2024-05-15,0.40,0.46,84.30,nozzle replaced after this entry
2024-05-16,0.40,0.40,87.50,new nozzle baseline