Umutcan Edizsalan
0c7f64ceb6
N1: COM hatch non-associative (AddHatch associativity=False) N2: ezdxf refuses DWG saves with clear error; server.py derives fmt from extension R19: dimension_aligned dist→distance; dimension_angular correct add_angular_dim_2l args (base/line1/line2/location) R9: polar array 360° no-duplicate (divisor=n when fill_angle%360<ε) R13: entity_offset side_x/side_y honored in ezdxf via cross-product (LINE) and distance-to-center (CIRCLE) R18: drawing_new bootstrap failure surfaces status="degraded" instead of swallowing silently Dead code: engineering/section.py, gear.generate_tooth_profile, CommandResult, _ACI_NAMES, set_layer_active, ensure_linetypes, ComBackend._batch_mode instance attr, engineering/__init__ build-seam comment Ruff: 38 auto-fixed + 5 manual → codebase is now ruff-clean; CI lint is now blocking 184 tests pass.
252 lines
8.9 KiB
Python
252 lines
8.9 KiB
Python
"""Premium-quality critique checks for finished drawings.
|
|
|
|
Each focus runs an independent check; new focuses must be added to the
|
|
`CritiqueFocus` Literal in plan_spec.py *and* registered here. Closed enum
|
|
keeps drawing_critique scope from drifting.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import math
|
|
from typing import TYPE_CHECKING
|
|
|
|
from .layers import ENGINEERING_LAYERS
|
|
from .plan_spec import (
|
|
ALL_CRITIQUE_FOCUSES,
|
|
ISO_128_LINEWEIGHTS_MM,
|
|
CritiqueFocus,
|
|
Issue,
|
|
)
|
|
|
|
if TYPE_CHECKING:
|
|
from backends.base import AutoCADBackend
|
|
|
|
|
|
# Layer-name → expected ACI color, derived from ENGINEERING_LAYERS.
|
|
_EXPECTED_LAYER_COLOR: dict[str, int] = {
|
|
name: color for name, color, _lt, _lw, _desc in ENGINEERING_LAYERS
|
|
}
|
|
|
|
# Dimension entity types that should sit on the DIM layer.
|
|
_DIM_TYPES = {
|
|
"DIMENSION", "DIMLINEAR", "DIMALIGNED", "DIMANGULAR",
|
|
"DIMRADIUS", "DIMDIAMETER", "DIMORDINATE",
|
|
}
|
|
|
|
|
|
async def _check_iso128(backend: AutoCADBackend) -> list[Issue]:
|
|
"""Layer lineweights must be in ISO_128_LINEWEIGHTS_MM (or -3=ByLayer
|
|
sentinel meaning 'inherit')."""
|
|
issues: list[Issue] = []
|
|
try:
|
|
layers = await backend.layer_list()
|
|
except Exception as exc:
|
|
return [Issue("warning", "iso128", f"layer_list failed: {exc}")]
|
|
allowed = set(ISO_128_LINEWEIGHTS_MM)
|
|
for lyr in layers:
|
|
# CONSTRUCTION-class layers are intentionally sub-ISO (0.05mm scratch
|
|
# weight) and must be cleared before finalize — never an ISO violation.
|
|
if "CONST" in lyr.name.upper():
|
|
continue
|
|
lw = float(lyr.lineweight)
|
|
# AutoCAD sentinels: -1 (Default), -2 (ByBlock), -3 (ByLayer);
|
|
# 0.0 = ezdxf's "use default" — not an ISO 128 violation.
|
|
if lw <= 0:
|
|
continue
|
|
# Layer lineweights come through as ezdxf/COM hundredths-of-a-mm
|
|
# (e.g. 25 == 0.25mm) — they are NOT pre-normalised to mm, so accept
|
|
# either the raw mm value or hundredths/100.
|
|
if lw not in allowed and (lw / 100.0) not in allowed:
|
|
issues.append(Issue(
|
|
severity="warning",
|
|
focus="iso128",
|
|
message=(
|
|
f"Layer '{lyr.name}' lineweight {lw} mm is not in the "
|
|
f"ISO 128 set {sorted(allowed)}."
|
|
),
|
|
detail={"layer": lyr.name, "lineweight": lw},
|
|
))
|
|
return issues
|
|
|
|
|
|
async def _check_layer_color(backend: AutoCADBackend) -> list[Issue]:
|
|
"""Engineering-standard layers must keep their canonical ACI color."""
|
|
issues: list[Issue] = []
|
|
try:
|
|
layers = await backend.layer_list()
|
|
except Exception:
|
|
return []
|
|
for lyr in layers:
|
|
expected = _EXPECTED_LAYER_COLOR.get(lyr.name)
|
|
if expected is None:
|
|
continue # unknown layer — caller's responsibility
|
|
if int(lyr.color) != int(expected):
|
|
issues.append(Issue(
|
|
severity="warning",
|
|
focus="layer_color",
|
|
message=(
|
|
f"Layer '{lyr.name}' has color {lyr.color}; "
|
|
f"engineering standard expects {expected}."
|
|
),
|
|
detail={"layer": lyr.name, "got": int(lyr.color), "expected": expected},
|
|
))
|
|
return issues
|
|
|
|
|
|
async def _check_construction_left(backend: AutoCADBackend) -> list[Issue]:
|
|
"""CONSTRUCTION layer must be empty before drawing_finalize."""
|
|
try:
|
|
ents = await backend.entity_list(layer_filter="CONSTRUCTION", limit=5000)
|
|
except Exception:
|
|
return []
|
|
if not ents:
|
|
return []
|
|
return [Issue(
|
|
severity="error",
|
|
focus="construction_left",
|
|
message=(
|
|
f"{len(ents)} entity/entities still on CONSTRUCTION layer. "
|
|
"Call construction_clear() before drawing_finalize."
|
|
),
|
|
handles=[e.handle for e in ents[:50]],
|
|
detail={"count": len(ents)},
|
|
)]
|
|
|
|
|
|
async def _check_untrimmed_corner(backend: AutoCADBackend) -> list[Issue]:
|
|
"""Two LINE endpoints within `tol` but not exactly equal usually means a
|
|
corner where one line overshoots — TRIM/EXTEND/FILLET was forgotten."""
|
|
tol = 0.5 # mm — generous; tighten via PlanSpec.notes later
|
|
try:
|
|
lines = await backend.entity_list(type_filter="LINE", limit=5000)
|
|
except Exception:
|
|
return []
|
|
endpoints: list[tuple[str, tuple[float, float]]] = []
|
|
for ln in lines:
|
|
s = ln.properties.get("start")
|
|
e = ln.properties.get("end")
|
|
if s and e:
|
|
endpoints.append((ln.handle, (float(s[0]), float(s[1]))))
|
|
endpoints.append((ln.handle, (float(e[0]), float(e[1]))))
|
|
issues: list[Issue] = []
|
|
n = len(endpoints)
|
|
seen: set[frozenset[str]] = set()
|
|
for i in range(n):
|
|
h1, p1 = endpoints[i]
|
|
for j in range(i + 1, n):
|
|
h2, p2 = endpoints[j]
|
|
if h1 == h2:
|
|
continue
|
|
d = math.hypot(p1[0] - p2[0], p1[1] - p2[1])
|
|
if 1e-9 < d <= tol:
|
|
key = frozenset((h1, h2))
|
|
if key in seen:
|
|
continue
|
|
seen.add(key)
|
|
issues.append(Issue(
|
|
severity="warning",
|
|
focus="untrimmed_corner",
|
|
message=(
|
|
f"Lines {h1} and {h2} have endpoints {d:.3f} mm apart — "
|
|
"likely an untrimmed corner (use entity_trim or entity_fillet)."
|
|
),
|
|
handles=[h1, h2],
|
|
detail={"gap_mm": d, "p1": list(p1), "p2": list(p2)},
|
|
))
|
|
return issues
|
|
|
|
|
|
async def _check_duplicate_entities(backend: AutoCADBackend) -> list[Issue]:
|
|
"""Two LINEs with identical endpoints (in either direction) are duplicates."""
|
|
try:
|
|
lines = await backend.entity_list(type_filter="LINE", limit=5000)
|
|
except Exception:
|
|
return []
|
|
seen: dict[tuple, str] = {}
|
|
issues: list[Issue] = []
|
|
for ln in lines:
|
|
s = ln.properties.get("start")
|
|
e = ln.properties.get("end")
|
|
if not (s and e):
|
|
continue
|
|
k1 = (round(s[0], 4), round(s[1], 4), round(e[0], 4), round(e[1], 4))
|
|
k2 = (k1[2], k1[3], k1[0], k1[1])
|
|
for key in (k1, k2):
|
|
if key in seen:
|
|
issues.append(Issue(
|
|
severity="warning",
|
|
focus="duplicate_entities",
|
|
message=f"Lines {seen[key]} and {ln.handle} are duplicates.",
|
|
handles=[seen[key], ln.handle],
|
|
))
|
|
break
|
|
else:
|
|
seen[k1] = ln.handle
|
|
return issues
|
|
|
|
|
|
async def _check_dim_overlap(backend: AutoCADBackend) -> list[Issue]:
|
|
"""Two dimensions whose insertion points are within `tol` likely overlap."""
|
|
tol = 5.0 # mm
|
|
try:
|
|
ents = await backend.entity_list(layer_filter="DIM", limit=5000)
|
|
except Exception:
|
|
return []
|
|
dim_points: list[tuple[str, tuple[float, float]]] = []
|
|
for e in ents:
|
|
if e.type not in _DIM_TYPES and "DIM" not in e.type:
|
|
continue
|
|
ip = (e.properties.get("text_position")
|
|
or e.properties.get("defpoint")
|
|
or e.properties.get("insertion_point"))
|
|
if ip and len(ip) >= 2:
|
|
dim_points.append((e.handle, (float(ip[0]), float(ip[1]))))
|
|
issues: list[Issue] = []
|
|
seen: set[frozenset[str]] = set()
|
|
for i, (h1, p1) in enumerate(dim_points):
|
|
for j in range(i + 1, len(dim_points)):
|
|
h2, p2 = dim_points[j]
|
|
d = math.hypot(p1[0] - p2[0], p1[1] - p2[1])
|
|
if d <= tol:
|
|
key = frozenset((h1, h2))
|
|
if key in seen:
|
|
continue
|
|
seen.add(key)
|
|
issues.append(Issue(
|
|
severity="warning",
|
|
focus="dim_overlap",
|
|
message=f"Dimensions {h1} and {h2} are {d:.2f} mm apart — likely overlapping.",
|
|
handles=[h1, h2],
|
|
))
|
|
return issues
|
|
|
|
|
|
_FOCUS_DISPATCH = {
|
|
"iso128": _check_iso128,
|
|
"layer_color": _check_layer_color,
|
|
"dim_overlap": _check_dim_overlap,
|
|
"untrimmed_corner": _check_untrimmed_corner,
|
|
"duplicate_entities": _check_duplicate_entities,
|
|
"construction_left": _check_construction_left,
|
|
}
|
|
|
|
|
|
async def run_critique(
|
|
backend: AutoCADBackend,
|
|
focus: list[CritiqueFocus] | None = None,
|
|
) -> list[Issue]:
|
|
"""Dispatch each requested focus check and return aggregated issues."""
|
|
foci = list(focus) if focus is not None else list(ALL_CRITIQUE_FOCUSES)
|
|
issues: list[Issue] = []
|
|
for f in foci:
|
|
check = _FOCUS_DISPATCH.get(f)
|
|
if check is None:
|
|
issues.append(Issue(
|
|
severity="warning",
|
|
focus=f, # type: ignore[arg-type]
|
|
message=f"Unknown critique focus '{f}' (closed enum).",
|
|
))
|
|
continue
|
|
issues.extend(await check(backend))
|
|
return issues
|