hyyz17200
132 lines
4.5 KiB
Python
132 lines
4.5 KiB
Python
from __future__ import annotations
|
|
|
|
import re
|
|
from dataclasses import dataclass
|
|
from pathlib import Path
|
|
|
|
from .models import DEFAULT_INSERT_BEFORE_MARKER, LineEnding
|
|
from .paths import default_swap_gcode_dir
|
|
|
|
M73_RE = re.compile(r"^(M73\s+P\d+\s+R)(\d+)(.*)$", re.MULTILINE)
|
|
|
|
|
|
def normalize_newlines(text: str) -> str:
|
|
return text.replace("\r\n", "\n").replace("\r", "\n")
|
|
|
|
|
|
def apply_line_ending(text: str, line_ending: LineEnding) -> bytes:
|
|
normalized = normalize_newlines(text)
|
|
if line_ending == "crlf":
|
|
normalized = normalized.replace("\n", "\r\n")
|
|
return normalized.encode("utf-8")
|
|
|
|
|
|
def read_swap_gcode_file(path: Path) -> str:
|
|
return path.read_text(encoding="utf-8-sig", errors="replace")
|
|
|
|
|
|
def resolve_swap_gcode_path(value: Path | str, swap_gcode_dir: Path | None = None) -> Path:
|
|
raw = Path(value)
|
|
if raw.exists():
|
|
return raw
|
|
search_dir = swap_gcode_dir or default_swap_gcode_dir()
|
|
candidate = search_dir / str(value)
|
|
if candidate.exists():
|
|
return candidate
|
|
if raw.suffix:
|
|
raise FileNotFoundError(f"Swap G-code file not found: {value}")
|
|
for suffix in (".gcode", ".nc", ".ngc", ".txt"):
|
|
candidate = search_dir / f"{value}{suffix}"
|
|
if candidate.exists():
|
|
return candidate
|
|
raise FileNotFoundError(f"Swap G-code file not found: {value}")
|
|
|
|
|
|
def list_swap_gcode_files(directory: Path | None = None) -> list[Path]:
|
|
root = directory or default_swap_gcode_dir()
|
|
if not root.exists():
|
|
return []
|
|
allowed = {".gcode", ".nc", ".ngc", ".txt"}
|
|
return sorted(path for path in root.iterdir() if path.is_file() and not path.name.startswith(".") and path.suffix.lower() in allowed)
|
|
|
|
|
|
def format_duration(seconds: float | None) -> str:
|
|
if seconds is None:
|
|
return "Unknown"
|
|
total = max(0, int(round(seconds)))
|
|
hours, rem = divmod(total, 3600)
|
|
minutes, secs = divmod(rem, 60)
|
|
if hours:
|
|
return f"{hours}h {minutes:02d}m"
|
|
if minutes:
|
|
return f"{minutes}m {secs:02d}s"
|
|
return f"{secs}s"
|
|
|
|
|
|
def format_filament(weight_grams: float | None, used_m: float | None = None) -> str:
|
|
if weight_grams is None and used_m is None:
|
|
return "Unknown"
|
|
parts: list[str] = []
|
|
if weight_grams is not None:
|
|
parts.append(f"{weight_grams:.2f} g")
|
|
if used_m is not None:
|
|
parts.append(f"{used_m:.2f} m")
|
|
return " / ".join(parts)
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class M73OffsetTemplate:
|
|
segments: tuple[str, ...]
|
|
base_remaining_minutes: tuple[int, ...]
|
|
|
|
def apply(self, plate_number: int) -> str:
|
|
if not self.base_remaining_minutes:
|
|
return self.segments[0]
|
|
minute_offset = plate_number * 100 * 60
|
|
parts: list[str] = []
|
|
for index, remaining_minutes in enumerate(self.base_remaining_minutes):
|
|
parts.append(self.segments[index])
|
|
parts.append(str(remaining_minutes + minute_offset))
|
|
parts.append(self.segments[-1])
|
|
return "".join(parts)
|
|
|
|
|
|
def prepare_m73_offset_template(gcode: str) -> M73OffsetTemplate:
|
|
segments: list[str] = []
|
|
base_remaining_minutes: list[int] = []
|
|
last_index = 0
|
|
for match in M73_RE.finditer(gcode):
|
|
segments.append(gcode[last_index : match.start(2)])
|
|
base_remaining_minutes.append(int(match.group(2)))
|
|
last_index = match.end(2)
|
|
segments.append(gcode[last_index:])
|
|
return M73OffsetTemplate(tuple(segments), tuple(base_remaining_minutes))
|
|
|
|
|
|
def apply_plate_number_offset(gcode: str, plate_number: int) -> str:
|
|
return prepare_m73_offset_template(gcode).apply(plate_number)
|
|
|
|
|
|
def build_swap_block(swap_gcode: str, cool_bed_temp: int | None, wait_seconds: int) -> str:
|
|
parts: list[str] = []
|
|
if cool_bed_temp is not None:
|
|
parts.append(f"M190 S{int(cool_bed_temp)}")
|
|
parts.append(normalize_newlines(swap_gcode).rstrip("\n"))
|
|
if wait_seconds > 0:
|
|
parts.append(f"G4 P{int(wait_seconds) * 1000}")
|
|
return "\n".join(part for part in parts if part) + "\n"
|
|
|
|
|
|
def insert_swap_block(gcode: str, swap_block: str, insert_before_marker: str = DEFAULT_INSERT_BEFORE_MARKER) -> str:
|
|
text = normalize_newlines(gcode)
|
|
marker = insert_before_marker.strip()
|
|
if marker:
|
|
marker_index = text.find("\n" + marker)
|
|
if marker_index == -1 and text.startswith(marker):
|
|
marker_index = 0
|
|
if marker_index != -1:
|
|
prefix = text[: marker_index + (1 if marker_index > 0 else 0)]
|
|
suffix = text[marker_index + (1 if marker_index > 0 else 0) :]
|
|
return prefix + swap_block + suffix
|
|
return text.rstrip("\n") + "\n" + swap_block
|