python-cad-tools 0.1.0rc1__py3-none-any.whl

python_cad_tools/drawings/__init__.py

@@ -0,0 +1,124 @@
+"""Public format-neutral drawing annotation contracts."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+type Point2 = tuple[float, float]
+type Direction = Literal["up", "down", "left", "right"]
+type DrawingStyleToken = Literal[
+    "annotation-line",
+    "annotation-text",
+    "annotation-section",
+    "annotation-elevation",
+    "annotation-table",
+]
+
+
+@dataclass(frozen=True, slots=True)
+class DrawingSheet:
+    sheet_id: str
+    view_id: Literal["plan", "front", "side", "section"]
+    origin_mm: tuple[float, float, float]
+    x_axis: tuple[float, float, float]
+    y_axis: tuple[float, float, float]
+    projected_bounds_mm: tuple[float, float, float, float]
+
+
+@dataclass(frozen=True, slots=True)
+class Line:
+    id: str
+    sheet_id: str
+    start: Point2
+    end: Point2
+    style: DrawingStyleToken
+
+
+@dataclass(frozen=True, slots=True)
+class Polyline:
+    id: str
+    sheet_id: str
+    points: tuple[Point2, ...]
+    closed: bool
+    style: DrawingStyleToken
+
+
+@dataclass(frozen=True, slots=True)
+class Text:
+    id: str
+    sheet_id: str
+    position: Point2
+    value: str
+    height_mm: float
+    rotation_degrees: float
+    style: DrawingStyleToken
+
+
+@dataclass(frozen=True, slots=True)
+class SectionCallout:
+    id: str
+    sheet_id: str
+    start: Point2
+    end: Point2
+    reference_sheet_id: str
+    label: str
+    view_direction: Direction
+
+
+@dataclass(frozen=True, slots=True)
+class ElevationMarker:
+    id: str
+    sheet_id: str
+    position: Point2
+    reference_sheet_id: str
+    label: str
+    direction: Direction
+
+
+@dataclass(frozen=True, slots=True)
+class TableRow:
+    id: str
+    cells: tuple[str, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class Table:
+    id: str
+    sheet_id: str
+    position: Point2
+    title: str
+    columns: tuple[str, ...]
+    rows: tuple[TableRow, ...]
+
+
+type AnnotationPrimitive = Line | Polyline | Text | SectionCallout | ElevationMarker | Table
+
+
+@dataclass(frozen=True, slots=True)
+class SheetAnnotations:
+    sheet_id: str
+    annotations: tuple[AnnotationPrimitive, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class DrawingAnnotationSet:
+    provider_id: str
+    sheets: tuple[SheetAnnotations, ...]
+
+
+__all__ = [
+    "Direction",
+    "DrawingAnnotationSet",
+    "DrawingSheet",
+    "DrawingStyleToken",
+    "ElevationMarker",
+    "Line",
+    "Point2",
+    "Polyline",
+    "SectionCallout",
+    "SheetAnnotations",
+    "Table",
+    "TableRow",
+    "Text",
+]

python_cad_tools/drawings/_catalog.py

@@ -0,0 +1,79 @@
+"""Standard drawing sheet catalog and orthographic projection helpers."""
+
+from __future__ import annotations
+
+from itertools import product
+from math import isfinite
+from typing import Any, Literal, cast
+
+from ..exceptions import ModelValidationError
+from ..geometry import bounds
+from . import DrawingSheet
+
+_SHEET_BASES: tuple[
+    tuple[
+        str,
+        Literal["plan", "front", "side", "section"],
+        tuple[float, float, float],
+        tuple[float, float, float],
+        tuple[float, float, float],
+    ],
+    ...,
+] = (
+    ("A-101", "plan", (0.0, 0.0, 0.0), (1.0, 0.0, 0.0), (0.0, 1.0, 0.0)),
+    ("A-201", "front", (0.0, 0.0, 0.0), (1.0, 0.0, 0.0), (0.0, 0.0, 1.0)),
+    ("A-202", "side", (0.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)),
+    ("A-301", "section", (0.0, 0.0, 0.0), (1.0, 0.0, 0.0), (0.0, 0.0, 1.0)),
+)
+
+
+def standard_sheet_catalog(model: Any) -> tuple[DrawingSheet, ...]:
+    physical = [
+        element
+        for element in model.walk()
+        if element.physical and element.visible and "drawings" in element.export_formats
+    ]
+    if not physical:
+        raise ModelValidationError("Drawing-inclusive operations require at least one visible physical drawing element")
+    sheets = []
+    for sheet_id, view_id, origin, x_axis, y_axis in _SHEET_BASES:
+        rectangles = [project_bounds(bounds(element.geometry), origin, x_axis, y_axis) for element in physical]
+        projected = (
+            min(item[0] for item in rectangles),
+            min(item[1] for item in rectangles),
+            max(item[2] for item in rectangles),
+            max(item[3] for item in rectangles),
+        )
+        if (
+            not all(isfinite(value) for value in projected)
+            or projected[0] >= projected[2]
+            or projected[1] >= projected[3]
+        ):
+            raise ModelValidationError(f"Drawing sheet {sheet_id!r} has invalid projected geometry bounds")
+        sheets.append(DrawingSheet(sheet_id, view_id, origin, x_axis, y_axis, projected))
+    return tuple(sheets)
+
+
+def project_bounds(
+    bounds_mm: tuple[float, float, float, float, float, float],
+    origin: tuple[float, float, float],
+    x_axis: tuple[float, float, float],
+    y_axis: tuple[float, float, float],
+) -> tuple[float, float, float, float]:
+    projected = []
+    for point in product(*((bounds_mm[index], bounds_mm[index + 3]) for index in range(3))):
+        relative = cast(tuple[float, float, float], tuple(point[index] - origin[index] for index in range(3)))
+        projected.append((dot(relative, x_axis), dot(relative, y_axis)))
+    return (
+        min(point[0] for point in projected),
+        min(point[1] for point in projected),
+        max(point[0] for point in projected),
+        max(point[1] for point in projected),
+    )
+
+
+def dot(left: tuple[float, float, float], right: tuple[float, float, float]) -> float:
+    return sum(left[index] * right[index] for index in range(3))
+
+
+__all__: list[str] = []

python_cad_tools/drawings/_validation.py

@@ -0,0 +1,238 @@
+"""Strict validation for public neutral drawing values."""
+
+from __future__ import annotations
+
+import re
+from math import isclose, isfinite
+from typing import Any
+
+from ..exceptions import ModelValidationError
+from . import (
+    DrawingAnnotationSet,
+    DrawingSheet,
+    ElevationMarker,
+    Line,
+    Polyline,
+    SectionCallout,
+    SheetAnnotations,
+    Table,
+    TableRow,
+    Text,
+)
+
+_STABLE_ID = re.compile(r"[A-Za-z0-9._-]+\Z", re.ASCII)
+_STYLE_TOKENS = {
+    "annotation-line",
+    "annotation-text",
+    "annotation-section",
+    "annotation-elevation",
+    "annotation-table",
+}
+_DIRECTIONS = {"up", "down", "left", "right"}
+_PRIMITIVE_TYPES = (Line, Polyline, Text, SectionCallout, ElevationMarker, Table)
+
+
+def validate_annotation_set(value: Any, sheets: tuple[DrawingSheet, ...]) -> DrawingAnnotationSet:
+    if not isinstance(value, DrawingAnnotationSet):
+        raise ModelValidationError(
+            f"Drawing annotation provider returned {type(value).__name__}; expected DrawingAnnotationSet"
+        )
+    _stable(value.provider_id, "annotation provider ID")
+    if not isinstance(value.sheets, tuple):
+        raise ModelValidationError("DrawingAnnotationSet.sheets must be a tuple")
+    sheet_catalog = {sheet.sheet_id: sheet for sheet in sheets}
+    _validate_sheet_catalog(sheets)
+    seen_sheet_records: set[str] = set()
+    seen_ids: set[str] = set()
+    for sheet_record in value.sheets:
+        if not isinstance(sheet_record, SheetAnnotations):
+            raise ModelValidationError("DrawingAnnotationSet.sheets must contain only SheetAnnotations values")
+        if sheet_record.sheet_id not in sheet_catalog:
+            raise ModelValidationError(f"Annotations reference unknown sheet: {sheet_record.sheet_id!r}")
+        if sheet_record.sheet_id in seen_sheet_records:
+            raise ModelValidationError(f"Duplicate SheetAnnotations record: {sheet_record.sheet_id!r}")
+        seen_sheet_records.add(sheet_record.sheet_id)
+        if not isinstance(sheet_record.annotations, tuple):
+            raise ModelValidationError("SheetAnnotations.annotations must be a tuple")
+        for annotation in sheet_record.annotations:
+            if not isinstance(annotation, _PRIMITIVE_TYPES):
+                raise ModelValidationError(f"Unsupported drawing annotation primitive: {type(annotation).__name__}")
+            _validate_annotation(annotation, sheet_record.sheet_id, sheet_catalog, seen_ids)
+            for child_id in _compound_child_ids(annotation):
+                if child_id in seen_ids:
+                    raise ModelValidationError(f"Duplicate annotation or compound child ID: {child_id!r}")
+                seen_ids.add(child_id)
+    return value
+
+
+def _validate_sheet_catalog(sheets: tuple[DrawingSheet, ...]) -> None:
+    if not isinstance(sheets, tuple) or not sheets:
+        raise ModelValidationError("DrawingContext.sheets must be a nonempty tuple")
+    seen: set[str] = set()
+    for sheet in sheets:
+        if not isinstance(sheet, DrawingSheet):
+            raise ModelValidationError("DrawingContext.sheets contains a non-DrawingSheet value")
+        _stable(sheet.sheet_id, "drawing sheet ID")
+        if sheet.sheet_id in seen:
+            raise ModelValidationError(f"Duplicate drawing sheet ID: {sheet.sheet_id!r}")
+        seen.add(sheet.sheet_id)
+        if sheet.view_id not in {"plan", "front", "side", "section"}:
+            raise ModelValidationError(f"Unsupported drawing view ID: {sheet.view_id!r}")
+        for label, vector in (("origin", sheet.origin_mm), ("x_axis", sheet.x_axis), ("y_axis", sheet.y_axis)):
+            if not _finite_tuple(vector, 3):
+                raise ModelValidationError(f"Drawing sheet {sheet.sheet_id!r} has invalid {label}")
+        x_length = sum(value * value for value in sheet.x_axis) ** 0.5
+        y_length = sum(value * value for value in sheet.y_axis) ** 0.5
+        product = sum(left * right for left, right in zip(sheet.x_axis, sheet.y_axis, strict=True))
+        if not isclose(x_length, 1.0, abs_tol=1e-9) or not isclose(y_length, 1.0, abs_tol=1e-9):
+            raise ModelValidationError(f"Drawing sheet {sheet.sheet_id!r} axes must be unit vectors")
+        if not isclose(product, 0.0, abs_tol=1e-9):
+            raise ModelValidationError(f"Drawing sheet {sheet.sheet_id!r} axes must be orthogonal")
+        if not _finite_tuple(sheet.projected_bounds_mm, 4):
+            raise ModelValidationError(f"Drawing sheet {sheet.sheet_id!r} has invalid projected bounds")
+        min_x, min_y, max_x, max_y = sheet.projected_bounds_mm
+        if min_x >= max_x or min_y >= max_y:
+            raise ModelValidationError(f"Drawing sheet {sheet.sheet_id!r} projected bounds must have positive area")
+
+
+def _validate_annotation(
+    annotation: Any,
+    containing_sheet: str,
+    sheets: dict[str, DrawingSheet],
+    seen_ids: set[str],
+) -> None:
+    _stable(annotation.id, "annotation ID")
+    if annotation.id in seen_ids:
+        raise ModelValidationError(f"Duplicate annotation ID: {annotation.id!r}")
+    seen_ids.add(annotation.id)
+    if annotation.sheet_id != containing_sheet:
+        raise ModelValidationError(
+            f"Annotation {annotation.id!r} sheet_id {annotation.sheet_id!r} does not match its container"
+        )
+    if annotation.sheet_id not in sheets:
+        raise ModelValidationError(f"Annotation {annotation.id!r} references unknown sheet {annotation.sheet_id!r}")
+    if isinstance(annotation, Line):
+        _point(annotation.start, annotation.id)
+        _point(annotation.end, annotation.id)
+        if annotation.start == annotation.end:
+            raise ModelValidationError(f"Line annotation {annotation.id!r} must be nonzero")
+        _style(annotation.style, annotation.id)
+    elif isinstance(annotation, Polyline):
+        if not isinstance(annotation.points, tuple) or len(annotation.points) < (3 if annotation.closed else 2):
+            raise ModelValidationError(f"Polyline annotation {annotation.id!r} has too few points")
+        for point in annotation.points:
+            _point(point, annotation.id)
+        if len(set(annotation.points)) < 2:
+            raise ModelValidationError(f"Polyline annotation {annotation.id!r} must contain distinct points")
+        if type(annotation.closed) is not bool:
+            raise ModelValidationError(f"Polyline annotation {annotation.id!r} closed must be bool")
+        _style(annotation.style, annotation.id)
+    elif isinstance(annotation, Text):
+        _point(annotation.position, annotation.id)
+        _text(annotation.value, annotation.id)
+        if not _finite_number(annotation.height_mm) or annotation.height_mm <= 0:
+            raise ModelValidationError(f"Text annotation {annotation.id!r} height_mm must be finite and positive")
+        if not _finite_number(annotation.rotation_degrees):
+            raise ModelValidationError(f"Text annotation {annotation.id!r} rotation_degrees must be finite")
+        _style(annotation.style, annotation.id)
+    elif isinstance(annotation, SectionCallout):
+        _point(annotation.start, annotation.id)
+        _point(annotation.end, annotation.id)
+        if annotation.start == annotation.end:
+            raise ModelValidationError(f"Section callout {annotation.id!r} must have a nonzero line")
+        _reference(annotation.reference_sheet_id, annotation.id, sheets)
+        _text(annotation.label, annotation.id)
+        _direction(annotation.view_direction, annotation.id)
+        dx = annotation.end[0] - annotation.start[0]
+        dy = annotation.end[1] - annotation.start[1]
+        if annotation.view_direction in {"left", "right"} and not isclose(dx, 0.0, abs_tol=1e-9):
+            raise ModelValidationError(f"Section callout {annotation.id!r} must be orthogonal to its view_direction")
+        if annotation.view_direction in {"up", "down"} and not isclose(dy, 0.0, abs_tol=1e-9):
+            raise ModelValidationError(f"Section callout {annotation.id!r} must be orthogonal to its view_direction")
+    elif isinstance(annotation, ElevationMarker):
+        _point(annotation.position, annotation.id)
+        _reference(annotation.reference_sheet_id, annotation.id, sheets)
+        _text(annotation.label, annotation.id)
+        _direction(annotation.direction, annotation.id)
+    elif isinstance(annotation, Table):
+        _point(annotation.position, annotation.id)
+        _text(annotation.title, annotation.id)
+        if not isinstance(annotation.columns, tuple) or not annotation.columns:
+            raise ModelValidationError(f"Table annotation {annotation.id!r} must have columns")
+        for column in annotation.columns:
+            _text(column, annotation.id)
+        if not isinstance(annotation.rows, tuple):
+            raise ModelValidationError(f"Table annotation {annotation.id!r} rows must be a tuple")
+        row_ids: set[str] = set()
+        for row in annotation.rows:
+            if not isinstance(row, TableRow):
+                raise ModelValidationError(f"Table annotation {annotation.id!r} contains a non-TableRow value")
+            _stable(row.id, f"row ID in table {annotation.id!r}")
+            if row.id in row_ids:
+                raise ModelValidationError(f"Duplicate drawing table row ID: {row.id!r}")
+            row_ids.add(row.id)
+            if not isinstance(row.cells, tuple) or len(row.cells) != len(annotation.columns):
+                raise ModelValidationError(f"Table row {row.id!r} cell count does not match its columns")
+            for cell in row.cells:
+                _text(cell, row.id)
+
+
+def _stable(value: object, label: str) -> None:
+    if not isinstance(value, str) or _STABLE_ID.fullmatch(value) is None:
+        raise ModelValidationError(f"{label} must match [A-Za-z0-9._-]+")
+
+
+def _style(value: object, annotation_id: str) -> None:
+    if value not in _STYLE_TOKENS:
+        raise ModelValidationError(f"Annotation {annotation_id!r} has unsupported style token {value!r}")
+
+
+def _direction(value: object, annotation_id: str) -> None:
+    if value not in _DIRECTIONS:
+        raise ModelValidationError(f"Annotation {annotation_id!r} has unsupported direction {value!r}")
+
+
+def _reference(value: object, annotation_id: str, sheets: dict[str, DrawingSheet]) -> None:
+    if not isinstance(value, str) or value not in sheets:
+        raise ModelValidationError(f"Annotation {annotation_id!r} references unknown sheet {value!r}")
+
+
+def _point(value: object, annotation_id: str) -> None:
+    if not _finite_tuple(value, 2):
+        raise ModelValidationError(f"Annotation {annotation_id!r} contains an invalid point")
+
+
+def _text(value: object, annotation_id: str) -> None:
+    if (
+        not isinstance(value, str)
+        or not value.strip()
+        or any(ord(character) < 32 or ord(character) == 127 for character in value)
+    ):
+        raise ModelValidationError(f"Annotation {annotation_id!r} contains invalid text")
+
+
+def _finite_tuple(value: object, length: int) -> bool:
+    return isinstance(value, tuple) and len(value) == length and all(_finite_number(item) for item in value)
+
+
+def _finite_number(value: object) -> bool:
+    return isinstance(value, (int, float)) and not isinstance(value, bool) and isfinite(value)
+
+
+def _compound_child_ids(annotation: Any) -> tuple[str, ...]:
+    if isinstance(annotation, SectionCallout):
+        suffixes = ("line", "arrow.start", "arrow.end", "label.start", "label.end")
+        return tuple(f"{annotation.id}.{suffix}" for suffix in suffixes)
+    if isinstance(annotation, ElevationMarker):
+        return tuple(f"{annotation.id}.{suffix}" for suffix in ("outline", "pointer", "label"))
+    if isinstance(annotation, Table):
+        ids = [f"{annotation.id}.title", f"{annotation.id}.border"]
+        ids.extend(f"{annotation.id}.header.{index}" for index in range(len(annotation.columns)))
+        for row in annotation.rows:
+            ids.extend(f"{annotation.id}.row.{row.id}.cell.{index}" for index in range(len(annotation.columns)))
+            ids.append(f"{annotation.id}.row.{row.id}.separator")
+        return tuple(ids)
+    return ()
+
+
+__all__: list[str] = []

python_cad_tools/elements.py

@@ -0,0 +1,121 @@
+"""Typed intermediate model shared by Python CAD Tools exporters."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+Color = tuple[float, float, float]
+GeometryKind = Literal["solid", "shell", "wire", "edge", "reference"]
+
+
+@dataclass(frozen=True, slots=True)
+class MaterialSpec:
+    id: str
+    name: str
+    category: str
+    color_rgb: Color
+    density_kg_m3: float | None = None
+    properties: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True)
+class Placement:
+    translation_mm: tuple[float, float, float] = (0.0, 0.0, 0.0)
+    rotation_deg_xyz: tuple[float, float, float] = (0.0, 0.0, 0.0)
+
+
+@dataclass(frozen=True, slots=True)
+class Dimensions:
+    length_mm: float | None = None
+    width_mm: float | None = None
+    height_mm: float | None = None
+    radius_mm: float | None = None
+    extras: dict[str, float] = field(default_factory=dict)
+
+    def values(self) -> tuple[float, ...]:
+        primary = (self.length_mm, self.width_mm, self.height_mm, self.radius_mm)
+        return tuple(value for value in primary if value is not None) + tuple(
+            self.extras[key] for key in sorted(self.extras)
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class IfcMapping:
+    ifc_class: str | None
+    predefined_type: str | None = None
+    exclude_reason: str | None = None
+
+
+@dataclass(slots=True)
+class DesignElement:
+    id: str
+    name: str
+    category: str
+    geometry: Any
+    geometry_kind: GeometryKind
+    placement: Placement = field(default_factory=Placement)
+    dimensions: Dimensions = field(default_factory=Dimensions)
+    material: MaterialSpec | None = None
+    color_rgb: Color | None = None
+    ifc_mapping: IfcMapping = field(default_factory=lambda: IfcMapping(None, exclude_reason="not mapped"))
+    storey: str | None = None
+    tags: set[str] = field(default_factory=set)
+    properties: dict[str, Any] = field(default_factory=dict)
+    children: list[DesignElement] = field(default_factory=list)
+    visible: bool = True
+    export_formats: set[str] = field(default_factory=lambda: {"step", "ifc", "glb", "drawings", "quantities"})
+    source_module: str = "model"
+    physical: bool = True
+    parent_id: str | None = None
+
+    def walk(self) -> Iterator[DesignElement]:
+        yield self
+        for child in sorted(self.children, key=lambda item: item.id):
+            yield from child.walk()
+
+
+@dataclass(slots=True)
+class DesignModel:
+    id: str
+    name: str
+    artifact_stem: str
+    elements: list[DesignElement]
+    coordinate_system: str = "right-handed; X right, Y depth/away, Z up; millimetres"
+    metadata: dict[str, Any] = field(default_factory=dict)
+    validators: list[Any] = field(default_factory=list)
+
+    def walk(self) -> Iterator[DesignElement]:
+        for element in sorted(self.elements, key=lambda item: item.id):
+            yield from element.walk()
+
+    def get(self, stable_id: str) -> DesignElement:
+        for element in self.walk():
+            if element.id == stable_id:
+                return element
+        raise KeyError(stable_id)
+
+
+@dataclass(frozen=True, slots=True)
+class QuantityRecord:
+    element_id: str
+    category: str
+    material_id: str | None
+    count: int
+    area_mm2: float | None
+    volume_mm3: float | None
+    mass_kg: float | None
+    provenance: str
+
+
+__all__ = [
+    "Color",
+    "DesignElement",
+    "DesignModel",
+    "Dimensions",
+    "GeometryKind",
+    "IfcMapping",
+    "MaterialSpec",
+    "Placement",
+]

python_cad_tools/exceptions.py

@@ -0,0 +1,45 @@
+"""Public exception hierarchy for Python CAD Tools."""
+
+
+class CadToolsError(RuntimeError):
+    """Base class for actionable Python CAD Tools failures."""
+
+
+class ProjectConfigError(CadToolsError):
+    """Project configuration or entry-point loading is invalid."""
+
+
+class ModelValidationError(CadToolsError):
+    """The project model violates a public model contract."""
+
+
+class BuildExportError(CadToolsError):
+    """An exporter failed to create or validate an artifact."""
+
+
+class ArtifactIntegrityError(CadToolsError):
+    """Generated artifact bytes do not match their inventory."""
+
+
+class UnsafePathError(CadToolsError):
+    """A configured or requested path escapes the project boundary."""
+
+
+class BuildLockedError(CadToolsError):
+    """A project operation cannot run because execution is already active."""
+
+
+class SiteError(CadToolsError):
+    """Viewer-site preparation or serving failed."""
+
+
+__all__ = [
+    "ArtifactIntegrityError",
+    "BuildExportError",
+    "BuildLockedError",
+    "CadToolsError",
+    "ModelValidationError",
+    "ProjectConfigError",
+    "SiteError",
+    "UnsafePathError",
+]

python_cad_tools/exporters/__init__.py

@@ -0,0 +1,8 @@
+"""Format exporters for the shared Python CAD Tools design model."""
+
+from .glb import GlbExporter
+from .ifc import IfcExporter
+from .quantities import QuantityExporter
+from .step import StepExporter
+
+__all__ = ["GlbExporter", "IfcExporter", "QuantityExporter", "StepExporter"]

python_cad_tools/exporters/base.py

@@ -0,0 +1,24 @@
+"""Common Python CAD Tools exporter protocol and helpers."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Protocol
+
+from ..elements import DesignElement, DesignModel
+
+
+class Exporter(Protocol):
+    name: str
+
+    def export(self, model: DesignModel, output_dir: Path) -> list[Path]: ...
+
+
+def selected_elements(model: DesignModel, format_name: str, *, physical_only: bool = False) -> list[DesignElement]:
+    return [
+        element
+        for element in model.walk()
+        if element.visible
+        and format_name in element.export_formats
+        and (element.physical or not physical_only)
+    ]

python_cad_tools/exporters/drawings/__init__.py

@@ -0,0 +1,5 @@
+"""Python CAD Tools conceptual drawing scenes and vector writers."""
+
+from .model import DrawingExporter
+
+__all__ = ["DrawingExporter"]