[file.utils] add preflight_source_aware

masque/test/test_gdsii_lazy_arrow.py

@@ -14,6 +14,7 @@ from ..library import IBorrowing, IMaterializable, LayerMappedView, Library, Ove
 from ..pattern import Pattern
 from ..repetition import Grid
 from ..file import gdsii
+from ..file.utils import preflight_source_aware
 from ..file.gdsii import lazy_arrow as gdsii_lazy_arrow
 from ..file.gdsii import lazy_write as gdsii_lazy_write
 from ..file.gdsii.perf import write_fixture
@@ -301,8 +302,10 @@ def test_gdsii_layer_mapped_view_controls_raw_copy_through(
     assert set(roundtrip['leaf'].shapes) == {(20, 0)}
 
     passthrough = LayerMappedView(raw, map_layer, copy_through=True)
+    preflighted = preflight_source_aware(passthrough)
+    assert isinstance(preflighted, OverlayLibrary)
     copied_file = tmp_path / 'layer_mapped_copied.gds'
-    gdsii_lazy_arrow.writefile(passthrough, copied_file)
+    gdsii_lazy_arrow.writefile(preflighted, copied_file)
 
     assert copied == ['leaf', 'mid', 'top']
     assert copied_file.read_bytes() == gds_file.read_bytes()
@@ -310,12 +313,13 @@ def test_gdsii_layer_mapped_view_controls_raw_copy_through(
 
     copied.clear()
     assert set(passthrough['leaf'].shapes) == {(20, 0)}
-    promoted_file = tmp_path / 'layer_mapped_promoted.gds'
-    gdsii_lazy_arrow.writefile(passthrough, promoted_file)
+    preflighted = preflight_source_aware(passthrough)
+    materialized_file = tmp_path / 'layer_mapped_materialized.gds'
+    gdsii_lazy_arrow.writefile(preflighted, materialized_file)
 
     assert copied == ['mid', 'top']
     assert not raw._cache
-    roundtrip, _ = gdsii.readfile(promoted_file)
+    roundtrip, _ = gdsii.readfile(materialized_file)
     assert set(roundtrip['leaf'].shapes) == {(20, 0)}
 
 

masque/test/test_library.py

@@ -11,7 +11,7 @@ from ..error import LibraryError, PatternError
 from ..ports import Port
 from ..repetition import Grid
 from ..shapes import Arc, Ellipse, Path, Text
-from ..file.utils import preflight
+from ..file.utils import preflight, preflight_source_aware
 
 if TYPE_CHECKING:
     from ..shapes import Polygon
@@ -193,6 +193,84 @@ def test_preflight_prune_empty_preserves_dangling_policy(caplog: pytest.LogCaptu
         preflight(make_lib(), allow_dangling_refs=False, prune_empty_patterns=True)
 
 
+def test_preflight_source_aware_skips_source_backed_patterns() -> None:
+    source = Library()
+    source["copied"] = Pattern()
+    source["materialized"] = Pattern()
+    mapped_names: list[str] = []
+
+    def map_layer(layer: int | tuple[int, int] | str) -> int | tuple[int, int] | str:
+        mapped_names.append(str(layer))
+        return layer
+
+    view = LayerMappedView(source, map_layer, copy_through=True)
+    view["materialized"].rect("named", xmin=0, xmax=1, ymin=0, ymax=1)
+
+    result = preflight_source_aware(view, allow_named_layers=True)
+
+    assert isinstance(result, OverlayLibrary)
+    assert mapped_names == []
+    assert result.source_cell("copied") is not None
+    assert result.source_cell("materialized") is None
+    assert not source["materialized"].shapes
+    assert "named" in result["materialized"].shapes
+
+
+def test_preflight_source_aware_checks_only_cells_without_provenance() -> None:
+    source = Library()
+    source["copied"] = Pattern().rect("copied_layer", xmin=0, xmax=1, ymin=0, ymax=1)
+    source["materialized"] = Pattern().rect("materialized_layer", xmin=0, xmax=1, ymin=0, ymax=1)
+    view = LayerMappedView(source, lambda layer: layer, copy_through=True)
+
+    preflight_source_aware(view, allow_named_layers=False)
+
+    view["materialized"]
+    with pytest.raises(PatternError, match="materialized_layer"):
+        preflight_source_aware(view, allow_named_layers=False)
+
+
+def test_preflight_source_aware_prunes_only_safe_checked_patterns() -> None:
+    source = Library({"child": Pattern(), "parent": Pattern()})
+    source["parent"].ref("child")
+    view = LayerMappedView(source, lambda layer: layer, copy_through=True)
+    view["child"]
+
+    result = preflight_source_aware(view, prune_empty_patterns=True)
+
+    assert isinstance(result, OverlayLibrary)
+    assert "child" in result
+    assert result.source_cell("parent") is not None
+
+    view["parent"]
+    result = preflight_source_aware(view, prune_empty_patterns=True)
+
+    assert "child" not in result
+    assert "parent" not in result
+    assert "child" in source
+    assert "child" in source["parent"].refs
+
+
+def test_preflight_source_aware_wraps_only_checked_patterns() -> None:
+    source = Library({"copied": Pattern(), "materialized": Pattern()})
+    for name in source:
+        source[name].rect((1, 0), xmin=0, xmax=1, ymin=0, ymax=1)
+        source[name].shapes[(1, 0)][0].repetition = Grid(a_vector=(10, 0), a_count=2)
+    view = LayerMappedView(source, lambda layer: layer, copy_through=True)
+    view["materialized"]
+
+    result = preflight_source_aware(view, wrap_repeated_shapes=True)
+
+    assert isinstance(result, OverlayLibrary)
+    assert result.source_cell("copied") is not None
+    assert source["copied"].shapes[(1, 0)][0].repetition is not None
+    assert result["materialized"].shapes[(1, 0)] == []
+    wrapper_names = result["materialized"].referenced_patterns()
+    assert len(wrapper_names) == 1
+    wrapper_name = next(iter(wrapper_names))
+    assert wrapper_name is not None
+    assert result[wrapper_name].shapes[(1, 0)][0].repetition is None
+
+
 def test_library_flatten() -> None:
     lib = Library()
     child = Pattern()
@@ -667,7 +745,7 @@ def test_lazy_library_subtree_preserves_type_and_shares_materialized_patterns()
     assert "child" in lib
 
 
-def test_overlay_subtree_preserves_type_sources_and_independent_promotion() -> None:
+def test_overlay_subtree_preserves_type_sources_and_independent_materialization() -> None:
     source = Library({"child": Pattern(), "top": Pattern(), "unused": Pattern()})
     source["top"].ref("child")
     overlay = OverlayLibrary()