disable deepcopy for Library since it doesn't work

- It was *slow*. Often >50% of runtime for large designs.
- It didn't catch all corner cases. True immutability would require
  language-level support.
- (minor) It doesn't play nice with type checking via mypy.

masque/__init__.py

@@ -24,11 +24,10 @@
     metaclass is used to auto-generate slots based on superclass type annotations.
  - File I/O submodules are imported by `masque.file` to avoid creating hard dependencies on
     external file-format reader/writers
- - Pattern locking/unlocking is quite slow for large hierarchies.
 
 """
 
-from .error import PatternError, PatternLockedError
+from .error import PatternError
 from .shapes import Shape
 from .label import Label
 from .subpattern import SubPattern

masque/error.py

@@ -11,13 +11,6 @@ class PatternError(MasqueError):
     """
     pass
 
-class PatternLockedError(PatternError):
-    """
-    Exception raised when trying to modify a locked pattern
-    """
-    def __init__(self):
-        PatternError.__init__(self, 'Tried to modify a locked Pattern, subpattern, or shape')
-
 
 class LibraryError(MasqueError):
     """

masque/file/dxf.py

@@ -63,7 +63,7 @@ def write(
         patterns: A Pattern or list of patterns to write to the stream.
         stream: Stream object to write to.
         modify_original: If `True`, the original pattern is modified as part of the writing
-            process. Otherwise, a copy is made and `deepunlock()`-ed.
+            process. Otherwise, a copy is made.
             Default `False`.
         disambiguate_func: Function which takes a list of patterns and alters them
             to make their names valid and unique. Default is `disambiguate_pattern_names`.
@@ -75,7 +75,7 @@ def write(
     assert(disambiguate_func is not None)
 
     if not modify_originals:
-        pattern = pattern.deepcopy().deepunlock()
+        pattern = pattern.deepcopy()
 
     # Get a dict of id(pattern) -> pattern
     patterns_by_id = pattern.referenced_patterns_by_id()
@@ -267,10 +267,12 @@ def _read_block(block, clean_vertices: bool) -> Pattern:
                 }
 
             if 'column_count' in attr:
-                args['repetition'] = Grid(a_vector=(attr['column_spacing'], 0),
-                                          b_vector=(0, attr['row_spacing']),
-                                          a_count=attr['column_count'],
-                                          b_count=attr['row_count'])
+                args['repetition'] = Grid(
+                    a_vector=(attr['column_spacing'], 0),
+                    b_vector=(0, attr['row_spacing']),
+                    a_count=attr['column_count'],
+                    b_count=attr['row_count'],
+                    )
             pat.subpatterns.append(SubPattern(**args))
         else:
             logger.warning(f'Ignoring DXF element {element.dxftype()} (not implemented).')

masque/file/gdsii.py

@@ -31,7 +31,7 @@ import pathlib
 import gzip
 
 import numpy
-from numpy.typing import NDArray
+from numpy.typing import NDArray, ArrayLike
 import klamath
 from klamath import records
 
@@ -53,6 +53,10 @@ path_cap_map = {
     }
 
 
+def rint_cast(val: ArrayLike) -> NDArray[numpy.int32]:
+    return numpy.rint(val, dtype=numpy.int32, casting='unsafe')
+
+
 def write(
         patterns: Union[Pattern, Sequence[Pattern]],
         stream: BinaryIO,
@@ -94,7 +98,7 @@ def write(
         library_name: Library name written into the GDSII file.
             Default 'masque-klamath'.
         modify_originals: If `True`, the original pattern is modified as part of the writing
-            process. Otherwise, a copy is made and `deepunlock()`-ed.
+            process. Otherwise, a copy is made.
             Default `False`.
         disambiguate_func: Function which takes a list of patterns and alters them
             to make their names valid and unique. Default is `disambiguate_pattern_names`, which
@@ -109,14 +113,16 @@ def write(
     assert(disambiguate_func is not None)       # placate mypy
 
     if not modify_originals:
-        patterns = [p.deepunlock() for p in copy.deepcopy(patterns)]
+        patterns = copy.deepcopy(patterns)
 
     patterns = [p.wrap_repeated_shapes() for p in patterns]
 
     # Create library
-    header = klamath.library.FileHeader(name=library_name.encode('ASCII'),
-                                        user_units_per_db_unit=logical_units_per_unit,
-                                        meters_per_db_unit=meters_per_unit)
+    header = klamath.library.FileHeader(
+        name=library_name.encode('ASCII'),
+        user_units_per_db_unit=logical_units_per_unit,
+        meters_per_db_unit=meters_per_unit,
+        )
     header.write(stream)
 
     # Get a dict of id(pattern) -> pattern
@@ -241,10 +247,11 @@ def _read_header(stream: BinaryIO) -> Dict[str, Any]:
     """
     header = klamath.library.FileHeader.read(stream)
 
-    library_info = {'name': header.name.decode('ASCII'),
-                    'meters_per_unit': header.meters_per_db_unit,
-                    'logical_units_per_unit': header.user_units_per_db_unit,
-                    }
+    library_info = {
+        'name': header.name.decode('ASCII'),
+        'meters_per_unit': header.meters_per_db_unit,
+        'logical_units_per_unit': header.user_units_per_db_unit,
+        }
     return library_info
 
 
@@ -276,10 +283,12 @@ def read_elements(
             path = _gpath_to_mpath(element, raw_mode)
             pat.shapes.append(path)
         elif isinstance(element, klamath.elements.Text):
-            label = Label(offset=element.xy.astype(float),
-                          layer=element.layer,
-                          string=element.string.decode('ASCII'),
-                          annotations=_properties_to_annotations(element.properties))
+            label = Label(
+                offset=element.xy.astype(float),
+                layer=element.layer,
+                string=element.string.decode('ASCII'),
+                annotations=_properties_to_annotations(element.properties),
+                )
             pat.labels.append(label)
         elif isinstance(element, klamath.elements.Reference):
             pat.subpatterns.append(_ref_to_subpat(element))
@@ -314,16 +323,22 @@ def _ref_to_subpat(ref: klamath.library.Reference) -> SubPattern:
         a_count, b_count = ref.colrow
         a_vector = (xy[1] - offset) / a_count
         b_vector = (xy[2] - offset) / b_count
-        repetition = Grid(a_vector=a_vector, b_vector=b_vector,
-                          a_count=a_count, b_count=b_count)
+        repetition = Grid(
+            a_vector=a_vector,
+            b_vector=b_vector,
+            a_count=a_count,
+            b_count=b_count,
+            )
 
-    subpat = SubPattern(pattern=None,
-                        offset=offset,
-                        rotation=numpy.deg2rad(ref.angle_deg),
-                        scale=ref.mag,
-                        mirrored=(ref.invert_y, False),
-                        annotations=_properties_to_annotations(ref.properties),
-                        repetition=repetition)
+    subpat = SubPattern(
+        pattern=None,
+        offset=offset,
+        rotation=numpy.deg2rad(ref.angle_deg),
+        scale=ref.mag,
+        mirrored=(ref.invert_y, False),
+        annotations=_properties_to_annotations(ref.properties),
+        repetition=repetition,
+        )
     subpat.identifier = (ref.struct_name.decode('ASCII'),)
     return subpat
 
@@ -334,26 +349,28 @@ def _gpath_to_mpath(gpath: klamath.library.Path, raw_mode: bool) -> Path:
     else:
         raise PatternError(f'Unrecognized path type: {gpath.path_type}')
 
-    mpath = Path(vertices=gpath.xy.astype(float),
-                 layer=gpath.layer,
-                 width=gpath.width,
-                 cap=cap,
-                 offset=numpy.zeros(2),
-                 annotations=_properties_to_annotations(gpath.properties),
-                 raw=raw_mode,
-                 )
+    mpath = Path(
+        vertices=gpath.xy.astype(float),
+        layer=gpath.layer,
+        width=gpath.width,
+        cap=cap,
+        offset=numpy.zeros(2),
+        annotations=_properties_to_annotations(gpath.properties),
+        raw=raw_mode,
+        )
     if cap == Path.Cap.SquareCustom:
         mpath.cap_extensions = gpath.extension
     return mpath
 
 
 def _boundary_to_polygon(boundary: klamath.library.Boundary, raw_mode: bool) -> Polygon:
-    return Polygon(vertices=boundary.xy[:-1].astype(float),
-                   layer=boundary.layer,
-                   offset=numpy.zeros(2),
-                   annotations=_properties_to_annotations(boundary.properties),
-                   raw=raw_mode,
-                   )
+    return Polygon(
+        vertices=boundary.xy[:-1].astype(float),
+        layer=boundary.layer,
+        offset=numpy.zeros(2),
+        annotations=_properties_to_annotations(boundary.properties),
+        raw=raw_mode,
+        )
 
 
 def _subpatterns_to_refs(subpatterns: List[SubPattern]) -> List[klamath.library.Reference]:
@@ -377,31 +394,37 @@ def _subpatterns_to_refs(subpatterns: List[SubPattern]) -> List[klamath.library.
                 rep.a_vector * rep.a_count,
                 b_vector * b_count,
                 ]
-            aref = klamath.library.Reference(struct_name=encoded_name,
-                                             xy=numpy.round(xy).astype(int),
-                                             colrow=(numpy.round(rep.a_count), numpy.round(rep.b_count)),
-                                             angle_deg=angle_deg,
-                                             invert_y=mirror_across_x,
-                                             mag=subpat.scale,
-                                             properties=properties)
+            aref = klamath.library.Reference(
+                struct_name=encoded_name,
+                xy=rint_cast(xy),
+                colrow=(numpy.rint(rep.a_count), numpy.rint(rep.b_count)),
+                angle_deg=angle_deg,
+                invert_y=mirror_across_x,
+                mag=subpat.scale,
+                properties=properties,
+                )
             refs.append(aref)
         elif rep is None:
-            ref = klamath.library.Reference(struct_name=encoded_name,
-                                            xy=numpy.round([subpat.offset]).astype(int),
-                                            colrow=None,
-                                            angle_deg=angle_deg,
-                                            invert_y=mirror_across_x,
-                                            mag=subpat.scale,
-                                            properties=properties)
+            ref = klamath.library.Reference(
+                struct_name=encoded_name,
+                xy=rint_cast([subpat.offset]),
+                colrow=None,
+                angle_deg=angle_deg,
+                invert_y=mirror_across_x,
+                mag=subpat.scale,
+                properties=properties,
+                )
             refs.append(ref)
         else:
-            new_srefs = [klamath.library.Reference(struct_name=encoded_name,
-                                                   xy=numpy.round([subpat.offset + dd]).astype(int),
-                                                   colrow=None,
-                                                   angle_deg=angle_deg,
-                                                   invert_y=mirror_across_x,
-                                                   mag=subpat.scale,
-                                                   properties=properties)
+            new_srefs = [klamath.library.Reference(
+                            struct_name=encoded_name,
+                            xy=rint_cast([subpat.offset + dd]),
+                            colrow=None,
+                            angle_deg=angle_deg,
+                            invert_y=mirror_across_x,
+                            mag=subpat.scale,
+                            properties=properties,
+                            )
                          for dd in rep.displacements]
             refs += new_srefs
     return refs
@@ -443,8 +466,8 @@ def _shapes_to_elements(
         layer, data_type = _mlayer2gds(shape.layer)
         properties = _annotations_to_properties(shape.annotations, 128)
         if isinstance(shape, Path) and not polygonize_paths:
-            xy = numpy.round(shape.vertices + shape.offset).astype(int)
-            width = numpy.round(shape.width).astype(int)
+            xy = rint_cast(shape.vertices + shape.offset)
+            width = rint_cast(shape.width)
             path_type = next(k for k, v in path_cap_map.items() if v == shape.cap)    # reverse lookup
 
             extension: Tuple[int, int]
@@ -453,30 +476,36 @@ def _shapes_to_elements(
             else:
                 extension = (0, 0)
 
-            path = klamath.elements.Path(layer=(layer, data_type),
-                                         xy=xy,
-                                         path_type=path_type,
-                                         width=width,
-                                         extension=extension,
-                                         properties=properties)
+            path = klamath.elements.Path(
+                layer=(layer, data_type),
+                xy=xy,
+                path_type=path_type,
+                width=width,
+                extension=extension,
+                properties=properties,
+                )
             elements.append(path)
         elif isinstance(shape, Polygon):
             polygon = shape
             xy_closed = numpy.empty((polygon.vertices.shape[0] + 1, 2), dtype=numpy.int32)
             numpy.rint(polygon.vertices + polygon.offset, out=xy_closed[:-1], casting='unsafe')
             xy_closed[-1] = xy_closed[0]
-            boundary = klamath.elements.Boundary(layer=(layer, data_type),
-                                                 xy=xy_closed,
-                                                 properties=properties)
+            boundary = klamath.elements.Boundary(
+                layer=(layer, data_type),
+                xy=xy_closed,
+                properties=properties,
+                )
             elements.append(boundary)
         else:
             for polygon in shape.to_polygons():
                 xy_closed = numpy.empty((polygon.vertices.shape[0] + 1, 2), dtype=numpy.int32)
                 numpy.rint(polygon.vertices + polygon.offset, out=xy_closed[:-1], casting='unsafe')
                 xy_closed[-1] = xy_closed[0]
-                boundary = klamath.elements.Boundary(layer=(layer, data_type),
-                                                     xy=xy_closed,
-                                                     properties=properties)
+                boundary = klamath.elements.Boundary(
+                    layer=(layer, data_type),
+                    xy=xy_closed,
+                    properties=properties,
+                    )
                 elements.append(boundary)
     return elements
 
@@ -486,17 +515,19 @@ def _labels_to_texts(labels: List[Label]) -> List[klamath.elements.Text]:
     for label in labels:
         properties = _annotations_to_properties(label.annotations, 128)
         layer, text_type = _mlayer2gds(label.layer)
-        xy = numpy.round([label.offset]).astype(int)
-        text = klamath.elements.Text(layer=(layer, text_type),
-                                     xy=xy,
-                                     string=label.string.encode('ASCII'),
-                                     properties=properties,
-                                     presentation=0,  # TODO maybe set some of these?
-                                     angle_deg=0,
-                                     invert_y=False,
-                                     width=0,
-                                     path_type=0,
-                                     mag=1)
+        xy = rint_cast([label.offset])
+        text = klamath.elements.Text(
+            layer=(layer, text_type),
+            xy=xy,
+            string=label.string.encode('ASCII'),
+            properties=properties,
+            presentation=0,  # TODO maybe set some of these?
+            angle_deg=0,
+            invert_y=False,
+            width=0,
+            path_type=0,
+            mag=1,
+            )
         texts.append(text)
     return texts
 

masque/file/oasis.py

@@ -22,6 +22,7 @@ import pathlib
 import gzip
 
 import numpy
+from numpy.typing import ArrayLike, NDArray
 import fatamorgana
 import fatamorgana.records as fatrec
 from fatamorgana.basic import PathExtensionScheme, AString, NString, PropStringReference
@@ -47,6 +48,10 @@ path_cap_map = {
 
 #TODO implement more shape types?
 
+def rint_cast(val: ArrayLike) -> NDArray[numpy.int64]:
+    return numpy.rint(val, dtype=numpy.int64, casting='unsafe')
+
+
 def build(
         patterns: Union[Pattern, Sequence[Pattern]],
         units_per_micron: int,
@@ -87,7 +92,7 @@ def build(
             `fatamorgana.records.LayerName` entries.
             Default is an empty dict (no names provided).
         modify_originals: If `True`, the original pattern is modified as part of the writing
-            process. Otherwise, a copy is made and `deepunlock()`-ed.
+            process. Otherwise, a copy is made.
             Default `False`.
         disambiguate_func: Function which takes a list of patterns and alters them
             to make their names valid and unique. Default is `disambiguate_pattern_names`.
@@ -109,7 +114,7 @@ def build(
         annotations = {}
 
     if not modify_originals:
-        patterns = [p.deepunlock() for p in copy.deepcopy(patterns)]
+        patterns = copy.deepcopy(patterns)
 
     # Create library
     lib = fatamorgana.OasisLayout(unit=units_per_micron, validation=None)
@@ -285,11 +290,13 @@ def read(
             if isinstance(element, fatrec.Polygon):
                 vertices = numpy.cumsum(numpy.vstack(((0, 0), element.get_point_list())), axis=0)
                 annotations = properties_to_annotations(element.properties, lib.propnames, lib.propstrings)
-                poly = Polygon(vertices=vertices,
-                               layer=element.get_layer_tuple(),
-                               offset=element.get_xy(),
-                               annotations=annotations,
-                               repetition=repetition)
+                poly = Polygon(
+                    vertices=vertices,
+                    layer=element.get_layer_tuple(),
+                    offset=element.get_xy(),
+                    annotations=annotations,
+                    repetition=repetition,
+                    )
 
                 pat.shapes.append(poly)
 
@@ -308,14 +315,16 @@ def read(
                                                                element.get_extension_end()[1]))
 
                 annotations = properties_to_annotations(element.properties, lib.propnames, lib.propstrings)
-                path = Path(vertices=vertices,
-                            layer=element.get_layer_tuple(),
-                            offset=element.get_xy(),
-                            repetition=repetition,
-                            annotations=annotations,
-                            width=element.get_half_width() * 2,
-                            cap=cap,
-                            **path_args)
+                path = Path(
+                    vertices=vertices,
+                    layer=element.get_layer_tuple(),
+                    offset=element.get_xy(),
+                    repetition=repetition,
+                    annotations=annotations,
+                    width=element.get_half_width() * 2,
+                    cap=cap,
+                    **path_args,
+                    )
 
                 pat.shapes.append(path)
 
@@ -323,12 +332,13 @@ def read(
                 width = element.get_width()
                 height = element.get_height()
                 annotations = properties_to_annotations(element.properties, lib.propnames, lib.propstrings)
-                rect = Polygon(layer=element.get_layer_tuple(),
-                               offset=element.get_xy(),
-                               repetition=repetition,
-                               vertices=numpy.array(((0, 0), (1, 0), (1, 1), (0, 1))) * (width, height),
-                               annotations=annotations,
-                               )
+                rect = Polygon(
+                    layer=element.get_layer_tuple(),
+                    offset=element.get_xy(),
+                    repetition=repetition,
+                    vertices=numpy.array(((0, 0), (1, 0), (1, 1), (0, 1))) * (width, height),
+                    annotations=annotations,
+                    )
                 pat.shapes.append(rect)
 
             elif isinstance(element, fatrec.Trapezoid):
@@ -357,12 +367,13 @@ def read(
                         vertices[2, 0] -= b
 
                 annotations = properties_to_annotations(element.properties, lib.propnames, lib.propstrings)
-                trapz = Polygon(layer=element.get_layer_tuple(),
-                                offset=element.get_xy(),
-                                repetition=repetition,
-                                vertices=vertices,
-                                annotations=annotations,
-                                )
+                trapz = Polygon(
+                    layer=element.get_layer_tuple(),
+                    offset=element.get_xy(),
+                    repetition=repetition,
+                    vertices=vertices,
+                    annotations=annotations,
+                    )
                 pat.shapes.append(trapz)
 
             elif isinstance(element, fatrec.CTrapezoid):
@@ -412,21 +423,24 @@ def read(
                     vertices[0, 1] += width
 
                 annotations = properties_to_annotations(element.properties, lib.propnames, lib.propstrings)
-                ctrapz = Polygon(layer=element.get_layer_tuple(),
-                                 offset=element.get_xy(),
-                                 repetition=repetition,
-                                 vertices=vertices,
-                                 annotations=annotations,
-                                 )
+                ctrapz = Polygon(
+                    layer=element.get_layer_tuple(),
+                    offset=element.get_xy(),
+                    repetition=repetition,
+                    vertices=vertices,
+                    annotations=annotations,
+                    )
                 pat.shapes.append(ctrapz)
 
             elif isinstance(element, fatrec.Circle):
                 annotations = properties_to_annotations(element.properties, lib.propnames, lib.propstrings)
-                circle = Circle(layer=element.get_layer_tuple(),
-                                offset=element.get_xy(),
-                                repetition=repetition,
-                                annotations=annotations,
-                                radius=float(element.get_radius()))
+                circle = Circle(
+                    layer=element.get_layer_tuple(),
+                    offset=element.get_xy(),
+                    repetition=repetition,
+                    annotations=annotations,
+                    radius=float(element.get_radius()),
+                    )
                 pat.shapes.append(circle)
 
             elif isinstance(element, fatrec.Text):
@@ -436,11 +450,13 @@ def read(
                     string = lib.textstrings[str_or_ref].string
                 else:
                     string = str_or_ref.string
-                label = Label(layer=element.get_layer_tuple(),
-                              offset=element.get_xy(),
-                              repetition=repetition,
-                              annotations=annotations,
-                              string=string)
+                label = Label(
+                    layer=element.get_layer_tuple(),
+                    offset=element.get_xy(),
+                    repetition=repetition,
+                    annotations=annotations,
+                    string=string,
+                    )
                 pat.labels.append(label)
 
             else:
@@ -499,14 +515,16 @@ def _placement_to_subpat(placement: fatrec.Placement, lib: fatamorgana.OasisLayo
         rotation = 0
     else:
         rotation = numpy.deg2rad(float(placement.angle))
-    subpat = SubPattern(offset=xy,
-                        pattern=None,
-                        mirrored=(placement.flip, False),
-                        rotation=rotation,
-                        scale=float(mag),
-                        identifier=(name,),
-                        repetition=repetition_fata2masq(placement.repetition),
-                        annotations=annotations)
+    subpat = SubPattern(
+        offset=xy,
+        pattern=None,
+        mirrored=(placement.flip, False),
+        rotation=rotation,
+        scale=float(mag),
+        identifier=(name,),
+        repetition=repetition_fata2masq(placement.repetition),
+        annotations=annotations,
+        )
     return subpat
 
 
@@ -522,7 +540,7 @@ def _subpatterns_to_placements(
         mirror_across_x, extra_angle = normalize_mirror(subpat.mirrored)
         frep, rep_offset = repetition_masq2fata(subpat.repetition)
 
-        offset = numpy.round(subpat.offset + rep_offset).astype(int)
+        offset = rint_cast(subpat.offset + rep_offset)
         angle = numpy.rad2deg(subpat.rotation + extra_angle) % 360
         ref = fatrec.Placement(
             name=subpat.pattern.name,
@@ -532,7 +550,8 @@ def _subpatterns_to_placements(
             properties=annotations_to_properties(subpat.annotations),
             x=offset[0],
             y=offset[1],
-            repetition=frep)
+            repetition=frep,
+            )
 
         refs.append(ref)
     return refs
@@ -549,46 +568,51 @@ def _shapes_to_elements(
         repetition, rep_offset = repetition_masq2fata(shape.repetition)
         properties = annotations_to_properties(shape.annotations)
         if isinstance(shape, Circle):
-            offset = numpy.round(shape.offset + rep_offset).astype(int)
-            radius = numpy.round(shape.radius).astype(int)
-            circle = fatrec.Circle(layer=layer,
-                                   datatype=datatype,
-                                   radius=radius,
-                                   x=offset[0],
-                                   y=offset[1],
-                                   properties=properties,
-                                   repetition=repetition)
+            offset = rint_cast(shape.offset + rep_offset)
+            radius = rint_cast(shape.radius)
+            circle = fatrec.Circle(
+                layer=layer,
+                datatype=datatype,
+                radius=radius,
+                x=offset[0],
+                y=offset[1],
+                properties=properties,
+                repetition=repetition,
+                )
             elements.append(circle)
         elif isinstance(shape, Path):
-            xy = numpy.round(shape.offset + shape.vertices[0] + rep_offset).astype(int)
-            deltas = numpy.round(numpy.diff(shape.vertices, axis=0)).astype(int)
-            half_width = numpy.round(shape.width / 2).astype(int)
+            xy = rint_cast(shape.offset + shape.vertices[0] + rep_offset)
+            deltas = rint_cast(numpy.diff(shape.vertices, axis=0))
+            half_width = rint_cast(shape.width / 2)
             path_type = next(k for k, v in path_cap_map.items() if v == shape.cap)    # reverse lookup
             extension_start = (path_type, shape.cap_extensions[0] if shape.cap_extensions is not None else None)
             extension_end = (path_type, shape.cap_extensions[1] if shape.cap_extensions is not None else None)
-            path = fatrec.Path(layer=layer,
-                               datatype=datatype,
-                               point_list=deltas,
-                               half_width=half_width,
-                               x=xy[0],
-                               y=xy[1],
-                               extension_start=extension_start,       # TODO implement multiple cap types?
-                               extension_end=extension_end,
-                               properties=properties,
-                               repetition=repetition,
-                               )
+            path = fatrec.Path(
+                layer=layer,
+                datatype=datatype,
+                point_list=deltas,
+                half_width=half_width,
+                x=xy[0],
+                y=xy[1],
+                extension_start=extension_start,       # TODO implement multiple cap types?
+                extension_end=extension_end,
+                properties=properties,
+                repetition=repetition,
+                )
             elements.append(path)
         else:
             for polygon in shape.to_polygons():
-                xy = numpy.round(polygon.offset + polygon.vertices[0] + rep_offset).astype(int)
-                points = numpy.round(numpy.diff(polygon.vertices, axis=0)).astype(int)
-                elements.append(fatrec.Polygon(layer=layer,
-                                               datatype=datatype,
-                                               x=xy[0],
-                                               y=xy[1],
-                                               point_list=points,
-                                               properties=properties,
-                                               repetition=repetition))
+                xy = rint_cast(polygon.offset + polygon.vertices[0] + rep_offset)
+                points = rint_cast(numpy.diff(polygon.vertices, axis=0))
+                elements.append(fatrec.Polygon(
+                    layer=layer,
+                    datatype=datatype,
+                    x=xy[0],
+                    y=xy[1],
+                    point_list=points,
+                    properties=properties,
+                    repetition=repetition,
+                    ))
     return elements
 
 
@@ -600,15 +624,17 @@ def _labels_to_texts(
     for label in labels:
         layer, datatype = layer2oas(label.layer)
         repetition, rep_offset = repetition_masq2fata(label.repetition)
-        xy = numpy.round(label.offset + rep_offset).astype(int)
+        xy = rint_cast(label.offset + rep_offset)
         properties = annotations_to_properties(label.annotations)
-        texts.append(fatrec.Text(layer=layer,
-                                 datatype=datatype,
-                                 x=xy[0],
-                                 y=xy[1],
-                                 string=label.string,
-                                 properties=properties,
-                                 repetition=repetition))
+        texts.append(fatrec.Text(
+            layer=layer,
+            datatype=datatype,
+            x=xy[0],
+            y=xy[1],
+            string=label.string,
+            properties=properties,
+            repetition=repetition,
+            ))
     return texts
 
 
@@ -648,10 +674,12 @@ def repetition_fata2masq(
         ) -> Optional[Repetition]:
     mrep: Optional[Repetition]
     if isinstance(rep, fatamorgana.GridRepetition):
-        mrep = Grid(a_vector=rep.a_vector,
-                    b_vector=rep.b_vector,
-                    a_count=rep.a_count,
-                    b_count=rep.b_count)
+        mrep = Grid(
+            a_vector=rep.a_vector,
+            b_vector=rep.b_vector,
+            a_count=rep.a_count,
+            b_count=rep.b_count,
+            )
     elif isinstance(rep, fatamorgana.ArbitraryRepetition):
         displacements = numpy.cumsum(numpy.column_stack((rep.x_displacements,
                                                          rep.y_displacements)), axis=0)
@@ -670,15 +698,20 @@ def repetition_masq2fata(
                    Tuple[int, int]]:
     frep: Union[fatamorgana.GridRepetition, fatamorgana.ArbitraryRepetition, None]
     if isinstance(rep, Grid):
+        a_vector = rint_cast(rep.a_vector)
+        b_vector = rint_cast(rep.b_vector) if rep.b_vector is not None else None
+        a_count = rint_cast(rep.a_count)
+        b_count = rint_cast(rep.b_count) if rep.b_count is not None else None
         frep = fatamorgana.GridRepetition(
-            a_vector=numpy.round(rep.a_vector).astype(int),
-            b_vector=numpy.round(rep.b_vector).astype(int),
-            a_count=numpy.round(rep.a_count).astype(int),
-            b_count=numpy.round(rep.b_count).astype(int))
+            a_vector=a_vector,
+            b_vector=b_vector,
+            a_count=a_count,
+            b_count=b_count,
+            )
         offset = (0, 0)
     elif isinstance(rep, Arbitrary):
         diffs = numpy.diff(rep.displacements, axis=0)
-        diff_ints = numpy.round(diffs).astype(int)
+        diff_ints = rint_cast(diffs)
         frep = fatamorgana.ArbitraryRepetition(diff_ints[:, 0], diff_ints[:, 1])
         offset = rep.displacements[0, :]
     else:

masque/file/python_gdsii.py

@@ -29,7 +29,7 @@ import pathlib
 import gzip
 
 import numpy
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import NDArray, ArrayLike
 # python-gdsii
 import gdsii.library    #type: ignore
 import gdsii.structure  #type: ignore
@@ -54,6 +54,10 @@ path_cap_map = {
     }
 
 
+def rint_cast(val: ArrayLike) -> NDArray[numpy.int32]:
+    return numpy.rint(val, dtype=numpy.int32, casting='unsafe')
+
+
 def build(
         patterns: Union[Pattern, Sequence[Pattern]],
         meters_per_unit: float,
@@ -91,7 +95,7 @@ def build(
         library_name: Library name written into the GDSII file.
             Default 'masque-gdsii-write'.
         modify_originals: If `True`, the original pattern is modified as part of the writing
-            process. Otherwise, a copy is made and `deepunlock()`-ed.
+            process. Otherwise, a copy is made.
             Default `False`.
         disambiguate_func: Function which takes a list of patterns and alters them
             to make their names valid and unique. Default is `disambiguate_pattern_names`, which
@@ -109,15 +113,17 @@ def build(
     assert(disambiguate_func is not None)       # placate mypy
 
     if not modify_originals:
-        patterns = [p.deepunlock() for p in copy.deepcopy(patterns)]
+        patterns = copy.deepcopy(patterns)
 
     patterns = [p.wrap_repeated_shapes() for p in patterns]
 
     # Create library
-    lib = gdsii.library.Library(version=600,
-                                name=library_name.encode('ASCII'),
-                                logical_unit=logical_units_per_unit,
-                                physical_unit=meters_per_unit)
+    lib = gdsii.library.Library(
+        version=600,
+        name=library_name.encode('ASCII'),
+        logical_unit=logical_units_per_unit,
+        physical_unit=meters_per_unit,
+        )
 
     # Get a dict of id(pattern) -> pattern
     patterns_by_id = {id(pattern): pattern for pattern in patterns}
@@ -240,10 +246,11 @@ def read(
 
     lib = gdsii.library.Library.load(stream)
 
-    library_info = {'name': lib.name.decode('ASCII'),
-                    'meters_per_unit': lib.physical_unit,
-                    'logical_units_per_unit': lib.logical_unit,
-                    }
+    library_info = {
+        'name': lib.name.decode('ASCII'),
+        'meters_per_unit': lib.physical_unit,
+        'logical_units_per_unit': lib.logical_unit,
+        }
 
     raw_mode = True     # Whether to construct shapes in raw mode (less error checking)
 
@@ -261,9 +268,11 @@ def read(
                 pat.shapes.append(path)
 
             elif isinstance(element, gdsii.elements.Text):
-                label = Label(offset=element.xy.astype(float),
-                              layer=(element.layer, element.text_type),
-                              string=element.string.decode('ASCII'))
+                label = Label(
+                    offset=element.xy.astype(float),
+                    layer=(element.layer, element.text_type),
+                    string=element.string.decode('ASCII'),
+                    )
                 pat.labels.append(label)
 
             elif isinstance(element, (gdsii.elements.SRef, gdsii.elements.ARef)):
@@ -337,16 +346,22 @@ def _ref_to_subpat(
         b_count = element.rows
         a_vector = (element.xy[1] - offset) / a_count
         b_vector = (element.xy[2] - offset) / b_count
-        repetition = Grid(a_vector=a_vector, b_vector=b_vector,
-                          a_count=a_count, b_count=b_count)
+        repetition = Grid(
+            a_vector=a_vector,
+            b_vector=b_vector,
+            a_count=a_count,
+            b_count=b_count,
+            )
 
-    subpat = SubPattern(pattern=None,
-                        offset=offset,
-                        rotation=rotation,
-                        scale=scale,
-                        mirrored=(mirror_across_x, False),
-                        annotations=_properties_to_annotations(element.properties),
-                        repetition=repetition)
+    subpat = SubPattern(
+        pattern=None,
+        offset=offset,
+        rotation=rotation,
+        scale=scale,
+        mirrored=(mirror_across_x, False),
+        annotations=_properties_to_annotations(element.properties),
+        repetition=repetition,
+        )
     subpat.identifier = (element.struct_name,)
     return subpat
 
@@ -357,14 +372,15 @@ def _gpath_to_mpath(element: gdsii.elements.Path, raw_mode: bool) -> Path:
     else:
         raise PatternError(f'Unrecognized path type: {element.path_type}')
 
-    args = {'vertices': element.xy.astype(float),
-            'layer': (element.layer, element.data_type),
-            'width': element.width if element.width is not None else 0.0,
-            'cap': cap,
-            'offset': numpy.zeros(2),
-            'annotations': _properties_to_annotations(element.properties),
-            'raw': raw_mode,
-           }
+    args = {
+        'vertices': element.xy.astype(float),
+        'layer': (element.layer, element.data_type),
+        'width': element.width if element.width is not None else 0.0,
+        'cap': cap,
+        'offset': numpy.zeros(2),
+        'annotations': _properties_to_annotations(element.properties),
+        'raw': raw_mode,
+        }
 
     if cap == Path.Cap.SquareCustom:
         args['cap_extensions'] = numpy.zeros(2)
@@ -377,12 +393,13 @@ def _gpath_to_mpath(element: gdsii.elements.Path, raw_mode: bool) -> Path:
 
 
 def _boundary_to_polygon(element: gdsii.elements.Boundary, raw_mode: bool) -> Polygon:
-    args = {'vertices': element.xy[:-1].astype(float),
-            'layer': (element.layer, element.data_type),
-            'offset': numpy.zeros(2),
-            'annotations': _properties_to_annotations(element.properties),
-            'raw': raw_mode,
-           }
+    args = {
+        'vertices': element.xy[:-1].astype(float),
+        'layer': (element.layer, element.data_type),
+        'offset': numpy.zeros(2),
+        'annotations': _properties_to_annotations(element.properties),
+        'raw': raw_mode,
+        }
     return Polygon(**args)
 
 
@@ -409,18 +426,24 @@ def _subpatterns_to_refs(
                 rep.a_vector * rep.a_count,
                 b_vector * b_count,
                 ]
-            ref = gdsii.elements.ARef(struct_name=encoded_name,
-                                      xy=numpy.round(xy).astype(int),
-                                      cols=numpy.round(rep.a_count).astype(int),
-                                      rows=numpy.round(rep.b_count).astype(int))
+            ref = gdsii.elements.ARef(
+                struct_name=encoded_name,
+                xy=rint_cast(xy),
+                cols=rint_cast(rep.a_count),
+                rows=rint_cast(rep.b_count),
+                )
             new_refs = [ref]
         elif rep is None:
-            ref = gdsii.elements.SRef(struct_name=encoded_name,
-                                      xy=numpy.round([subpat.offset]).astype(int))
+            ref = gdsii.elements.SRef(
+                struct_name=encoded_name,
+                xy=rint_cast([subpat.offset]),
+                )
             new_refs = [ref]
         else:
-            new_refs = [gdsii.elements.SRef(struct_name=encoded_name,
-                                            xy=numpy.round([subpat.offset + dd]).astype(int))
+            new_refs = [gdsii.elements.SRef(
+                            struct_name=encoded_name,
+                            xy=rint_cast([subpat.offset + dd]),
+                            )
                         for dd in rep.displacements]
 
         for ref in new_refs:
@@ -470,23 +493,28 @@ def _shapes_to_elements(
         layer, data_type = _mlayer2gds(shape.layer)
         properties = _annotations_to_properties(shape.annotations, 128)
         if isinstance(shape, Path) and not polygonize_paths:
-            xy = numpy.round(shape.vertices + shape.offset).astype(int)
-            width = numpy.round(shape.width).astype(int)
+            xy = rint_cast(shape.vertices + shape.offset)
+            width = rint_cast(shape.width)
             path_type = next(k for k, v in path_cap_map.items() if v == shape.cap)    # reverse lookup
-            path = gdsii.elements.Path(layer=layer,
-                                       data_type=data_type,
-                                       xy=xy)
+            path = gdsii.elements.Path(
+                layer=layer,
+                data_type=data_type,
+                xy=xy,
+                )
             path.path_type = path_type
             path.width = width
             path.properties = properties
             elements.append(path)
         else:
             for polygon in shape.to_polygons():
-                xy_open = numpy.round(polygon.vertices + polygon.offset).astype(int)
-                xy_closed = numpy.vstack((xy_open, xy_open[0, :]))
-                boundary = gdsii.elements.Boundary(layer=layer,
-                                                   data_type=data_type,
-                                                   xy=xy_closed)
+                xy_closed = numpy.empty((polygon.vertices.shape[0] + 1, 2), dtype=numpy.int32)
+                numpy.rint(polygon.vertices + polygon.offset, out=xy_closed[:-1], casting='unsafe')
+                xy_closed[-1] = xy_closed[0]
+                boundary = gdsii.elements.Boundary(
+                    layer=layer,
+                    data_type=data_type,
+                    xy=xy_closed,
+                    )
                 boundary.properties = properties
                 elements.append(boundary)
     return elements
@@ -497,11 +525,13 @@ def _labels_to_texts(labels: List[Label]) -> List[gdsii.elements.Text]:
     for label in labels:
         properties = _annotations_to_properties(label.annotations, 128)
         layer, text_type = _mlayer2gds(label.layer)
-        xy = numpy.round([label.offset]).astype(int)
-        text = gdsii.elements.Text(layer=layer,
-                                   text_type=text_type,
-                                   xy=xy,
-                                   string=label.string.encode('ASCII'))
+        xy = rint_cast([label.offset])
+        text = gdsii.elements.Text(
+            layer=layer,
+            text_type=text_type,
+            xy=xy,
+            string=label.string.encode('ASCII'),
+            )
         text.properties = properties
         texts.append(text)
     return texts

masque/label.py

@@ -6,14 +6,13 @@ from numpy.typing import ArrayLike, NDArray
 
 from .repetition import Repetition
 from .utils import rotation_matrix_2d, layer_t, AutoSlots, annotations_t
-from .traits import PositionableImpl, LayerableImpl, Copyable, Pivotable, LockableImpl, RepeatableImpl
-from .traits import AnnotatableImpl
+from .traits import PositionableImpl, LayerableImpl, Copyable, Pivotable, RepeatableImpl, AnnotatableImpl
 
 
 L = TypeVar('L', bound='Label')
 
 
-class Label(PositionableImpl, LayerableImpl, LockableImpl, RepeatableImpl, AnnotatableImpl,
+class Label(PositionableImpl, LayerableImpl, RepeatableImpl, AnnotatableImpl,
             Pivotable, Copyable, metaclass=AutoSlots):
     """
     A text annotation with a position and layer (but no size; it is not drawn)
@@ -49,33 +48,23 @@ class Label(PositionableImpl, LayerableImpl, LockableImpl, RepeatableImpl, Annot
             layer: layer_t = 0,
             repetition: Optional[Repetition] = None,
             annotations: Optional[annotations_t] = None,
-            locked: bool = False,
             identifier: Tuple = (),
             ) -> None:
-        LockableImpl.unlock(self)
         self.identifier = identifier
         self.string = string
         self.offset = numpy.array(offset, dtype=float, copy=True)
         self.layer = layer
         self.repetition = repetition
         self.annotations = annotations if annotations is not None else {}
-        self.set_locked(locked)
 
     def __copy__(self: L) -> L:
-        return type(self)(string=self.string,
-                          offset=self.offset.copy(),
-                          layer=self.layer,
-                          repetition=self.repetition,
-                          locked=self.locked,
-                          identifier=self.identifier)
-
-    def __deepcopy__(self: L, memo: Dict = None) -> L:
-        memo = {} if memo is None else memo
-        new = copy.copy(self)
-        LockableImpl.unlock(new)
-        new._offset = self._offset.copy()
-        new.set_locked(self.locked)
-        return new
+        return type(self)(
+            string=self.string,
+            offset=self.offset.copy(),
+            layer=self.layer,
+            repetition=self.repetition,
+            identifier=self.identifier,
+            )
 
     def rotate_around(self: L, pivot: ArrayLike, rotation: float) -> L:
         """
@@ -107,16 +96,5 @@ class Label(PositionableImpl, LayerableImpl, LockableImpl, RepeatableImpl, Annot
         """
         return numpy.array([self.offset, self.offset])
 
-    def lock(self: L) -> L:
-        PositionableImpl._lock(self)
-        LockableImpl.lock(self)
-        return self
-
-    def unlock(self: L) -> L:
-        LockableImpl.unlock(self)
-        PositionableImpl._unlock(self)
-        return self
-
     def __repr__(self) -> str:
-        locked = ' L' if self.locked else ''
-        return f'<Label "{self.string}" l{self.layer} o{self.offset}{locked}>'
+        return f'<Label "{self.string}" l{self.layer} o{self.offset}>'

masque/library/library.py

@@ -332,6 +332,8 @@ class Library:
         self.cache = {}
         return self
 
+    def __deepcopy__(self: L, memo: Optional[Dict] = None) -> L:
+        raise LibraryError('Library cannot be deepcopied -- python copy.deepcopy() does not copy closures!')
 
 r"""
     #   Add a filter for names which aren't added

masque/pattern.py

@@ -18,9 +18,8 @@ from .subpattern import SubPattern
 from .shapes import Shape, Polygon
 from .label import Label
 from .utils import rotation_matrix_2d, normalize_mirror, AutoSlots, annotations_t
-from .error import PatternError, PatternLockedError
-from .traits import LockableImpl, AnnotatableImpl, Scalable, Mirrorable
-from .traits import Rotatable, Positionable
+from .error import PatternError
+from .traits import AnnotatableImpl, Scalable, Mirrorable, Rotatable, Positionable
 
 
 visitor_function_t = Callable[['Pattern', Tuple['Pattern'], Dict, NDArray[numpy.float64]], 'Pattern']
@@ -29,7 +28,7 @@ visitor_function_t = Callable[['Pattern', Tuple['Pattern'], Dict, NDArray[numpy.
 P = TypeVar('P', bound='Pattern')
 
 
-class Pattern(LockableImpl, AnnotatableImpl, Mirrorable, metaclass=AutoSlots):
+class Pattern(AnnotatableImpl, Mirrorable, metaclass=AutoSlots):
     """
     2D layout consisting of some set of shapes, labels, and references to other Pattern objects
      (via SubPattern). Shapes are assumed to inherit from masque.shapes.Shape or provide equivalent functions.
@@ -61,7 +60,6 @@ class Pattern(LockableImpl, AnnotatableImpl, Mirrorable, metaclass=AutoSlots):
             labels: Sequence[Label] = (),
             subpatterns: Sequence[SubPattern] = (),
             annotations: Optional[annotations_t] = None,
-            locked: bool = False,
             ) -> None:
         """
         Basic init; arguments get assigned to member variables.
@@ -72,9 +70,7 @@ class Pattern(LockableImpl, AnnotatableImpl, Mirrorable, metaclass=AutoSlots):
             labels: Initial labels in the Pattern
             subpatterns: Initial subpatterns in the Pattern
             name: An identifier for the Pattern
-            locked: Whether to lock the pattern after construction
         """
-        LockableImpl.unlock(self)
         if isinstance(shapes, list):
             self.shapes = shapes
         else:
@@ -92,15 +88,15 @@ class Pattern(LockableImpl, AnnotatableImpl, Mirrorable, metaclass=AutoSlots):
 
         self.annotations = annotations if annotations is not None else {}
         self.name = name
-        self.set_locked(locked)
 
     def __copy__(self, memo: Dict = None) -> 'Pattern':
-        return Pattern(name=self.name,
-                       shapes=copy.deepcopy(self.shapes),
-                       labels=copy.deepcopy(self.labels),
-                       subpatterns=[copy.copy(sp) for sp in self.subpatterns],
-                       annotations=copy.deepcopy(self.annotations),
-                       locked=self.locked)
+        return Pattern(
+            name=self.name,
+            shapes=copy.deepcopy(self.shapes),
+            labels=copy.deepcopy(self.labels),
+            subpatterns=[copy.copy(sp) for sp in self.subpatterns],
+            annotations=copy.deepcopy(self.annotations),
+            )
 
     def __deepcopy__(self, memo: Dict = None) -> 'Pattern':
         memo = {} if memo is None else memo
@@ -110,7 +106,7 @@ class Pattern(LockableImpl, AnnotatableImpl, Mirrorable, metaclass=AutoSlots):
             labels=copy.deepcopy(self.labels, memo),
             subpatterns=copy.deepcopy(self.subpatterns, memo),
             annotations=copy.deepcopy(self.annotations, memo),
-            locked=self.locked)
+            )
         return new
 
     def rename(self: P, name: str) -> P:
@@ -307,14 +303,13 @@ class Pattern(LockableImpl, AnnotatableImpl, Mirrorable, metaclass=AutoSlots):
                 sp_transform = False
 
             if subpattern.pattern is not None:
-                result = subpattern.pattern.dfs(visit_before=visit_before,
-                                                visit_after=visit_after,
-                                                transform=sp_transform,
-                                                memo=memo,
-                                                hierarchy=hierarchy + (self,))
-                if result is not subpattern.pattern:
-                    # skip assignment to avoid PatternLockedError unless modified
-                    subpattern.pattern = result
+                subpattern.patern = subpattern.pattern.dfs(
+                    visit_before=visit_before,
+                    visit_after=visit_after,
+                    transform=sp_transform,
+                    memo=memo,
+                    hierarchy=hierarchy + (self,),
+                    )
 
         if visit_after is not None:
             pat = visit_after(pat, hierarchy=hierarchy, memo=memo, transform=transform)         # type: ignore
@@ -454,7 +449,7 @@ class Pattern(LockableImpl, AnnotatableImpl, Mirrorable, metaclass=AutoSlots):
             A list of `(Ni, 2)` `numpy.ndarray`s specifying vertices of the polygons. Each ndarray
              is of the form `[[x0, y0], [x1, y1],...]`.
         """
-        pat = self.deepcopy().deepunlock().polygonize().flatten()
+        pat = self.deepcopy().polygonize().flatten()
         return [shape.vertices + shape.offset for shape in pat.shapes]      # type: ignore      # mypy can't figure out that shapes are all Polygons now
 
     @overload
@@ -872,66 +867,6 @@ class Pattern(LockableImpl, AnnotatableImpl, Mirrorable, metaclass=AutoSlots):
         self.subpatterns.append(SubPattern(*args, **kwargs))
         return self
 
-    def lock(self: P) -> P:
-        """
-        Lock the pattern, raising an exception if it is modified.
-        Also see `deeplock()`.
-
-        Returns:
-            self
-        """
-        if not self.locked:
-            self.shapes = tuple(self.shapes)
-            self.labels = tuple(self.labels)
-            self.subpatterns = tuple(self.subpatterns)
-            LockableImpl.lock(self)
-        return self
-
-    def unlock(self: P) -> P:
-        """
-        Unlock the pattern
-
-        Returns:
-            self
-        """
-        if self.locked:
-            LockableImpl.unlock(self)
-            self.shapes = list(self.shapes)
-            self.labels = list(self.labels)
-            self.subpatterns = list(self.subpatterns)
-        return self
-
-    def deeplock(self: P) -> P:
-        """
-        Recursively lock the pattern, all referenced shapes, subpatterns, and labels.
-
-        Returns:
-            self
-        """
-        self.lock()
-        for ss in chain(self.shapes, self.labels):
-            ss.lock()       # type: ignore      # mypy struggles with multiple inheritance :(
-        for sp in self.subpatterns:
-            sp.deeplock()
-        return self
-
-    def deepunlock(self: P) -> P:
-        """
-        Recursively unlock the pattern, all referenced shapes, subpatterns, and labels.
-
-        This is dangerous unless you have just performed a deepcopy, since anything
-          you change will be changed everywhere it is referenced!
-
-        Return:
-            self
-        """
-        self.unlock()
-        for ss in chain(self.shapes, self.labels):
-            ss.unlock()       # type: ignore      # mypy struggles with multiple inheritance :(
-        for sp in self.subpatterns:
-            sp.deepunlock()
-        return self
-
     @staticmethod
     def load(filename: str) -> 'Pattern':
         """
@@ -1046,5 +981,4 @@ class Pattern(LockableImpl, AnnotatableImpl, Mirrorable, metaclass=AutoSlots):
         return toplevel
 
     def __repr__(self) -> str:
-        locked = ' L' if self.locked else ''
-        return (f'<Pattern "{self.name}": sh{len(self.shapes)} sp{len(self.subpatterns)} la{len(self.labels)}{locked}>')
+        return (f'<Pattern "{self.name}": sh{len(self.shapes)} sp{len(self.subpatterns)} la{len(self.labels)}>')

masque/repetition.py

@@ -12,7 +12,7 @@ from numpy.typing import ArrayLike, NDArray
 
 from .error import PatternError
 from .utils import rotation_matrix_2d, AutoSlots
-from .traits import LockableImpl, Copyable, Scalable, Rotatable, Mirrorable
+from .traits import Copyable, Scalable, Rotatable, Mirrorable
 
 
 class Repetition(Copyable, Rotatable, Mirrorable, Scalable, metaclass=ABCMeta):
@@ -30,7 +30,7 @@ class Repetition(Copyable, Rotatable, Mirrorable, Scalable, metaclass=ABCMeta):
         pass
 
 
-class Grid(LockableImpl, Repetition, metaclass=AutoSlots):
+class Grid(Repetition, metaclass=AutoSlots):
     """
     `Grid` describes a 2D grid formed by two basis vectors and two 'counts' (sizes).
 
@@ -67,7 +67,6 @@ class Grid(LockableImpl, Repetition, metaclass=AutoSlots):
             a_count: int,
             b_vector: Optional[ArrayLike] = None,
             b_count: Optional[int] = 1,
-            locked: bool = False,
             ) -> None:
         """
         Args:
@@ -79,7 +78,6 @@ class Grid(LockableImpl, Repetition, metaclass=AutoSlots):
                 Can be omitted when specifying a 1D array.
             b_count: Number of elements in the `b_vector` direction.
                 Should be omitted if `b_vector` was omitted.
-            locked: Whether the `Grid` is locked after initialization.
 
         Raises:
             PatternError if `b_*` inputs conflict with each other
@@ -99,26 +97,18 @@ class Grid(LockableImpl, Repetition, metaclass=AutoSlots):
         if b_count < 1:
             raise PatternError(f'Repetition has too-small b_count: {b_count}')
 
-        object.__setattr__(self, 'locked', False)
         self.a_vector = a_vector        # type: ignore     # setter handles type conversion
         self.b_vector = b_vector        # type: ignore     # setter handles type conversion
         self.a_count = a_count
         self.b_count = b_count
-        self.locked = locked
 
     def __copy__(self) -> 'Grid':
-        new = Grid(a_vector=self.a_vector.copy(),
-                   b_vector=copy.copy(self.b_vector),
-                   a_count=self.a_count,
-                   b_count=self.b_count,
-                   locked=self.locked)
-        return new
-
-    def __deepcopy__(self, memo: Dict = None) -> 'Grid':
-        memo = {} if memo is None else memo
-        new = copy.copy(self)
-        LocakbleImpl.unlock(new)
-        new.locked = self.locked
+        new = Grid(
+            a_vector=self.a_vector.copy(),
+            b_vector=copy.copy(self.b_vector),
+            a_count=self.a_count,
+            b_count=self.b_count,
+            )
         return new
 
     # a_vector property
@@ -242,36 +232,9 @@ class Grid(LockableImpl, Repetition, metaclass=AutoSlots):
             self.b_vector *= c
         return self
 
-    def lock(self) -> 'Grid':
-        """
-        Lock the `Grid`, disallowing changes.
-
-        Returns:
-            self
-        """
-        self.a_vector.flags.writeable = False
-        if self.b_vector is not None:
-            self.b_vector.flags.writeable = False
-        LockableImpl.lock(self)
-        return self
-
-    def unlock(self) -> 'Grid':
-        """
-        Unlock the `Grid`
-
-        Returns:
-            self
-        """
-        self.a_vector.flags.writeable = True
-        if self.b_vector is not None:
-            self.b_vector.flags.writeable = True
-        LockableImpl.unlock(self)
-        return self
-
     def __repr__(self) -> str:
-        locked = ' L' if self.locked else ''
         bv = f', {self.b_vector}' if self.b_vector is not None else ''
-        return (f'<Grid {self.a_count}x{self.b_count} ({self.a_vector}{bv}){locked}>')
+        return (f'<Grid {self.a_count}x{self.b_count} ({self.a_vector}{bv})>')
 
     def __eq__(self, other: Any) -> bool:
         if not isinstance(other, type(self)):
@@ -286,12 +249,10 @@ class Grid(LockableImpl, Repetition, metaclass=AutoSlots):
             return False
         if any(self.b_vector[ii] != other.b_vector[ii] for ii in range(2)):
             return False
-        if self.locked != other.locked:
-            return False
         return True
 
 
-class Arbitrary(LockableImpl, Repetition, metaclass=AutoSlots):
+class Arbitrary(Repetition, metaclass=AutoSlots):
     """
     `Arbitrary` is a simple list of (absolute) displacements for instances.
 
@@ -320,48 +281,19 @@ class Arbitrary(LockableImpl, Repetition, metaclass=AutoSlots):
     def __init__(
             self,
             displacements: ArrayLike,
-            locked: bool = False,
             ) -> None:
         """
         Args:
             displacements: List of vectors (Nx2 ndarray) specifying displacements.
-            locked: Whether the object is locked after initialization.
         """
-        object.__setattr__(self, 'locked', False)
         self.displacements = displacements
-        self.locked = locked
-
-    def lock(self) -> 'Arbitrary':
-        """
-        Lock the object, disallowing changes.
-
-        Returns:
-            self
-        """
-        self._displacements.flags.writeable = False
-        LockableImpl.lock(self)
-        return self
-
-    def unlock(self) -> 'Arbitrary':
-        """
-        Unlock the object
-
-        Returns:
-            self
-        """
-        self._displacements.flags.writeable = True
-        LockableImpl.unlock(self)
-        return self
 
     def __repr__(self) -> str:
-        locked = ' L' if self.locked else ''
-        return (f'<Arbitrary {len(self.displacements)}pts {locked}>')
+        return (f'<Arbitrary {len(self.displacements)}pts>')
 
     def __eq__(self, other: Any) -> bool:
         if not isinstance(other, type(self)):
             return False
-        if self.locked != other.locked:
-            return False
         return numpy.array_equal(self.displacements, other.displacements)
 
     def rotate(self, rotation: float) -> 'Arbitrary':

masque/shapes/arc.py

@@ -10,7 +10,6 @@ from . import Shape, Polygon, normalized_shape_tuple, DEFAULT_POLY_NUM_POINTS
 from .. import PatternError
 from ..repetition import Repetition
 from ..utils import is_scalar, layer_t, AutoSlots, annotations_t
-from ..traits import LockableImpl
 
 
 class Arc(Shape, metaclass=AutoSlots):
@@ -166,10 +165,8 @@ class Arc(Shape, metaclass=AutoSlots):
             dose: float = 1.0,
             repetition: Optional[Repetition] = None,
             annotations: Optional[annotations_t] = None,
-            locked: bool = False,
             raw: bool = False,
             ) -> None:
-        LockableImpl.unlock(self)
         self.identifier = ()
         if raw:
             assert(isinstance(radii, numpy.ndarray))
@@ -197,18 +194,6 @@ class Arc(Shape, metaclass=AutoSlots):
         self.poly_num_points = poly_num_points
         self.poly_max_arclen = poly_max_arclen
         [self.mirror(a) for a, do in enumerate(mirrored) if do]
-        self.set_locked(locked)
-
-    def __deepcopy__(self, memo: Dict = None) -> 'Arc':
-        memo = {} if memo is None else memo
-        new = copy.copy(self)
-        Shape.unlock(new)
-        new._offset = self._offset.copy()
-        new._radii = self._radii.copy()
-        new._angles = self._angles.copy()
-        new._annotations = copy.deepcopy(self._annotations)
-        new.set_locked(self.locked)
-        return new
 
     def to_polygons(
             self,
@@ -429,21 +414,8 @@ class Arc(Shape, metaclass=AutoSlots):
             a.append((a0, a1))
         return numpy.array(a)
 
-    def lock(self) -> 'Arc':
-        self.radii.flags.writeable = False
-        self.angles.flags.writeable = False
-        Shape.lock(self)
-        return self
-
-    def unlock(self) -> 'Arc':
-        Shape.unlock(self)
-        self.radii.flags.writeable = True
-        self.angles.flags.writeable = True
-        return self
-
     def __repr__(self) -> str:
         angles = f' a°{numpy.rad2deg(self.angles)}'
         rotation = f' r°{numpy.rad2deg(self.rotation):g}' if self.rotation != 0 else ''
         dose = f' d{self.dose:g}' if self.dose != 1 else ''
-        locked = ' L' if self.locked else ''
-        return f'<Arc l{self.layer} o{self.offset} r{self.radii}{angles} w{self.width:g}{rotation}{dose}{locked}>'
+        return f'<Arc l{self.layer} o{self.offset} r{self.radii}{angles} w{self.width:g}{rotation}{dose}>'

masque/shapes/circle.py

@@ -9,7 +9,6 @@ from . import Shape, Polygon, normalized_shape_tuple, DEFAULT_POLY_NUM_POINTS
 from .. import PatternError
 from ..repetition import Repetition
 from ..utils import is_scalar, layer_t, AutoSlots, annotations_t
-from ..traits import LockableImpl
 
 
 class Circle(Shape, metaclass=AutoSlots):
@@ -54,10 +53,8 @@ class Circle(Shape, metaclass=AutoSlots):
             dose: float = 1.0,
             repetition: Optional[Repetition] = None,
             annotations: Optional[annotations_t] = None,
-            locked: bool = False,
             raw: bool = False,
             ) -> None:
-        LockableImpl.unlock(self)
         self.identifier = ()
         if raw:
             assert(isinstance(offset, numpy.ndarray))
@@ -76,16 +73,6 @@ class Circle(Shape, metaclass=AutoSlots):
             self.dose = dose
         self.poly_num_points = poly_num_points
         self.poly_max_arclen = poly_max_arclen
-        self.set_locked(locked)
-
-    def __deepcopy__(self, memo: Dict = None) -> 'Circle':
-        memo = {} if memo is None else memo
-        new = copy.copy(self)
-        Shape.unlock(new)
-        new._offset = self._offset.copy()
-        new._annotations = copy.deepcopy(self._annotations)
-        new.set_locked(self.locked)
-        return new
 
     def to_polygons(
             self,
@@ -138,5 +125,4 @@ class Circle(Shape, metaclass=AutoSlots):
 
     def __repr__(self) -> str:
         dose = f' d{self.dose:g}' if self.dose != 1 else ''
-        locked = ' L' if self.locked else ''
-        return f'<Circle l{self.layer} o{self.offset} r{self.radius:g}{dose}{locked}>'
+        return f'<Circle l{self.layer} o{self.offset} r{self.radius:g}{dose}>'

masque/shapes/ellipse.py

@@ -10,7 +10,6 @@ from . import Shape, Polygon, normalized_shape_tuple, DEFAULT_POLY_NUM_POINTS
 from .. import PatternError
 from ..repetition import Repetition
 from ..utils import is_scalar, rotation_matrix_2d, layer_t, AutoSlots, annotations_t
-from ..traits import LockableImpl
 
 
 class Ellipse(Shape, metaclass=AutoSlots):
@@ -101,10 +100,8 @@ class Ellipse(Shape, metaclass=AutoSlots):
             dose: float = 1.0,
             repetition: Optional[Repetition] = None,
             annotations: Optional[annotations_t] = None,
-            locked: bool = False,
             raw: bool = False,
             ) -> None:
-        LockableImpl.unlock(self)
         self.identifier = ()
         if raw:
             assert(isinstance(radii, numpy.ndarray))
@@ -127,17 +124,6 @@ class Ellipse(Shape, metaclass=AutoSlots):
         [self.mirror(a) for a, do in enumerate(mirrored) if do]
         self.poly_num_points = poly_num_points
         self.poly_max_arclen = poly_max_arclen
-        self.set_locked(locked)
-
-    def __deepcopy__(self, memo: Dict = None) -> 'Ellipse':
-        memo = {} if memo is None else memo
-        new = copy.copy(self)
-        Shape.unlock(new)
-        new._offset = self._offset.copy()
-        new._radii = self._radii.copy()
-        new._annotations = copy.deepcopy(self._annotations)
-        new.set_locked(self.locked)
-        return new
 
     def to_polygons(
             self,
@@ -209,18 +195,7 @@ class Ellipse(Shape, metaclass=AutoSlots):
                 (self.offset, scale / norm_value, angle, False, self.dose),
                 lambda: Ellipse(radii=radii * norm_value, layer=self.layer))
 
-    def lock(self) -> 'Ellipse':
-        self.radii.flags.writeable = False
-        Shape.lock(self)
-        return self
-
-    def unlock(self) -> 'Ellipse':
-        Shape.unlock(self)
-        self.radii.flags.writeable = True
-        return self
-
     def __repr__(self) -> str:
         rotation = f' r{self.rotation*180/pi:g}' if self.rotation != 0 else ''
         dose = f' d{self.dose:g}' if self.dose != 1 else ''
-        locked = ' L' if self.locked else ''
-        return f'<Ellipse l{self.layer} o{self.offset} r{self.radii}{rotation}{dose}{locked}>'
+        return f'<Ellipse l{self.layer} o{self.offset} r{self.radii}{rotation}{dose}>'

masque/shapes/path.py

@@ -11,7 +11,6 @@ from .. import PatternError
 from ..repetition import Repetition
 from ..utils import is_scalar, rotation_matrix_2d, layer_t, AutoSlots
 from ..utils import remove_colinear_vertices, remove_duplicate_vertices, annotations_t
-from ..traits import LockableImpl
 
 
 class PathCap(Enum):
@@ -155,10 +154,8 @@ class Path(Shape, metaclass=AutoSlots):
             dose: float = 1.0,
             repetition: Optional[Repetition] = None,
             annotations: Optional[annotations_t] = None,
-            locked: bool = False,
             raw: bool = False,
             ) -> None:
-        LockableImpl.unlock(self)
         self._cap_extensions = None     # Since .cap setter might access it
 
         self.identifier = ()
@@ -187,18 +184,15 @@ class Path(Shape, metaclass=AutoSlots):
             self.cap_extensions = cap_extensions
         self.rotate(rotation)
         [self.mirror(a) for a, do in enumerate(mirrored) if do]
-        self.set_locked(locked)
 
     def __deepcopy__(self, memo: Dict = None) -> 'Path':
         memo = {} if memo is None else memo
         new = copy.copy(self)
-        Shape.unlock(new)
         new._offset = self._offset.copy()
         new._vertices = self._vertices.copy()
         new._cap = copy.deepcopy(self._cap, memo)
         new._cap_extensions = copy.deepcopy(self._cap_extensions, memo)
         new._annotations = copy.deepcopy(self._annotations)
-        new.set_locked(self.locked)
         return new
 
     @staticmethod
@@ -424,22 +418,7 @@ class Path(Shape, metaclass=AutoSlots):
             extensions = numpy.zeros(2)
         return extensions
 
-    def lock(self) -> 'Path':
-        self.vertices.flags.writeable = False
-        if self.cap_extensions is not None:
-            self.cap_extensions.flags.writeable = False
-        Shape.lock(self)
-        return self
-
-    def unlock(self) -> 'Path':
-        Shape.unlock(self)
-        self.vertices.flags.writeable = True
-        if self.cap_extensions is not None:
-            self.cap_extensions.flags.writeable = True
-        return self
-
     def __repr__(self) -> str:
         centroid = self.offset + self.vertices.mean(axis=0)
         dose = f' d{self.dose:g}' if self.dose != 1 else ''
-        locked = ' L' if self.locked else ''
-        return f'<Path l{self.layer} centroid {centroid} v{len(self.vertices)} w{self.width} c{self.cap}{dose}{locked}>'
+        return f'<Path l{self.layer} centroid {centroid} v{len(self.vertices)} w{self.width} c{self.cap}{dose}>'

masque/shapes/polygon.py

@@ -10,7 +10,6 @@ from .. import PatternError
 from ..repetition import Repetition
 from ..utils import is_scalar, rotation_matrix_2d, layer_t, AutoSlots
 from ..utils import remove_colinear_vertices, remove_duplicate_vertices, annotations_t
-from ..traits import LockableImpl
 
 
 class Polygon(Shape, metaclass=AutoSlots):
@@ -83,10 +82,8 @@ class Polygon(Shape, metaclass=AutoSlots):
             dose: float = 1.0,
             repetition: Optional[Repetition] = None,
             annotations: Optional[annotations_t] = None,
-            locked: bool = False,
             raw: bool = False,
             ) -> None:
-        LockableImpl.unlock(self)
         self.identifier = ()
         if raw:
             assert(isinstance(vertices, numpy.ndarray))
@@ -106,17 +103,6 @@ class Polygon(Shape, metaclass=AutoSlots):
             self.dose = dose
         self.rotate(rotation)
         [self.mirror(a) for a, do in enumerate(mirrored) if do]
-        self.set_locked(locked)
-
-    def __deepcopy__(self, memo: Optional[Dict] = None) -> 'Polygon':
-        memo = {} if memo is None else memo
-        new = copy.copy(self)
-        Shape.unlock(new)
-        new._offset = self._offset.copy()
-        new._vertices = self._vertices.copy()
-        new._annotations = copy.deepcopy(self._annotations)
-        new.set_locked(self.locked)
-        return new
 
     @staticmethod
     def square(
@@ -430,18 +416,7 @@ class Polygon(Shape, metaclass=AutoSlots):
         self.vertices = remove_colinear_vertices(self.vertices, closed_path=True)
         return self
 
-    def lock(self) -> 'Polygon':
-        self.vertices.flags.writeable = False
-        Shape.lock(self)
-        return self
-
-    def unlock(self) -> 'Polygon':
-        Shape.unlock(self)
-        self.vertices.flags.writeable = True
-        return self
-
     def __repr__(self) -> str:
         centroid = self.offset + self.vertices.mean(axis=0)
         dose = f' d{self.dose:g}' if self.dose != 1 else ''
-        locked = ' L' if self.locked else ''
-        return f'<Polygon l{self.layer} centroid {centroid} v{len(self.vertices)}{dose}{locked}>'
+        return f'<Polygon l{self.layer} centroid {centroid} v{len(self.vertices)}{dose}>'

masque/shapes/shape.py

@@ -4,10 +4,11 @@ from abc import ABCMeta, abstractmethod
 import numpy
 from numpy.typing import NDArray, ArrayLike
 
-from ..traits import (PositionableImpl, LayerableImpl, DoseableImpl,
-                      Rotatable, Mirrorable, Copyable, Scalable,
-                      PivotableImpl, LockableImpl, RepeatableImpl,
-                      AnnotatableImpl)
+from ..traits import (
+    PositionableImpl, LayerableImpl, DoseableImpl,
+    Rotatable, Mirrorable, Copyable, Scalable,
+    PivotableImpl, RepeatableImpl, AnnotatableImpl,
+    )
 
 if TYPE_CHECKING:
     from . import Polygon
@@ -27,7 +28,7 @@ T = TypeVar('T', bound='Shape')
 
 
 class Shape(PositionableImpl, LayerableImpl, DoseableImpl, Rotatable, Mirrorable, Copyable, Scalable,
-            PivotableImpl, RepeatableImpl, LockableImpl, AnnotatableImpl, metaclass=ABCMeta):
+            PivotableImpl, RepeatableImpl, AnnotatableImpl, metaclass=ABCMeta):
     """
     Abstract class specifying functions common to all shapes.
     """
@@ -36,13 +37,6 @@ class Shape(PositionableImpl, LayerableImpl, DoseableImpl, Rotatable, Mirrorable
     identifier: Tuple
     """ An arbitrary identifier for the shape, usually empty but used by `Pattern.flatten()` """
 
-    def __copy__(self) -> 'Shape':
-        cls = self.__class__
-        new = cls.__new__(cls)
-        for name in self.__slots__:     # type: str
-            object.__setattr__(new, name, getattr(self, name))
-        return new
-
     '''
     --- Abstract methods
     '''
@@ -182,7 +176,7 @@ class Shape(PositionableImpl, LayerableImpl, DoseableImpl, Rotatable, Mirrorable
                 xs2 = (xs[:-1] + xs[1:]) / 2
                 inds2 = get_grid_inds(xs2)
 
-                xinds = numpy.round(numpy.arange(gxi_min, gxi_max - 0.99, 1 / 3)).astype(int)
+                xinds = numpy.rint(numpy.arange(gxi_min, gxi_max - 0.99, 1 / 3), dtype=numpy.int64, casting='unsafe')
 
                 # interleave the results
                 yinds = xinds.copy()
@@ -293,7 +287,7 @@ class Shape(PositionableImpl, LayerableImpl, DoseableImpl, Rotatable, Mirrorable
             for contour in contours:
                 # /2 deals with supersampling
                 # +.5 deals with the fact that our 0-edge becomes -.5 in the super-sampled contour output
-                snapped_contour = numpy.round((contour + .5) / 2).astype(int)
+                snapped_contour = numpy.rint((contour + .5) / 2, dtype=numpy.int64, casting='unsafe')
                 vertices = numpy.hstack((grx[snapped_contour[:, None, 0] + offset_i[0]],
                                          gry[snapped_contour[:, None, 1] + offset_i[1]]))
 
@@ -303,13 +297,3 @@ class Shape(PositionableImpl, LayerableImpl, DoseableImpl, Rotatable, Mirrorable
                     dose=self.dose))
 
         return manhattan_polygons
-
-    def lock(self: T) -> T:
-        PositionableImpl._lock(self)
-        LockableImpl.lock(self)
-        return self
-
-    def unlock(self: T) -> T:
-        LockableImpl.unlock(self)
-        PositionableImpl._unlock(self)
-        return self

masque/shapes/text.py

@@ -11,7 +11,6 @@ from ..repetition import Repetition
 from ..traits import RotatableImpl
 from ..utils import is_scalar, get_bit, normalize_mirror, layer_t, AutoSlots
 from ..utils import annotations_t
-from ..traits import LockableImpl
 
 # Loaded on use:
 # from freetype import Face
@@ -74,10 +73,8 @@ class Text(RotatableImpl, Shape, metaclass=AutoSlots):
             dose: float = 1.0,
             repetition: Optional[Repetition] = None,
             annotations: Optional[annotations_t] = None,
-            locked: bool = False,
             raw: bool = False,
             ) -> None:
-        LockableImpl.unlock(self)
         self.identifier = ()
         if raw:
             assert(isinstance(offset, numpy.ndarray))
@@ -102,17 +99,6 @@ class Text(RotatableImpl, Shape, metaclass=AutoSlots):
             self.repetition = repetition
             self.annotations = annotations if annotations is not None else {}
         self.font_path = font_path
-        self.set_locked(locked)
-
-    def __deepcopy__(self, memo: Dict = None) -> 'Text':
-        memo = {} if memo is None else memo
-        new = copy.copy(self)
-        Shape.unlock(new)
-        new._offset = self._offset.copy()
-        new._mirrored = copy.deepcopy(self._mirrored, memo)
-        new._annotations = copy.deepcopy(self._annotations)
-        new.set_locked(self.locked)
-        return new
 
     def to_polygons(
             self,
@@ -259,19 +245,8 @@ def get_char_as_polygons(
 
     return polygons, advance
 
-    def lock(self) -> 'Text':
-        self.mirrored.flags.writeable = False
-        Shape.lock(self)
-        return self
-
-    def unlock(self) -> 'Text':
-        Shape.unlock(self)
-        self.mirrored.flags.writeable = True
-        return self
-
     def __repr__(self) -> str:
         rotation = f' r°{self.rotation*180/pi:g}' if self.rotation != 0 else ''
         dose = f' d{self.dose:g}' if self.dose != 1 else ''
-        locked = ' L' if self.locked else ''
         mirrored = ' m{:d}{:d}'.format(*self.mirrored) if self.mirrored.any() else ''
-        return f'<TextShape "{self.string}" l{self.layer} o{self.offset} h{self.height:g}{rotation}{mirrored}{dose}{locked}>'
+        return f'<TextShape "{self.string}" l{self.layer} o{self.offset} h{self.height:g}{rotation}{mirrored}{dose}>'

masque/subpattern.py

@@ -14,9 +14,10 @@ from numpy.typing import NDArray, ArrayLike
 from .error import PatternError
 from .utils import is_scalar, AutoSlots, annotations_t
 from .repetition import Repetition
-from .traits import (PositionableImpl, DoseableImpl, RotatableImpl, ScalableImpl,
-                     Mirrorable, PivotableImpl, Copyable, LockableImpl, RepeatableImpl,
-                     AnnotatableImpl)
+from .traits import (
+    PositionableImpl, DoseableImpl, RotatableImpl, ScalableImpl,
+    Mirrorable, PivotableImpl, Copyable, RepeatableImpl, AnnotatableImpl
+    )
 
 
 if TYPE_CHECKING:
@@ -27,16 +28,17 @@ S = TypeVar('S', bound='SubPattern')
 
 
 class SubPattern(PositionableImpl, DoseableImpl, RotatableImpl, ScalableImpl, Mirrorable,
-                 PivotableImpl, Copyable, RepeatableImpl, LockableImpl, AnnotatableImpl,
+                 PivotableImpl, Copyable, RepeatableImpl, AnnotatableImpl,
                  metaclass=AutoSlots):
     """
     SubPattern provides basic support for nesting Pattern objects within each other, by adding
      offset, rotation, scaling, and associated methods.
     """
-    __slots__ = ('_pattern',
-                 '_mirrored',
-                 'identifier',
-                 )
+    __slots__ = (
+        '_pattern',
+        '_mirrored',
+        'identifier',
+        )
 
     _pattern: Optional['Pattern']
     """ The `Pattern` being instanced """
@@ -58,7 +60,6 @@ class SubPattern(PositionableImpl, DoseableImpl, RotatableImpl, ScalableImpl, Mi
             scale: float = 1.0,
             repetition: Optional[Repetition] = None,
             annotations: Optional[annotations_t] = None,
-            locked: bool = False,
             identifier: Tuple[Any, ...] = (),
             ) -> None:
         """
@@ -70,10 +71,8 @@ class SubPattern(PositionableImpl, DoseableImpl, RotatableImpl, ScalableImpl, Mi
             dose: Scaling factor applied to the dose.
             scale: Scaling factor applied to the pattern's geometry.
             repetition: TODO
-            locked: Whether the `SubPattern` is locked after initialization.
             identifier: Arbitrary tuple, used internally by some `masque` functions.
         """
-        LockableImpl.unlock(self)
         self.identifier = identifier
         self.pattern = pattern
         self.offset = offset
@@ -85,28 +84,18 @@ class SubPattern(PositionableImpl, DoseableImpl, RotatableImpl, ScalableImpl, Mi
         self.mirrored = mirrored
         self.repetition = repetition
         self.annotations = annotations if annotations is not None else {}
-        self.set_locked(locked)
 
     def __copy__(self) -> 'SubPattern':
-        new = SubPattern(pattern=self.pattern,
-                         offset=self.offset.copy(),
-                         rotation=self.rotation,
-                         dose=self.dose,
-                         scale=self.scale,
-                         mirrored=self.mirrored.copy(),
-                         repetition=copy.deepcopy(self.repetition),
-                         annotations=copy.deepcopy(self.annotations),
-                         locked=self.locked)
-        return new
-
-    def __deepcopy__(self, memo: Dict = None) -> 'SubPattern':
-        memo = {} if memo is None else memo
-        new = copy.copy(self)
-        LockableImpl.unlock(new)
-        new.pattern = copy.deepcopy(self.pattern, memo)
-        new.repetition = copy.deepcopy(self.repetition, memo)
-        new.annotations = copy.deepcopy(self.annotations, memo)
-        new.set_locked(self.locked)
+        new = SubPattern(
+            pattern=self.pattern,
+            offset=self.offset.copy(),
+            rotation=self.rotation,
+            dose=self.dose,
+            scale=self.scale,
+            mirrored=self.mirrored.copy(),
+            repetition=copy.deepcopy(self.repetition),
+            annotations=copy.deepcopy(self.annotations),
+            )
         return new
 
     # pattern property
@@ -139,7 +128,7 @@ class SubPattern(PositionableImpl, DoseableImpl, RotatableImpl, ScalableImpl, Mi
              `SubPattern`'s properties.
         """
         assert(self.pattern is not None)
-        pattern = self.pattern.deepcopy().deepunlock()
+        pattern = self.pattern.deepcopy()
         if self.scale != 1:
             pattern.scale_by(self.scale)
         if numpy.any(self.mirrored):
@@ -187,62 +176,10 @@ class SubPattern(PositionableImpl, DoseableImpl, RotatableImpl, ScalableImpl, Mi
             return None
         return self.as_pattern().get_bounds()
 
-    def lock(self: S) -> S:
-        """
-        Lock the SubPattern, disallowing changes
-
-        Returns:
-            self
-        """
-        self.mirrored.flags.writeable = False
-        PositionableImpl._lock(self)
-        LockableImpl.lock(self)
-        return self
-
-    def unlock(self: S) -> S:
-        """
-        Unlock the SubPattern
-
-        Returns:
-            self
-        """
-        LockableImpl.unlock(self)
-        PositionableImpl._unlock(self)
-        self.mirrored.flags.writeable = True
-        return self
-
-    def deeplock(self: S) -> S:
-        """
-        Recursively lock the SubPattern and its contained pattern
-
-        Returns:
-            self
-        """
-        assert(self.pattern is not None)
-        self.lock()
-        self.pattern.deeplock()
-        return self
-
-    def deepunlock(self: S) -> S:
-        """
-        Recursively unlock the SubPattern and its contained pattern
-
-        This is dangerous unless you have just performed a deepcopy, since
-        the subpattern and its components may be used in more than one once!
-
-        Returns:
-            self
-        """
-        assert(self.pattern is not None)
-        self.unlock()
-        self.pattern.deepunlock()
-        return self
-
     def __repr__(self) -> str:
         name = self.pattern.name if self.pattern is not None else None
         rotation = f' r{self.rotation*180/pi:g}' if self.rotation != 0 else ''
         scale = f' d{self.scale:g}' if self.scale != 1 else ''
         mirrored = ' m{:d}{:d}'.format(*self.mirrored) if self.mirrored.any() else ''
         dose = f' d{self.dose:g}' if self.dose != 1 else ''
-        locked = ' L' if self.locked else ''
-        return f'<SubPattern "{name}" at {self.offset}{rotation}{scale}{mirrored}{dose}{locked}>'
+        return f'<SubPattern "{name}" at {self.offset}{rotation}{scale}{mirrored}{dose}>'

masque/traits/__init__.py

@@ -9,5 +9,4 @@ from .repeatable import Repeatable, RepeatableImpl
 from .scalable import Scalable, ScalableImpl
 from .mirrorable import Mirrorable
 from .copyable import Copyable
-from .lockable import Lockable, LockableImpl
 from .annotatable import Annotatable, AnnotatableImpl

masque/traits/annotatable.py

@@ -44,9 +44,6 @@ class AnnotatableImpl(Annotatable, metaclass=ABCMeta):
     @property
     def annotations(self) -> annotations_t:
         return self._annotations
-#        # TODO: Find a way to make sure the subclass implements Lockable without dealing with diamond inheritance or this extra hasattr
-#        if hasattr(self, 'is_locked') and self.is_locked():
-#            return MappingProxyType(self._annotations)
 
     @annotations.setter
     def annotations(self, annotations: annotations_t):

masque/traits/lockable.py

@@ -1,103 +0,0 @@
-from typing import TypeVar, Dict, Tuple, Any
-from abc import ABCMeta, abstractmethod
-
-from ..error import PatternLockedError
-
-
-T = TypeVar('T', bound='Lockable')
-I = TypeVar('I', bound='LockableImpl')
-
-
-class Lockable(metaclass=ABCMeta):
-    """
-    Abstract class for all lockable entities
-    """
-    __slots__ = ()      # type: Tuple[str, ...]
-
-    '''
-    ---- Methods
-    '''
-    @abstractmethod
-    def lock(self: T) -> T:
-        """
-        Lock the object, disallowing further changes
-
-        Returns:
-            self
-        """
-        pass
-
-    @abstractmethod
-    def unlock(self: T) -> T:
-        """
-        Unlock the object, reallowing changes
-
-        Returns:
-            self
-        """
-        pass
-
-    @abstractmethod
-    def is_locked(self) -> bool:
-        """
-        Returns:
-            True if the object is locked
-        """
-        pass
-
-    def set_locked(self: T, locked: bool) -> T:
-        """
-        Locks or unlocks based on the argument.
-        No action if already in the requested state.
-
-        Args:
-            locked: State to set.
-
-        Returns:
-            self
-        """
-        if locked != self.is_locked():
-            if locked:
-                self.lock()
-            else:
-                self.unlock()
-        return self
-
-
-class LockableImpl(Lockable, metaclass=ABCMeta):
-    """
-    Simple implementation of Lockable
-    """
-    __slots__ = ()      # type: Tuple[str, ...]
-
-    locked: bool
-    """ If `True`, disallows changes to the object """
-
-    '''
-    ---- Non-abstract methods
-    '''
-    def __setattr__(self, name, value):
-        if self.locked and name != 'locked':
-            raise PatternLockedError()
-        object.__setattr__(self, name, value)
-
-    def __getstate__(self) -> Dict[str, Any]:
-        if hasattr(self, '__slots__'):
-            return {key: getattr(self, key) for key in self.__slots__}
-        else:
-            return self.__dict__
-
-    def __setstate__(self, state: Dict[str, Any]) -> None:
-        for k, v in state.items():
-            object.__setattr__(self, k, v)
-
-    def lock(self: I) -> I:
-        object.__setattr__(self, 'locked', True)
-        return self
-
-    def unlock(self: I) -> I:
-        object.__setattr__(self, 'locked', False)
-        return self
-
-    def is_locked(self) -> bool:
-        return self.locked

masque/traits/positionable.py

@@ -120,23 +120,3 @@ class PositionableImpl(Positionable, metaclass=ABCMeta):
     def translate(self: I, offset: ArrayLike) -> I:
         self._offset += offset   # type: ignore         # NDArray += ArrayLike should be fine??
         return self
-
-    def _lock(self: I) -> I:
-        """
-        Lock the entity, disallowing further changes
-
-        Returns:
-            self
-        """
-        self._offset.flags.writeable = False
-        return self
-
-    def _unlock(self: I) -> I:
-        """
-        Unlock the entity
-
-        Returns:
-            self
-        """
-        self._offset.flags.writeable = True
-        return self