| from __future__ import annotations |
|
|
| import math |
| import os |
| import re |
| from dataclasses import dataclass |
| from pathlib import Path |
|
|
|
|
| TARGET = Path(os.environ.get("EVAL_TARGET_DIR", r"C:\Users\User\Desktop")) |
| OUTPUT = TARGET / "task-11.nc" |
| NUMBER = r"[+-]?(?:\d+(?:\.\d*)?|\.\d+)" |
| TOKEN_RE = re.compile(rf"([A-Z])\s*({NUMBER})", re.IGNORECASE) |
| EXPECTED_TOOLS = [1, 2, 3, 4] |
| EXPECTED_SPINDLES = {1: 1800.0, 2: 2200.0, 3: 1500.0, 4: 3000.0} |
| EXPECTED_FEEDS = {1: (0.409, 99), 2: (0.409, 99), 3: (0.064, 99), 4: (100.0, 98)} |
|
|
|
|
| @dataclass |
| class Move: |
| tool: int |
| motion: int |
| start_x: float | None |
| start_z: float | None |
| end_x: float | None |
| end_z: float | None |
| feed: float | None |
| feed_mode: int |
|
|
|
|
| @dataclass |
| class Program: |
| tools: list[int] |
| spindles: dict[int, list[float]] |
| moves: list[Move] |
| segment_feeds: dict[int, list[tuple[float, int]]] |
| spindle_on: set[int] |
|
|
|
|
| def strip_comments(raw: str) -> str: |
| source = raw.replace("\x00", "") |
| previous = None |
| while previous != source: |
| previous = source |
| source = re.sub(r"\([^()]*\)", " ", source) |
| return "\n".join(line.split(";", 1)[0] for line in source.splitlines()).upper() |
|
|
|
|
| def words(line: str) -> list[tuple[str, str]]: |
| return [(match.group(1).upper(), match.group(2)) for match in TOKEN_RE.finditer(line)] |
|
|
|
|
| def g_codes(tokens: list[tuple[str, str]]) -> set[int]: |
| result = set() |
| for letter, raw in tokens: |
| if letter != "G": |
| continue |
| value = float(raw) |
| if abs(value - round(value)) <= 1e-9: |
| result.add(int(round(value))) |
| return result |
|
|
|
|
| def tool_number(raw: str) -> int | None: |
| if not re.fullmatch(r"\+?\d+(?:\.0*)?", raw): |
| return None |
| digits = raw.lstrip("+").split(".", 1)[0] |
| number = int(digits) |
| if len(digits) >= 3 or number >= 100: |
| number //= 100 |
| return number |
|
|
|
|
| def close(actual: float, expected: float, absolute: float = 1.0) -> bool: |
| return abs(actual - expected) <= max(absolute, abs(expected) * 0.01) |
|
|
|
|
| def cluster(values: list[float], gap: float) -> list[list[float]]: |
| groups: list[list[float]] = [] |
| for value in sorted(values): |
| if not groups or value - groups[-1][-1] > gap: |
| groups.append([value]) |
| else: |
| groups[-1].append(value) |
| return groups |
|
|
|
|
| def parse(source: str) -> Program | None: |
| lines = source.splitlines() |
| end_index = None |
| for index, line in enumerate(lines): |
| if any(letter == "M" and abs(float(raw) - 30.0) <= 1e-9 for letter, raw in words(line)): |
| end_index = index |
| break |
| if end_index is None: |
| return None |
| trailing = "\n".join(lines[end_index + 1 :]) |
| trailing = re.sub(r"(?m)^\s*N\d+\s*$", "", trailing).replace("%", "").strip() |
| if trailing: |
| return None |
|
|
| unit_scale = 1.0 |
| absolute = True |
| feed_mode = 98 |
| motion = 0 |
| current_tool: int | None = None |
| x: float | None = None |
| z: float | None = None |
| feed: float | None = None |
| tools: list[int] = [] |
| spindles = {tool: [] for tool in EXPECTED_TOOLS} |
| segment_feeds = {tool: [] for tool in EXPECTED_TOOLS} |
| spindle_on: set[int] = set() |
| moves: list[Move] = [] |
|
|
| for line in lines[: end_index + 1]: |
| tokens = words(line) |
| if not tokens: |
| continue |
| codes = g_codes(tokens) |
| if 20 in codes: |
| unit_scale = 25.4 |
| if 21 in codes: |
| unit_scale = 1.0 |
| if 90 in codes: |
| absolute = True |
| if 91 in codes: |
| absolute = False |
| if 98 in codes: |
| feed_mode = 98 |
| if 99 in codes: |
| feed_mode = 99 |
| for code in (0, 1, 2, 3, 81, 82, 83): |
| if code in codes: |
| motion = code |
|
|
| for letter, raw in tokens: |
| if letter != "T": |
| continue |
| parsed_tool = tool_number(raw) |
| if parsed_tool not in EXPECTED_TOOLS: |
| return None |
| current_tool = parsed_tool |
| if not tools or tools[-1] != parsed_tool: |
| tools.append(parsed_tool) |
|
|
| if current_tool is None: |
| continue |
| for letter, raw in tokens: |
| value = float(raw) |
| if letter == "S": |
| spindles[current_tool].append(value) |
| elif letter == "F": |
| feed = value * unit_scale |
| segment_feeds[current_tool].append((feed, feed_mode)) |
| elif letter == "M" and int(round(value)) in (3, 4): |
| spindle_on.add(current_tool) |
|
|
| x_words = [float(raw) * unit_scale for letter, raw in tokens if letter == "X"] |
| z_words = [float(raw) * unit_scale for letter, raw in tokens if letter == "Z"] |
| if not x_words and not z_words: |
| continue |
| start_x, start_z = x, z |
| if x_words: |
| x = x_words[-1] if absolute or x is None else x + x_words[-1] |
| if z_words: |
| z = z_words[-1] if absolute or z is None else z + z_words[-1] |
| if motion in (0, 1, 2, 3, 81, 82, 83): |
| moves.append(Move(current_tool, motion, start_x, start_z, x, z, feed, feed_mode)) |
|
|
| return Program(tools, spindles, moves, segment_feeds, spindle_on) |
|
|
|
|
| def cutting(program: Program, tool: int) -> list[Move]: |
| return [move for move in program.moves if move.tool == tool and move.motion in (1, 2, 3, 81, 82, 83)] |
|
|
|
|
| def valid_feed(program: Program, tool: int) -> bool: |
| expected, expected_mode = EXPECTED_FEEDS[tool] |
| feeds = [(feed, mode) for feed, mode in program.segment_feeds[tool] if feed > 0 and math.isfinite(feed)] |
| tolerance = max(0.0005, abs(expected) * 0.005) |
| return any(mode == expected_mode and abs(feed - expected) <= tolerance for feed, mode in feeds) |
|
|
|
|
| def axial_profile(moves: list[Move], minimum_moves: int) -> bool: |
| positioned = [move for move in moves if move.end_x is not None and move.end_z is not None] |
| if len(positioned) < minimum_moves: |
| return False |
| z_values = [move.end_z for move in positioned] |
| x_values = [move.end_x for move in positioned] |
| if max(z_values) - min(z_values) < 100.0 or min(z_values) > -100.0 or max(z_values) > 10.0: |
| return False |
| distinct_x = {round(value, 1) for value in x_values if 5.0 <= value <= 80.0} |
| return len(distinct_x) >= 3 |
|
|
|
|
| def valid_grooves(moves: list[Move]) -> bool: |
| plunges = [] |
| for move in moves: |
| if move.motion != 1 or None in (move.start_x, move.start_z, move.end_x, move.end_z): |
| continue |
| if abs(move.end_z - move.start_z) <= 0.75 and move.start_x - move.end_x >= 4.0: |
| plunges.append(move) |
| if len(plunges) < 4: |
| return False |
| groups = cluster([move.end_z for move in plunges], gap=8.0) |
| if len(groups) != 2 or any(len(group) < 2 or max(group) - min(group) > 6.0 for group in groups): |
| return False |
| centers = [sum(group) / len(group) for group in groups] |
| if not 20.0 <= centers[1] - centers[0] <= 80.0: |
| return False |
| return all(-160.0 <= center <= 5.0 for center in centers) |
|
|
|
|
| def valid_center_drill(moves: list[Move]) -> bool: |
| for move in moves: |
| if move.motion not in (1, 81, 82, 83) or move.end_x is None or move.end_z is None: |
| continue |
| start_z = move.start_z if move.start_z is not None else 0.0 |
| if abs(move.end_x) <= 0.25 and move.end_z <= -0.5 and start_z - move.end_z >= 1.0: |
| return True |
| return False |
|
|
|
|
| def check(path: Path) -> bool: |
| if not path.is_file() or not 300 <= path.stat().st_size <= 2_000_000: |
| return False |
| raw = path.read_text(encoding="utf-8", errors="ignore") |
| if "\x00" in raw: |
| return False |
| program = parse(strip_comments(raw)) |
| if program is None or program.tools != EXPECTED_TOOLS or program.spindle_on != set(EXPECTED_TOOLS): |
| return False |
| for tool, expected in EXPECTED_SPINDLES.items(): |
| if not any(close(value, expected, 1.0) for value in program.spindles[tool]): |
| return False |
| if not valid_feed(program, tool): |
| return False |
| rough = cutting(program, 1) |
| finish = cutting(program, 2) |
| grooves = cutting(program, 3) |
| center = cutting(program, 4) |
| if not axial_profile(rough, 12) or not axial_profile(finish, 6): |
| return False |
| if not valid_grooves(grooves) or not valid_center_drill(center): |
| return False |
| if sum(1 for move in program.moves if move.motion in (1, 2, 3, 81, 82, 83)) < 30: |
| return False |
| return True |
|
|
|
|
| def main() -> bool: |
| return check(OUTPUT) |
|
|
|
|
| if __name__ == "__main__": |
| try: |
| result = main() |
| except Exception: |
| result = False |
| print("True" if result else "False") |
| raise SystemExit(0) |
|
|
