gdsdiff 0.1.0__py3-none-any.whl

gdsdiff/hierarchy.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass, field
+from typing import Iterable
+
+from .config import LayerSpec
+from .geometry import normalize_polygon_points
+from .spatial import BBox, bbox_union
+
+
+@dataclass(frozen=True)
+class CellIdentity:
+    digest: str
+    local_polygon_count: int
+    reference_count: int
+
+
+@dataclass(frozen=True)
+class ReferenceChange:
+    kind: str
+    bbox: BBox
+    old_child_digest: str | None = None
+    new_child_digest: str | None = None
+
+
+@dataclass(frozen=True)
+class HierarchyCompareResult:
+    old_top: str
+    new_top: str
+    old_digest: str
+    new_digest: str
+    identical: bool
+    matched_subtree_count: int
+    changed_references: tuple[ReferenceChange, ...] = field(default_factory=tuple)
+
+
+def compare_hierarchy(
+    old_lib: gdstk.Library,
+    new_lib: gdstk.Library,
+    *,
+    old_top: str | None = None,
+    new_top: str | None = None,
+) -> HierarchyCompareResult:
+    old_cell = _select_top(old_lib, old_top)
+    new_cell = _select_top(new_lib, new_top)
+    old_cache: dict[int, CellIdentity] = {}
+    new_cache: dict[int, CellIdentity] = {}
+    old_identity = canonical_cell_identity(old_cell, old_cache)
+    new_identity = canonical_cell_identity(new_cell, new_cache)
+    matched: set[tuple[str, str]] = set()
+    changes: list[ReferenceChange] = []
+    _compare_cells(old_cell, new_cell, old_cache, new_cache, matched, changes)
+    return HierarchyCompareResult(
+        old_top=old_cell.name,
+        new_top=new_cell.name,
+        old_digest=old_identity.digest,
+        new_digest=new_identity.digest,
+        identical=old_identity.digest == new_identity.digest,
+        matched_subtree_count=len(matched),
+        changed_references=tuple(sorted(changes, key=lambda item: (item.kind, item.bbox, item.old_child_digest or "", item.new_child_digest or ""))),
+    )
+
+
+def canonical_cell_identity(cell: gdstk.Cell, cache: dict[int, CellIdentity] | None = None) -> CellIdentity:
+    cache = cache if cache is not None else {}
+    return _canonical_cell_identity(cell, cache, set())
+
+
+def _canonical_cell_identity(cell: gdstk.Cell, cache: dict[int, CellIdentity], visiting: set[int]) -> CellIdentity:
+    key = id(cell)
+    if key in cache:
+        return cache[key]
+    if key in visiting:
+        raise ValueError(f"hierarchy cycle detected at cell {cell.name!r}")
+    visiting.add(key)
+    polygon_records = sorted(_polygon_record(polygon) for polygon in cell.polygons)
+    reference_records = []
+    for reference in cell.references:
+        child = _reference_cell(reference)
+        child_identity = _canonical_cell_identity(child, cache, visiting)
+        reference_records.append((_reference_transform_record(reference), child_identity.digest))
+    reference_records.sort()
+    digest = _digest_records(("cell", tuple(polygon_records), tuple(reference_records)))
+    visiting.remove(key)
+    identity = CellIdentity(
+        digest=digest,
+        local_polygon_count=len(polygon_records),
+        reference_count=len(reference_records),
+    )
+    cache[key] = identity
+    return identity
+
+
+def _compare_cells(
+    old_cell: gdstk.Cell,
+    new_cell: gdstk.Cell,
+    old_cache: dict[int, CellIdentity],
+    new_cache: dict[int, CellIdentity],
+    matched: set[tuple[str, str]],
+    changes: list[ReferenceChange],
+) -> None:
+    old_identity = old_cache[id(old_cell)]
+    new_identity = new_cache[id(new_cell)]
+    if old_identity.digest == new_identity.digest:
+        matched.add((old_identity.digest, new_identity.digest))
+        return
+    old_refs = _references_by_transform(old_cell, old_cache)
+    new_refs = _references_by_transform(new_cell, new_cache)
+    for transform in sorted(set(old_refs) | set(new_refs)):
+        old_group = old_refs.get(transform, [])
+        new_group = new_refs.get(transform, [])
+        paired_count = min(len(old_group), len(new_group))
+        for index in range(paired_count):
+            old_ref, old_digest = old_group[index]
+            new_ref, new_digest = new_group[index]
+            if old_digest == new_digest:
+                matched.add((old_digest, new_digest))
+                continue
+            changes.append(
+                ReferenceChange(
+                    kind="changed",
+                    bbox=_reference_bbox_union((old_ref, new_ref)),
+                    old_child_digest=old_digest,
+                    new_child_digest=new_digest,
+                )
+            )
+            _compare_cells(_reference_cell(old_ref), _reference_cell(new_ref), old_cache, new_cache, matched, changes)
+        for old_ref, old_digest in old_group[paired_count:]:
+            changes.append(ReferenceChange(kind="removed", bbox=_reference_bbox(old_ref), old_child_digest=old_digest))
+        for new_ref, new_digest in new_group[paired_count:]:
+            changes.append(ReferenceChange(kind="added", bbox=_reference_bbox(new_ref), new_child_digest=new_digest))
+
+
+def _references_by_transform(cell: gdstk.Cell, cache: dict[int, CellIdentity]) -> dict[tuple[object, ...], list[tuple[gdstk.Reference, str]]]:
+    grouped: dict[tuple[object, ...], list[tuple[gdstk.Reference, str]]] = {}
+    for reference in cell.references:
+        child = _reference_cell(reference)
+        digest = cache[id(child)].digest
+        grouped.setdefault(_reference_transform_record(reference), []).append((reference, digest))
+    for group in grouped.values():
+        group.sort(key=lambda item: item[1])
+    return grouped
+
+
+def _polygon_record(polygon: gdstk.Polygon) -> tuple[object, ...]:
+    points = normalize_polygon_points([(_float_key(point[0]), _float_key(point[1])) for point in polygon.points])
+    if points:
+        rotations = [points[index:] + points[:index] for index in range(len(points))]
+        reverse = tuple(reversed(points))
+        rotations.extend(reverse[index:] + reverse[:index] for index in range(len(reverse)))
+        points = min(rotations)
+    return (LayerSpec(polygon.layer, polygon.datatype), points)
+
+
+def _reference_transform_record(reference: gdstk.Reference) -> tuple[object, ...]:
+    return (
+        _float_pair(reference.origin),
+        _float_key(reference.rotation or 0),
+        _float_key(reference.magnification if reference.magnification is not None else 1),
+        bool(reference.x_reflection),
+        _repetition_record(reference.repetition),
+    )
+
+
+def _repetition_record(repetition) -> tuple[object, ...] | None:
+    if repetition is None or repetition.size == 1:
+        return None
+    return tuple(sorted(_float_pair(offset) for offset in repetition.get_offsets()))
+
+
+def _reference_cell(reference: gdstk.Reference) -> gdstk.Cell:
+    if reference.cell is None:
+        raise ValueError(f"unresolved reference to {reference.cell_name!r}")
+    return reference.cell
+
+
+def _reference_bbox(reference: gdstk.Reference) -> BBox:
+    bbox = reference.bounding_box()
+    if bbox is None:
+        return (0, 0, 0, 0)
+    return (
+        int(_float_key(bbox[0][0])),
+        int(_float_key(bbox[0][1])),
+        int(_float_key(bbox[1][0])),
+        int(_float_key(bbox[1][1])),
+    )
+
+
+def _reference_bbox_union(references: Iterable[gdstk.Reference]) -> BBox:
+    return bbox_union(tuple(_reference_bbox(reference) for reference in references))
+
+
+def _select_top(lib: gdstk.Library, name: str | None) -> gdstk.Cell:
+    if name is not None:
+        for cell in lib.cells:
+            if cell.name == name:
+                return cell
+        raise ValueError(f"top cell {name!r} not found")
+    tops = lib.top_level()
+    if len(tops) != 1:
+        raise ValueError("library must have exactly one top cell when top is not supplied")
+    return tops[0]
+
+
+def _float_key(value: float) -> int:
+    return int(round(float(value) * 1_000_000_000))
+
+
+def _float_pair(values) -> tuple[int, int]:
+    return (_float_key(values[0]), _float_key(values[1]))
+
+
+def _digest_records(records: object) -> str:
+    return hashlib.sha256(repr(records).encode("utf-8")).hexdigest()

gdsdiff/hierarchy_extract.py

@@ -0,0 +1,263 @@
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from decimal import Decimal
+from pathlib import Path
+from typing import Iterable
+
+import gdstk
+import numpy as np
+
+from .config import LayerSpec, parse_layer_selector
+from .gds_metadata import decimal_from_number
+from .geometry import LayerTable, PolygonBuffer, normalize_polygon_points, polygon_bbox, polygon_flags
+from .grid import snap_to_grid
+from .inventory import select_top_cell
+from .spatial import BBox, bboxes_intersect
+
+
+@dataclass(frozen=True)
+class WindowedHierarchyStats:
+    visited_cell_count: int
+    considered_reference_instance_count: int
+    pruned_reference_instance_count: int
+    emitted_polygon_count: int
+    raw_local_polygon_count: int
+    max_snap_error_dbu: Decimal
+
+    def to_json(self) -> dict[str, object]:
+        return {
+            "visited_cell_count": self.visited_cell_count,
+            "considered_reference_instance_count": self.considered_reference_instance_count,
+            "pruned_reference_instance_count": self.pruned_reference_instance_count,
+            "emitted_polygon_count": self.emitted_polygon_count,
+            "raw_local_polygon_count": self.raw_local_polygon_count,
+            "max_snap_error_dbu": str(self.max_snap_error_dbu),
+        }
+
+
+@dataclass(frozen=True)
+class WindowedHierarchyExtractionResult:
+    top_name: str
+    window_bbox: BBox
+    buffer: PolygonBuffer
+    stats: WindowedHierarchyStats
+
+
+@dataclass(frozen=True)
+class _Transform:
+    a: float = 1.0
+    b: float = 0.0
+    c: float = 0.0
+    d: float = 1.0
+    tx: float = 0.0
+    ty: float = 0.0
+
+    def apply(self, x: float, y: float) -> tuple[float, float]:
+        return self.a * x + self.b * y + self.tx, self.c * x + self.d * y + self.ty
+
+    def compose(self, child: "_Transform") -> "_Transform":
+        return _Transform(
+            a=self.a * child.a + self.b * child.c,
+            b=self.a * child.b + self.b * child.d,
+            c=self.c * child.a + self.d * child.c,
+            d=self.c * child.b + self.d * child.d,
+            tx=self.a * child.tx + self.b * child.ty + self.tx,
+            ty=self.c * child.tx + self.d * child.ty + self.ty,
+        )
+
+
+def extract_hierarchy_window_from_gds(
+    path: str | Path,
+    *,
+    window_bbox: BBox,
+    top_name: str | None = None,
+    layers: str | LayerSpec | Iterable[str | tuple[int, int] | LayerSpec] = "all",
+    meters_per_dbu: Decimal | str | float | None = None,
+) -> WindowedHierarchyExtractionResult:
+    lib = gdstk.read_gds(str(path))
+    grid = decimal_from_number(meters_per_dbu) if meters_per_dbu is not None else decimal_from_number(lib.precision)
+    return extract_hierarchy_window(lib, window_bbox=window_bbox, top_name=top_name, layers=layers, meters_per_dbu=grid)
+
+
+def extract_hierarchy_window(
+    lib: gdstk.Library,
+    *,
+    window_bbox: BBox,
+    top_name: str | None = None,
+    layers: str | LayerSpec | Iterable[str | tuple[int, int] | LayerSpec] = "all",
+    meters_per_dbu: Decimal | str | float | None = None,
+) -> WindowedHierarchyExtractionResult:
+    top = select_top_cell(lib, top_name=top_name)
+    grid = decimal_from_number(meters_per_dbu) if meters_per_dbu is not None else decimal_from_number(lib.precision)
+    unit = decimal_from_number(lib.unit)
+    selected_layers = _selected_layers_or_none(layers)
+    extractor = _WindowExtractor(unit=unit, grid=grid, selected_layers=selected_layers, window_bbox=window_bbox)
+    extractor.traverse_cell(top, _Transform(), set())
+    return WindowedHierarchyExtractionResult(
+        top_name=top.name,
+        window_bbox=window_bbox,
+        buffer=extractor.to_buffer(),
+        stats=WindowedHierarchyStats(
+            visited_cell_count=extractor.visited_cell_count,
+            considered_reference_instance_count=extractor.considered_reference_instance_count,
+            pruned_reference_instance_count=extractor.pruned_reference_instance_count,
+            emitted_polygon_count=len(extractor.polygons),
+            raw_local_polygon_count=extractor.raw_local_polygon_count,
+            max_snap_error_dbu=extractor.max_snap_error,
+        ),
+    )
+
+
+class _WindowExtractor:
+    def __init__(self, *, unit: Decimal, grid: Decimal, selected_layers: set[LayerSpec] | None, window_bbox: BBox) -> None:
+        self.unit = unit
+        self.grid = grid
+        self.selected_layers = selected_layers
+        self.window_bbox = window_bbox
+        self.polygons: list[tuple[LayerSpec, tuple[tuple[int, int], ...]]] = []
+        self.max_snap_error = Decimal(0)
+        self.visited_cell_count = 0
+        self.considered_reference_instance_count = 0
+        self.pruned_reference_instance_count = 0
+        self.raw_local_polygon_count = 0
+
+    def traverse_cell(self, cell: gdstk.Cell, transform: _Transform, visiting: set[int]) -> None:
+        key = id(cell)
+        if key in visiting:
+            raise ValueError(f"hierarchy cycle detected at cell {cell.name!r}")
+        visiting.add(key)
+        self.visited_cell_count += 1
+        for polygon in cell.get_polygons(depth=0, include_paths=True):
+            self.raw_local_polygon_count += 1
+            spec = LayerSpec(polygon.layer, polygon.datatype)
+            if self.selected_layers is not None and spec not in self.selected_layers:
+                continue
+            points = tuple(transform.apply(float(point[0]), float(point[1])) for point in polygon.points)
+            if not _float_bbox_intersects_window(points, self.window_bbox, self.unit, self.grid):
+                continue
+            snapped = self._snap_points(points)
+            if len(snapped) >= 3 and bboxes_intersect(polygon_bbox(snapped), self.window_bbox):
+                self.polygons.append((spec, snapped))
+        for reference in cell.references:
+            child = _reference_cell(reference)
+            if id(child) in visiting:
+                raise ValueError(f"hierarchy cycle detected at cell {child.name!r}")
+            child_bbox = child.bounding_box()
+            if child_bbox is None:
+                continue
+            for offset in _reference_offsets(reference):
+                self.considered_reference_instance_count += 1
+                reference_transform = _reference_transform(reference, offset)
+                child_transform = transform.compose(reference_transform)
+                transformed_bbox = _transform_bbox(child_bbox, child_transform, self.unit, self.grid)
+                if not bboxes_intersect(transformed_bbox, self.window_bbox):
+                    self.pruned_reference_instance_count += 1
+                    continue
+                self.traverse_cell(child, child_transform, visiting)
+        visiting.remove(key)
+
+    def _snap_points(self, points: tuple[tuple[float, float], ...]) -> tuple[tuple[int, int], ...]:
+        snapped_points: list[tuple[int, int]] = []
+        for x, y in points:
+            x_physical = decimal_from_number(x) * self.unit
+            y_physical = decimal_from_number(y) * self.unit
+            sx = snap_to_grid(x_physical, self.grid)
+            sy = snap_to_grid(y_physical, self.grid)
+            self.max_snap_error = max(
+                self.max_snap_error,
+                abs(x_physical / self.grid - Decimal(sx)),
+                abs(y_physical / self.grid - Decimal(sy)),
+            )
+            snapped_points.append((sx, sy))
+        return normalize_polygon_points(snapped_points)
+
+    def to_buffer(self) -> PolygonBuffer:
+        layer_table = LayerTable(tuple(sorted({layer for layer, _ in self.polygons})))
+        layer_index = layer_table.index_by_layer
+        vertices: list[tuple[int, int]] = []
+        offsets = [0]
+        layer_ids = []
+        bboxes = []
+        flags = []
+        source_ids = []
+        for source_id, (layer, points) in enumerate(self.polygons):
+            vertices.extend(points)
+            offsets.append(len(vertices))
+            layer_ids.append(layer_index[layer])
+            bboxes.append(polygon_bbox(points))
+            flags.append(polygon_flags(points))
+            source_ids.append(source_id)
+        return PolygonBuffer(
+            vertices_xy=np.asarray(vertices, dtype=np.int64).reshape((-1, 2)),
+            polygon_offsets=np.asarray(offsets, dtype=np.uint64),
+            layer_ids=np.asarray(layer_ids, dtype=np.uint32),
+            bboxes=np.asarray(bboxes, dtype=np.int64).reshape((-1, 4)),
+            flags=np.asarray(flags, dtype=np.uint32),
+            source_ids=np.asarray(source_ids, dtype=np.uint64),
+            layer_table=layer_table,
+        )
+
+
+def _reference_cell(reference: gdstk.Reference) -> gdstk.Cell:
+    if reference.cell is None:
+        raise ValueError(f"unresolved reference to {reference.cell_name!r}")
+    return reference.cell
+
+
+def _reference_offsets(reference: gdstk.Reference) -> tuple[tuple[float, float], ...]:
+    repetition = reference.repetition
+    if repetition is None or repetition.size <= 1:
+        return ((0.0, 0.0),)
+    return tuple((float(x), float(y)) for x, y in repetition.get_offsets())
+
+
+def _reference_transform(reference: gdstk.Reference, offset: tuple[float, float]) -> _Transform:
+    rotation = float(reference.rotation or 0.0)
+    magnification = float(reference.magnification if reference.magnification is not None else 1.0)
+    cos_r = math.cos(rotation)
+    sin_r = math.sin(rotation)
+    if reference.x_reflection:
+        a = magnification * cos_r
+        b = magnification * sin_r
+        c = magnification * sin_r
+        d = -magnification * cos_r
+    else:
+        a = magnification * cos_r
+        b = -magnification * sin_r
+        c = magnification * sin_r
+        d = magnification * cos_r
+    return _Transform(
+        a=a,
+        b=b,
+        c=c,
+        d=d,
+        tx=float(reference.origin[0]) + offset[0],
+        ty=float(reference.origin[1]) + offset[1],
+    )
+
+
+def _transform_bbox(bbox, transform: _Transform, unit: Decimal, grid: Decimal) -> BBox:
+    corners = (
+        transform.apply(float(bbox[0][0]), float(bbox[0][1])),
+        transform.apply(float(bbox[0][0]), float(bbox[1][1])),
+        transform.apply(float(bbox[1][0]), float(bbox[0][1])),
+        transform.apply(float(bbox[1][0]), float(bbox[1][1])),
+    )
+    snapped = [(snap_to_grid(decimal_from_number(x) * unit, grid), snap_to_grid(decimal_from_number(y) * unit, grid)) for x, y in corners]
+    return polygon_bbox(tuple(snapped))
+
+
+def _float_bbox_intersects_window(points: tuple[tuple[float, float], ...], window: BBox, unit: Decimal, grid: Decimal) -> bool:
+    if not points:
+        return False
+    snapped = [(snap_to_grid(decimal_from_number(x) * unit, grid), snap_to_grid(decimal_from_number(y) * unit, grid)) for x, y in points]
+    return bboxes_intersect(polygon_bbox(tuple(snapped)), window)
+
+
+def _selected_layers_or_none(layers) -> set[LayerSpec] | None:
+    parsed = parse_layer_selector(layers)
+    if parsed == "all":
+        return None
+    return set(parsed)

gdsdiff/inventory.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable
+
+import gdstk
+
+from .config import LayerSpec, parse_layer_selector
+from .gds_metadata import GdsMetadata, decimal_from_number
+
+
+@dataclass(frozen=True)
+class RecordInventory:
+    polygons: int = 0
+    paths: int = 0
+    labels: int = 0
+    references: int = 0
+    cells: int = 0
+
+    def to_json(self) -> dict[str, int]:
+        return {
+            "polygons": self.polygons,
+            "paths": self.paths,
+            "labels": self.labels,
+            "references": self.references,
+            "cells": self.cells,
+        }
+
+
+@dataclass(frozen=True)
+class GdsInventory:
+    metadata: GdsMetadata
+    selected_top: str
+    reachable_cells: tuple[str, ...]
+    layers: tuple[LayerSpec, ...]
+    records: RecordInventory
+    ignored_record_counts: dict[str, int]
+
+    def to_json(self) -> dict[str, object]:
+        return {
+            "metadata": self.metadata.to_json(),
+            "selected_top": self.selected_top,
+            "reachable_cells": list(self.reachable_cells),
+            "layers": [layer.to_json() for layer in self.layers],
+            "records": self.records.to_json(),
+            "ignored_record_counts": dict(self.ignored_record_counts),
+        }
+
+
+@dataclass(frozen=True)
+class SelectedLayerPresence:
+    layer: LayerSpec
+    present_old: bool
+    present_new: bool
+
+    def to_json(self) -> dict[str, object]:
+        return {
+            "layer": self.layer.layer,
+            "datatype": self.layer.datatype,
+            "present_old": self.present_old,
+            "present_new": self.present_new,
+        }
+
+
+def inventory_gds(path: str | Path, *, top_name: str | None = None) -> GdsInventory:
+    path = Path(path)
+    lib = gdstk.read_gds(str(path))
+    top = select_top_cell(lib, top_name=top_name)
+    reachable = _reachable_cells(top)
+    final_layers = tuple(sorted({LayerSpec(poly.layer, poly.datatype) for poly in top.get_polygons()}))
+    records = _record_inventory(reachable)
+    metadata = GdsMetadata(
+        path=path,
+        unit_m=decimal_from_number(lib.unit),
+        precision_m=decimal_from_number(lib.precision),
+        cell_count=len(lib.cells),
+        top_names=tuple(cell.name for cell in lib.top_level()),
+    )
+    return GdsInventory(
+        metadata=metadata,
+        selected_top=top.name,
+        reachable_cells=tuple(sorted(cell.name for cell in reachable)),
+        layers=final_layers,
+        records=records,
+        ignored_record_counts={"labels": records.labels},
+    )
+
+
+def select_top_cell(lib: gdstk.Library, *, top_name: str | None = None) -> gdstk.Cell:
+    if top_name is not None:
+        for cell in lib.cells:
+            if cell.name == top_name:
+                return cell
+        raise ValueError(f"top cell {top_name!r} not found")
+    tops = lib.top_level()
+    if len(tops) != 1:
+        names = ", ".join(cell.name for cell in tops) or "<none>"
+        raise ValueError(f"expected exactly one top-level cell, found {len(tops)}: {names}")
+    return tops[0]
+
+
+def resolve_selected_layers(
+    old_inventory: GdsInventory,
+    new_inventory: GdsInventory,
+    selector: str | LayerSpec | Iterable[str | tuple[int, int] | LayerSpec] = "all",
+    *,
+    allow_empty_selected_layer: bool = False,
+) -> tuple[SelectedLayerPresence, ...]:
+    old_layers = set(old_inventory.layers)
+    new_layers = set(new_inventory.layers)
+    if selector == "all":
+        selected = tuple(sorted(old_layers | new_layers))
+    else:
+        parsed = parse_layer_selector(selector)
+        if parsed == "all":
+            selected = tuple(sorted(old_layers | new_layers))
+        else:
+            selected = parsed
+    result = tuple(
+        SelectedLayerPresence(layer=layer, present_old=layer in old_layers, present_new=layer in new_layers)
+        for layer in selected
+    )
+    absent_both = [presence.layer for presence in result if not presence.present_old and not presence.present_new]
+    if absent_both and not allow_empty_selected_layer:
+        missing = ", ".join(f"{layer.layer}:{layer.datatype}" for layer in absent_both)
+        raise ValueError(f"selected layer(s) absent in both inputs: {missing}")
+    return result
+
+
+def _reachable_cells(top: gdstk.Cell) -> tuple[gdstk.Cell, ...]:
+    seen: set[str] = set()
+    out: list[gdstk.Cell] = []
+
+    def visit(cell: gdstk.Cell) -> None:
+        if cell.name in seen:
+            return
+        seen.add(cell.name)
+        out.append(cell)
+        for ref in cell.references:
+            if isinstance(ref.cell, gdstk.Cell):
+                visit(ref.cell)
+
+    visit(top)
+    return tuple(out)
+
+
+def _record_inventory(cells: tuple[gdstk.Cell, ...]) -> RecordInventory:
+    polygons = sum(len(cell.polygons) for cell in cells)
+    paths = sum(len(cell.paths) for cell in cells)
+    labels = sum(len(cell.labels) for cell in cells)
+    references = sum(len(cell.references) for cell in cells)
+    return RecordInventory(polygons=polygons, paths=paths, labels=labels, references=references, cells=len(cells))

gdsdiff/multiprocessing_support.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import multiprocessing as mp
+import sys
+import threading
+from multiprocessing.context import BaseContext
+
+_IS_PORTABLE_PROCESS_WORKER = False
+
+
+def mark_portable_process_worker() -> None:
+    """Mark a spawned pair-extraction worker so it never forks again."""
+
+    global _IS_PORTABLE_PROCESS_WORKER
+    _IS_PORTABLE_PROCESS_WORKER = True
+
+
+def fork_context() -> BaseContext | None:
+    """Return a fork context when the platform supports one.
+
+    Several hot paths share large, read-only geometry buffers through forked
+    worker globals. Windows does not provide fork, so callers must retain a
+    serial path instead of failing while attempting to create a pool.
+    """
+
+    if (
+        _IS_PORTABLE_PROCESS_WORKER
+        or sys.version_info >= (3, 14)
+        or "fork" not in mp.get_all_start_methods()
+        or threading.active_count() != 1
+    ):
+        return None
+    return mp.get_context("fork")
+
+
+def portable_process_context() -> BaseContext:
+    """Return the portable context for independent, pickle-safe tasks."""
+
+    return mp.get_context("spawn")