prefab 1.0.3__py3-none-any.whl → 1.1.0__py3-none-any.whl

prefab/__init__.py

@@ -5,7 +5,7 @@ Usage:
     import prefab as pf
 """
 
-__version__ = "1.0.3"
+__version__ = "1.1.0"
 
 from . import compare, geometry, read, shapes
 from .device import BufferSpec, Device

prefab/device.py

@@ -16,9 +16,12 @@ from matplotlib.axes import Axes
 from matplotlib.patches import Rectangle
 from PIL import Image
 from pydantic import BaseModel, Field, conint, root_validator, validator
+from scipy.ndimage import distance_transform_edt
+from skimage import measure
+from skimage.morphology import closing, disk, opening, square
 from tqdm import tqdm
 
-from . import geometry
+from . import compare, geometry
 from .models import Model
 
 Image.MAX_IMAGE_PIXELS = None
@@ -224,6 +227,7 @@ class Device(BaseModel):
         model: Model,
         model_type: str,
         binarize: bool,
+        gpu: bool = False,
     ) -> "Device":
         try:
             with open(os.path.expanduser("~/.prefab.toml")) as file:
@@ -245,6 +249,7 @@ class Device(BaseModel):
                 "Signup/login and generate a new token.\n"
                 "See https://www.prefabphotonics.com/docs/guides/quickstart."
             ) from None
+
         headers = {
             "Authorization": f"Bearer {access_token}",
             "X-Refresh-Token": refresh_token,
@@ -258,84 +263,99 @@ class Device(BaseModel):
         }
         json_data = json.dumps(predict_data)
 
-        endpoint_url = "https://prefab-photonics--predict-v1.modal.run"
-
-        with requests.post(
-            endpoint_url, data=json_data, headers=headers, stream=True
-        ) as response:
-            response.raise_for_status()
-            event_type = None
-            model_descriptions = {"p": "Prediction", "c": "Correction", "s": "SEMulate"}
-            progress_bar = tqdm(
-                total=100,
-                desc=f"{model_descriptions[model_type]}",
-                unit="%",
-                colour="green",
-                bar_format="{l_bar}{bar:30}{r_bar}{bar:-10b}",
-            )
+        endpoint_url = (
+            "https://prefab-photonics--predict-gpu-v1.modal.run"
+            if gpu
+            else "https://prefab-photonics--predict-v1.modal.run"
+        )
 
-            for line in response.iter_lines():
-                if line:
-                    decoded_line = line.decode("utf-8").strip()
-                    if decoded_line.startswith("event:"):
-                        event_type = decoded_line.split(":")[1].strip()
-                    elif decoded_line.startswith("data:"):
-                        try:
-                            data_content = json.loads(decoded_line.split("data: ")[1])
-                            if event_type == "progress":
-                                progress = round(100 * data_content["progress"])
-                                progress_bar.update(progress - progress_bar.n)
-                            elif event_type == "result":
-                                results = []
-                                for key in sorted(data_content.keys()):
-                                    if key.startswith("result"):
-                                        decoded_image = self._decode_array(
-                                            data_content[key]
-                                        )
-                                        results.append(decoded_image)
+        try:
+            with requests.post(
+                endpoint_url, data=json_data, headers=headers, stream=True
+            ) as response:
+                response.raise_for_status()
+                event_type = None
+                model_descriptions = {
+                    "p": "Prediction",
+                    "c": "Correction",
+                    "s": "SEMulate",
+                }
+                progress_bar = tqdm(
+                    total=100,
+                    desc=f"{model_descriptions[model_type]}",
+                    unit="%",
+                    colour="green",
+                    bar_format="{l_bar}{bar:30}{r_bar}{bar:-10b}",
+                )
 
-                                if results:
-                                    prediction = np.stack(results, axis=-1)
-                                    if binarize:
-                                        prediction = geometry.binarize_hard(prediction)
+                for line in response.iter_lines():
+                    if line:
+                        decoded_line = line.decode("utf-8").strip()
+                        if decoded_line.startswith("event:"):
+                            event_type = decoded_line.split(":")[1].strip()
+                        elif decoded_line.startswith("data:"):
+                            try:
+                                data_content = json.loads(
+                                    decoded_line.split("data: ")[1]
+                                )
+                                if event_type == "progress":
+                                    progress = round(100 * data_content["progress"])
+                                    progress_bar.update(progress - progress_bar.n)
+                                elif event_type == "result":
+                                    results = []
+                                    for key in sorted(data_content.keys()):
+                                        if key.startswith("result"):
+                                            decoded_image = self._decode_array(
+                                                data_content[key]
+                                            )
+                                            results.append(decoded_image)
+
+                                    if results:
+                                        prediction = np.stack(results, axis=-1)
+                                        if binarize:
+                                            prediction = geometry.binarize_hard(
+                                                prediction
+                                            )
+                                        progress_bar.close()
+                                        return prediction
+                                elif event_type == "end":
+                                    print("Stream ended.")
                                     progress_bar.close()
-                                    return prediction
-                            elif event_type == "end":
-                                print("Stream ended.")
-                                progress_bar.close()
-                                break
-                            elif event_type == "auth":
-                                if "new_refresh_token" in data_content["auth"]:
-                                    prefab_file_path = os.path.expanduser(
-                                        "~/.prefab.toml"
-                                    )
-                                    with open(
-                                        prefab_file_path, "w", encoding="utf-8"
-                                    ) as toml_file:
-                                        toml.dump(
-                                            {
-                                                "access_token": data_content["auth"][
-                                                    "new_access_token"
-                                                ],
-                                                "refresh_token": data_content["auth"][
-                                                    "new_refresh_token"
-                                                ],
-                                            },
-                                            toml_file,
+                                    break
+                                elif event_type == "auth":
+                                    if "new_refresh_token" in data_content["auth"]:
+                                        prefab_file_path = os.path.expanduser(
+                                            "~/.prefab.toml"
                                         )
-                            elif event_type == "error":
-                                print(f"Error: {data_content['error']}")
-                                progress_bar.close()
-                        except json.JSONDecodeError:
-                            print(
-                                "Failed to decode JSON:",
-                                decoded_line.split("data: ")[1],
-                            )
+                                        with open(
+                                            prefab_file_path, "w", encoding="utf-8"
+                                        ) as toml_file:
+                                            toml.dump(
+                                                {
+                                                    "access_token": data_content[
+                                                        "auth"
+                                                    ]["new_access_token"],
+                                                    "refresh_token": data_content[
+                                                        "auth"
+                                                    ]["new_refresh_token"],
+                                                },
+                                                toml_file,
+                                            )
+                                elif event_type == "error":
+                                    raise ValueError(f"{data_content['error']}")
+                            except json.JSONDecodeError:
+                                raise ValueError(
+                                    "Failed to decode JSON:",
+                                    decoded_line.split("data: ")[1],
+                                ) from None
+        except requests.RequestException as e:
+            raise RuntimeError(f"Request failed: {e}") from e
 
     def predict(
         self,
         model: Model,
         binarize: bool = False,
+        gpu: bool = False,
     ) -> "Device":
         """
         Predict the nanofabrication outcome of the device using a specified model.
@@ -357,6 +377,10 @@ class Device(BaseModel):
             If True, the predicted device geometry will be binarized using a threshold
             method. This is useful for converting probabilistic predictions into binary
             geometries. Defaults to False.
+        gpu : bool, optional
+            If True, the prediction will be performed on a GPU. Defaults to False.
+            Note: The GPU option has more overhead and will take longer for small
+            devices, but will be faster for larger devices.
 
         Returns
         -------
@@ -373,6 +397,7 @@ class Device(BaseModel):
             model=model,
             model_type="p",
             binarize=binarize,
+            gpu=gpu,
         )
         return self.model_copy(update={"device_array": prediction_array})
 
@@ -380,6 +405,7 @@ class Device(BaseModel):
         self,
         model: Model,
         binarize: bool = True,
+        gpu: bool = False,
     ) -> "Device":
         """
         Correct the nanofabrication outcome of the device using a specified model.
@@ -403,6 +429,10 @@ class Device(BaseModel):
             If True, the corrected device geometry will be binarized using a threshold
             method. This is useful for converting probabilistic corrections into binary
             geometries. Defaults to True.
+        gpu : bool, optional
+            If True, the prediction will be performed on a GPU. Defaults to False.
+            Note: The GPU option has more overhead and will take longer for small
+            devices, but will be faster for larger devices.
 
         Returns
         -------
@@ -419,12 +449,14 @@ class Device(BaseModel):
             model=model,
             model_type="c",
             binarize=binarize,
+            gpu=gpu,
         )
         return self.model_copy(update={"device_array": correction_array})
 
     def semulate(
         self,
         model: Model,
+        gpu: bool = False,
     ) -> "Device":
         """
         Simulate the appearance of the device as if viewed under a scanning electron
@@ -444,6 +476,10 @@ class Device(BaseModel):
             in `models.py`. Each model is associated with a version and dataset that
             detail its creation and the data it was trained on, ensuring the SEMulation
             is tailored to specific fabrication parameters.
+        gpu : bool, optional
+            If True, the prediction will be performed on a GPU. Defaults to False.
+            Note: The GPU option has more overhead and will take longer for small
+            devices, but will be faster for larger devices.
 
         Returns
         -------
@@ -455,6 +491,7 @@ class Device(BaseModel):
             model=model,
             model_type="s",
             binarize=False,
+            gpu=gpu,
         )
         return self.model_copy(update={"device_array": semulated_array})
 
@@ -636,6 +673,149 @@ class Device(BaseModel):
 
         return cell
 
+    def to_gdsfactory(self) -> "gf.Component":  # noqa: F821
+        """
+        Convert the device geometry to a gdsfactory Component.
+
+        Returns
+        -------
+        gf.Component
+            A gdsfactory Component object representing the device geometry.
+
+        Raises
+        ------
+        ImportError
+            If the gdsfactory package is not installed.
+        """
+        try:
+            import gdsfactory as gf
+        except ImportError:
+            raise ImportError(
+                "The gdsfactory package is required to use this function; "
+                "try `pip install gdsfactory`."
+            ) from None
+
+        device_array = np.rot90(self.device_array, k=-1)
+        return gf.read.from_np(device_array[:, :, 0], nm_per_pixel=1)
+
+    def to_tidy3d(
+        self,
+        eps0: float,
+        thickness: float,
+    ) -> "td.Structure":  # noqa: F821
+        """
+        Convert the device geometry to a Tidy3D Structure.
+
+        Parameters
+        ----------
+        eps0 : float
+            The permittivity value to assign to the device array.
+        thickness : float
+            The thickness of the device in the z-direction.
+
+        Returns
+        -------
+        td.Structure
+            A Tidy3D Structure object representing the device geometry.
+
+        Raises
+        ------
+        ImportError
+            If the tidy3d package is not installed.
+        """
+        try:
+            from tidy3d import Box, CustomMedium, SpatialDataArray, Structure, inf
+        except ImportError:
+            raise ImportError(
+                "The tidy3d package is required to use this function; "
+                "try `pip install tidy3d`."
+            ) from None
+
+        X = np.linspace(-self.shape[1] / 2000, self.shape[1] / 2000, self.shape[1])
+        Y = np.linspace(-self.shape[0] / 2000, self.shape[0] / 2000, self.shape[0])
+        Z = np.array([0])
+
+        device_array = np.rot90(np.fliplr(self.device_array), k=1)
+        eps_array = np.where(device_array >= 1.0, eps0, device_array)
+        eps_array = np.where(eps_array < 1.0, 1.0, eps_array)
+        eps_dataset = SpatialDataArray(eps_array, coords=dict(x=X, y=Y, z=Z))
+        medium = CustomMedium.from_eps_raw(eps_dataset)
+        return Structure(
+            geometry=Box(center=(0, 0, 0), size=(inf, inf, thickness)), medium=medium
+        )
+
+    def to_3d(self, thickness_nm: int) -> np.ndarray:
+        """
+        Convert the 2D device geometry into a 3D representation.
+
+        This method creates a 3D array by interpolating between the bottom and top
+        layers of the device geometry. The interpolation is linear.
+
+        Parameters
+        ----------
+        thickness_nm : int
+            The thickness of the 3D representation in nanometers.
+
+        Returns
+        -------
+        np.ndarray
+            A 3D narray representing the device geometry with the specified thickness.
+        """
+        bottom_layer = self.device_array[:, :, 0]
+        top_layer = self.device_array[:, :, -1]
+        dt_bottom = distance_transform_edt(bottom_layer) - distance_transform_edt(
+            1 - bottom_layer
+        )
+        dt_top = distance_transform_edt(top_layer) - distance_transform_edt(
+            1 - top_layer
+        )
+        weights = np.linspace(0, 1, thickness_nm)
+        layered_array = np.zeros(
+            (bottom_layer.shape[0], bottom_layer.shape[1], thickness_nm)
+        )
+        for i, w in enumerate(weights):
+            dt_interp = (1 - w) * dt_bottom + w * dt_top
+            layered_array[:, :, i] = dt_interp >= 0
+        return layered_array
+
+    def to_stl(self, thickness_nm: int, filename: str = "prefab_device.stl"):
+        """
+        Export the device geometry as an STL file.
+
+        Parameters
+        ----------
+        thickness_nm : int
+            The thickness of the 3D representation in nanometers.
+        filename : str, optional
+            The name of the STL file to save. Defaults to "prefab_device.stl".
+
+        Raises
+        ------
+        ValueError
+            If the thickness is not a positive integer.
+        ImportError
+            If the numpy-stl package is not installed.
+        """
+        try:
+            from stl import mesh
+        except ImportError:
+            raise ImportError(
+                "The stl package is required to use this function; "
+                "try `pip install numpy-stl`."
+            ) from None
+
+        if thickness_nm <= 0:
+            raise ValueError("Thickness must be a positive integer.")
+
+        layered_array = self.to_3d(thickness_nm)
+        verts, faces, _, _ = measure.marching_cubes(layered_array, level=0.5)
+        cube = mesh.Mesh(np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype))
+        for i, f in enumerate(faces):
+            for j in range(3):
+                cube.vectors[i][j] = verts[f[j], :]
+        cube.save(filename)
+        print(f"Saved Device to '{filename}'")
+
     def _plot_base(
         self,
         plot_array: np.ndarray,
@@ -1259,3 +1439,91 @@ class Device(BaseModel):
             with higher values indicating greater uncertainty.
         """
         return 1 - 2 * np.abs(0.5 - self.device_array)
+
+    def enforce_feature_size(
+        self, min_feature_size: int, strel: str = "disk"
+    ) -> "Device":
+        """
+        Enforce a minimum feature size on the device geometry.
+
+        This method applies morphological operations to ensure that all features in the
+        device geometry are at least the specified minimum size. It uses either a disk
+        or square structuring element for the operations.
+
+        Parameters
+        ----------
+        min_feature_size : int
+            The minimum feature size to enforce, in nanometers.
+        strel : str, optional
+            The type of structuring element to use. Can be either "disk" or "square".
+            Defaults to "disk".
+
+        Returns
+        -------
+        Device
+            A new instance of the Device with the modified geometry.
+
+        Raises
+        ------
+        ValueError
+            If an invalid structuring element type is specified.
+        """
+        if strel == "disk":
+            structuring_element = disk(radius=min_feature_size / 2)
+        elif strel == "square":
+            structuring_element = square(width=min_feature_size)
+        else:
+            raise ValueError(f"Invalid structuring element: {strel}")
+
+        modified_geometry = closing(self.device_array[:, :, 0], structuring_element)
+        modified_geometry = opening(modified_geometry, structuring_element)
+        modified_geometry = np.expand_dims(modified_geometry, axis=-1)
+        return self.model_copy(update={"device_array": modified_geometry})
+
+    def check_feature_size(self, min_feature_size: int, strel: str = "disk"):
+        """
+        Check and visualize the effect of enforcing a minimum feature size on the device
+        geometry.
+
+        This method enforces a minimum feature size on the device geometry using the
+        specified structuring element, compares the modified geometry with the original,
+        and plots the differences. It also calculates and prints the Hamming distance
+        between the original and modified geometries, providing a measure of the changes
+        introduced by the feature size enforcement.
+
+        Parameters
+        ----------
+        min_feature_size : int
+            The minimum feature size to enforce, in nanometers.
+        strel : str, optional
+            The type of structuring element to use. Can be either "disk" or "square".
+            Defaults to "disk".
+
+        Raises
+        ------
+        ValueError
+            If an invalid structuring element type is specified or if min_feature_size
+            is not a positive integer.
+        """
+        if min_feature_size <= 0:
+            raise ValueError("min_feature_size must be a positive integer.")
+
+        enforced_device = self.enforce_feature_size(min_feature_size, strel)
+
+        difference = np.abs(
+            enforced_device.device_array[:, :, 0] - self.device_array[:, :, 0]
+        )
+        _, ax = self._plot_base(
+            plot_array=difference,
+            show_buffer=False,
+            ax=None,
+            bounds=None,
+            cmap="jet",
+        )
+
+        hamming_distance = compare.hamming_distance(self, enforced_device)
+        print(
+            f"Feature size check with minimum size {min_feature_size} "
+            f"using '{strel}' structuring element resulted in a Hamming "
+            f"distance of: {hamming_distance}"
+        )

prefab/read.py

@@ -219,6 +219,73 @@ def _gdstk_to_device_array(
     return device_array
 
 
+def from_gdsfactory(
+    component: "gf.Component",  # noqa: F821
+    **kwargs,
+) -> Device:
+    """
+    Create a Device from a gdsfactory component.
+
+    Parameters
+    ----------
+    component : gf.Component
+        The gdsfactory component to be converted into a Device object.
+    **kwargs
+        Additional keyword arguments to be passed to the Device constructor.
+
+    Returns
+    -------
+    Device
+        A Device object representing the gdsfactory component.
+
+    Raises
+    ------
+    ImportError
+        If the gdsfactory package is not installed.
+    """
+    try:
+        import gdsfactory as gf
+    except ImportError:
+        raise ImportError(
+            "The gdsfactory package is required to use this function; "
+            "try `pip install gdsfactory`."
+        ) from None
+
+    bounds = (
+        (component.xmin * 1000, component.ymin * 1000),
+        (component.xmax * 1000, component.ymax * 1000),
+    )
+
+    polygons = [
+        polygon
+        for polygons_list in component.get_polygons_points().values()
+        for polygon in polygons_list
+    ]
+
+    contours = [
+        np.array(
+            [
+                [
+                    [
+                        int(1000 * vertex[0] - bounds[0][0]),
+                        int(1000 * vertex[1] - bounds[0][1]),
+                    ]
+                ]
+                for vertex in polygon
+            ]
+        )
+        for polygon in polygons
+    ]
+
+    device_array = np.zeros(
+        (int(bounds[1][1] - bounds[0][1]), int(bounds[1][0] - bounds[0][0])),
+        dtype=np.uint8,
+    )
+    cv2.fillPoly(img=device_array, pts=contours, color=(1, 1, 1))
+    device_array = np.flipud(device_array)
+    return Device(device_array=device_array, **kwargs)
+
+
 def from_sem(
     sem_path: str,
     sem_resolution: float = None,
@@ -314,3 +381,73 @@ def get_sem_resolution(sem_path: str, sem_resolution_key: str) -> float:
                         value /= 1000
                     return value
     raise ValueError(f"Resolution key '{sem_resolution_key}' not found in {sem_path}.")
+
+
+def from_tidy3d(
+    tidy3d_sim: "tidy3d.Simulation",  # noqa: F821
+    eps_threshold: float,
+    z: float,
+    **kwargs,
+) -> Device:
+    """
+    Create a Device from a Tidy3D simulation.
+
+    Parameters
+    ----------
+    tidy3d_sim : tidy3d.Simulation
+        The Tidy3D simulation object.
+    eps_threshold : float
+        The threshold value for the permittivity to binarize the device array.
+    z : float
+        The z-coordinate at which to extract the permittivity.
+    **kwargs
+        Additional keyword arguments to be passed to the Device constructor.
+
+    Returns
+    -------
+    Device
+        A Device object representing the permittivity cross-section at the specified
+        z-coordinate for the Tidy3D simulation.
+
+    Raises
+    ------
+    ValueError
+        If the z-coordinate is outside the bounds of the simulation size in the
+        z-direction.
+    ImportError
+        If the tidy3d package is not installed.
+    """
+    try:
+        from tidy3d import Coords, Grid
+    except ImportError:
+        raise ImportError(
+            "The tidy3d package is required to use this function; "
+            "try `pip install tidy3d`."
+        ) from None
+
+    if not (
+        tidy3d_sim.center[2] - tidy3d_sim.size[2] / 2
+        <= z
+        <= tidy3d_sim.center[2] + tidy3d_sim.size[2] / 2
+    ):
+        raise ValueError(
+            f"z={z} is outside the bounds of the simulation size in the z-direction."
+        )
+
+    x = np.arange(
+        tidy3d_sim.center[0] - tidy3d_sim.size[0] / 2,
+        tidy3d_sim.center[0] + tidy3d_sim.size[0] / 2,
+        0.001,
+    )
+    y = np.arange(
+        tidy3d_sim.center[1] - tidy3d_sim.size[1] / 2,
+        tidy3d_sim.center[1] + tidy3d_sim.size[1] / 2,
+        0.001,
+    )
+    z = np.array([z])
+
+    grid = Grid(boundaries=Coords(x=x, y=y, z=z))
+    eps = np.real(tidy3d_sim.epsilon_on_grid(grid=grid, coord_key="boundaries").values)
+    device_array = geometry.binarize_hard(device_array=eps, eta=eps_threshold)[:, :, 0]
+    device_array = np.fliplr(np.rot90(device_array, k=-1))
+    return Device(device_array=device_array, **kwargs)

{prefab-1.0.3.dist-info → prefab-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prefab
-Version: 1.0.3
+Version: 1.1.0
 Summary: Artificial nanofabrication of integrated photonic circuits using deep learning
 Project-URL: Homepage, https://prefabphotonics.com
 Project-URL: Repository, https://github.com/PreFab-Photonics/PreFab
@@ -524,6 +524,7 @@ Requires-Dist: pillow
 Requires-Dist: pydantic
 Requires-Dist: requests
 Requires-Dist: scikit-image
+Requires-Dist: scipy
 Requires-Dist: toml
 Requires-Dist: tqdm
 Description-Content-Type: text/markdown

prefab-1.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+prefab/__init__.py,sha256=Tx4t6ODZeL-V-ZPuQXjEHHtwb7rjqCb2ApLFDniQ5fA,401
+prefab/__main__.py,sha256=aAgt1WXa44k1nJqsiSD3uAfNeGpwtjWqMUYCHN5_Qrw,2759
+prefab/compare.py,sha256=AfLJ69DTqvt0mkMqNCTdn2KWKoclt_0htGVXvarEhkY,2709
+prefab/device.py,sha256=lklENpvqROifkEgNCT4BwU9xnsLt1nwdLksh5VDgpKU,58507
+prefab/geometry.py,sha256=pXsVeu4Ycnq60bG6WqFNoUWnyiNStIaYQgbMIrEyndM,9614
+prefab/models.py,sha256=UMzYZzKouroxlwkXCMKIYozmQCMhNhvt8kQrZmwmZB4,3671
+prefab/read.py,sha256=Rzj9GGrszsKWdY8GxtmpfYcA4nsiuxgwSdEDVvfHN80,14624
+prefab/shapes.py,sha256=Hc6dc2Y5Wmb2mZAxhdjBNEJF7C7tF2o460HNvcqcQdo,24856
+prefab-1.1.0.dist-info/METADATA,sha256=tHahGccx-TKDbeo2ZMKTjC_JYPWesvovFyUuTONF_YA,34817
+prefab-1.1.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+prefab-1.1.0.dist-info/licenses/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
+prefab-1.1.0.dist-info/RECORD,,

prefab-1.0.3.dist-info/RECORD

@@ -1,12 +0,0 @@
-prefab/__init__.py,sha256=54JuP2jMRBoA7uWb9uoQ_VXXsi_V1ld_LM2A9wXiLkA,401
-prefab/__main__.py,sha256=aAgt1WXa44k1nJqsiSD3uAfNeGpwtjWqMUYCHN5_Qrw,2759
-prefab/compare.py,sha256=AfLJ69DTqvt0mkMqNCTdn2KWKoclt_0htGVXvarEhkY,2709
-prefab/device.py,sha256=sWDL9xXjDs0LzL91oGu8JFvYCQcMF8msz7fjbxwDWEg,48397
-prefab/geometry.py,sha256=pXsVeu4Ycnq60bG6WqFNoUWnyiNStIaYQgbMIrEyndM,9614
-prefab/models.py,sha256=UMzYZzKouroxlwkXCMKIYozmQCMhNhvt8kQrZmwmZB4,3671
-prefab/read.py,sha256=HNuovvQx0Vg0X-z5-gUlL-T1M1RQf81Bmy0wDAdqO28,10782
-prefab/shapes.py,sha256=Hc6dc2Y5Wmb2mZAxhdjBNEJF7C7tF2o460HNvcqcQdo,24856
-prefab-1.0.3.dist-info/METADATA,sha256=yQgJ6qqL8WWfcZmVxRpmAvucNq1XSBYLQra4fmpH3T0,34796
-prefab-1.0.3.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-prefab-1.0.3.dist-info/licenses/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
-prefab-1.0.3.dist-info/RECORD,,