prefab 1.1.2__py3-none-any.whl → 1.1.4__py3-none-any.whl

prefab/__init__.py

@@ -5,9 +5,9 @@ Usage:
     import prefab as pf
 """
 
-__version__ = "1.1.2"
+__version__ = "1.1.4"
 
-from . import compare, geometry, read, shapes
+from . import compare, geometry, predict, read, shapes
 from .device import BufferSpec, Device
 from .models import models
 
@@ -15,6 +15,7 @@ __all__ = [
     "Device",
     "BufferSpec",
     "geometry",
+    "predict",
     "read",
     "shapes",
     "compare",

prefab/device.py

@@ -1,27 +1,21 @@
 """Provides the Device class for representing photonic devices."""
 
-import base64
-import io
-import json
-import os
 from typing import Optional
 
 import cv2
 import gdstk
 import matplotlib.pyplot as plt
 import numpy as np
-import requests
-import toml
 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 tqdm import tqdm
 
 from . import compare, geometry
 from .models import Model
+from .predict import predict_array
 
 Image.MAX_IMAGE_PIXELS = None
 
@@ -210,147 +204,6 @@ class Device(BaseModel):
             or np.array_equal(unique_values, [1])
         )
 
-    def _encode_array(self, array):
-        image = Image.fromarray(np.uint8(array * 255))
-        buffered = io.BytesIO()
-        image.save(buffered, format="PNG")
-        encoded_png = base64.b64encode(buffered.getvalue()).decode("utf-8")
-        return encoded_png
-
-    def _decode_array(self, encoded_png):
-        binary_data = base64.b64decode(encoded_png)
-        image = Image.open(io.BytesIO(binary_data))
-        return np.array(image) / 255
-
-    def _predict_array(
-        self,
-        model: Model,
-        model_type: str,
-        binarize: bool,
-        gpu: bool = False,
-    ) -> "Device":
-        try:
-            with open(os.path.expanduser("~/.prefab.toml")) as file:
-                content = file.readlines()
-                access_token = None
-                refresh_token = None
-                for line in content:
-                    if "access_token" in line:
-                        access_token = line.split("=")[1].strip().strip('"')
-                    if "refresh_token" in line:
-                        refresh_token = line.split("=")[1].strip().strip('"')
-                        break
-                if not access_token or not refresh_token:
-                    raise ValueError("Token not found in the configuration file.")
-        except FileNotFoundError:
-            raise FileNotFoundError(
-                "Could not validate user.\n"
-                "Please update prefab using: pip install --upgrade prefab.\n"
-                "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,
-        }
-
-        predict_data = {
-            "device_array": self._encode_array(self.device_array[:, :, 0]),
-            "model": model.to_json(),
-            "model_type": model_type,
-            "binary": binarize,
-        }
-        json_data = json.dumps(predict_data)
-
-        endpoint_url = (
-            "https://prefab-photonics--predict-gpu-v1.modal.run"
-            if gpu
-            else "https://prefab-photonics--predict-v1.modal.run"
-        )
-
-        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}",
-                )
-
-                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()
-                                    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,
-                                            )
-                                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,
@@ -393,7 +246,8 @@ class Device(BaseModel):
             If the prediction service returns an error or if the response from the
             service cannot be processed correctly.
         """
-        prediction_array = self._predict_array(
+        prediction_array = predict_array(
+            device_array=self.device_array,
             model=model,
             model_type="p",
             binarize=binarize,
@@ -445,7 +299,8 @@ class Device(BaseModel):
             If the correction service returns an error or if the response from the
             service cannot be processed correctly.
         """
-        correction_array = self._predict_array(
+        correction_array = predict_array(
+            device_array=self.device_array,
             model=model,
             model_type="c",
             binarize=binarize,
@@ -487,7 +342,8 @@ class Device(BaseModel):
             A new instance of the Device class with its geometry transformed to simulate
             an SEM image style.
         """
-        semulated_array = self._predict_array(
+        semulated_array = predict_array(
+            device_array=self.device_array,
             model=model,
             model_type="s",
             binarize=False,
@@ -550,6 +406,7 @@ class Device(BaseModel):
         cell_name: str = "prefab_device",
         gds_layer: tuple[int, int] = (1, 0),
         contour_approx_mode: int = 2,
+        origin: tuple[float, float] = (0.0, 0.0),
     ):
         """
         Exports the device geometry as a GDSII file.
@@ -572,11 +429,15 @@ class Device(BaseModel):
             The mode of contour approximation used during the conversion. Defaults to 2,
             which corresponds to `cv2.CHAIN_APPROX_SIMPLE`, a method that compresses
             horizontal, vertical, and diagonal segments and leaves only their endpoints.
+        origin : tuple[float, float], optional
+            The x and y coordinates of the origin for the GDSII export. Defaults to
+            (0.0, 0.0).
         """
         gdstk_cell = self.flatten()._device_to_gdstk(
             cell_name=cell_name,
             gds_layer=gds_layer,
             contour_approx_mode=contour_approx_mode,
+            origin=origin,
         )
         print(f"Saving GDS to '{gds_path}'...")
         gdstk_library = gdstk.Library()
@@ -588,6 +449,7 @@ class Device(BaseModel):
         cell_name: str = "prefab_device",
         gds_layer: tuple[int, int] = (1, 0),
         contour_approx_mode: int = 2,
+        origin: tuple[float, float] = (0.0, 0.0),
     ):
         """
         Converts the device geometry to a GDSTK cell object.
@@ -607,6 +469,9 @@ class Device(BaseModel):
             The mode of contour approximation used during the conversion. Defaults to 2,
             which corresponds to `cv2.CHAIN_APPROX_SIMPLE`, a method that compresses
             horizontal, vertical, and diagonal segments and leaves only their endpoints.
+        origin : tuple[float, float], optional
+            The x and y coordinates of the origin for the GDSTK cell. Defaults to
+            (0.0, 0.0).
 
         Returns
         -------
@@ -618,6 +483,7 @@ class Device(BaseModel):
             cell_name=cell_name,
             gds_layer=gds_layer,
             contour_approx_mode=contour_approx_mode,
+            origin=origin,
         )
         return gdstk_cell
 
@@ -626,6 +492,7 @@ class Device(BaseModel):
         cell_name: str,
         gds_layer: tuple[int, int],
         contour_approx_mode: int,
+        origin: tuple[float, float],
     ) -> gdstk.Cell:
         approx_mode_mapping = {
             1: cv2.CHAIN_APPROX_NONE,
@@ -662,8 +529,21 @@ class Device(BaseModel):
             polygons_to_process = hierarchy_polygons[level]
 
             if polygons_to_process:
+                center_x_nm = self.device_array.shape[1] / 2
+                center_y_nm = self.device_array.shape[0] / 2
+
+                center_x_um = center_x_nm / 1000
+                center_y_um = center_y_nm / 1000
+
+                adjusted_polygons = [
+                    [
+                        (x - center_x_um + origin[0], y - center_y_um + origin[1])
+                        for x, y in polygon
+                    ]
+                    for polygon in polygons_to_process
+                ]
                 processed_polygons = gdstk.boolean(
-                    polygons_to_process,
+                    adjusted_polygons,
                     processed_polygons,
                     operation,
                     layer=gds_layer[0],
@@ -1313,13 +1193,6 @@ class Device(BaseModel):
         """
         Trim the device geometry by removing empty space around it.
 
-        Parameters
-        ----------
-        buffer_thickness : dict, optional
-            A dictionary specifying the thickness of the buffer to leave around the
-            non-zero elements of the array. Should contain keys 'top', 'bottom', 'left',
-            'right'. Defaults to None, which means no buffer is added.
-
         Returns
         -------
         Device
@@ -1414,15 +1287,10 @@ class Device(BaseModel):
         Flatten the device geometry by summing the vertical layers and normalizing the
         result.
 
-        Parameters
-        ----------
-        device_array : np.ndarray
-            The input array to be flattened.
-
         Returns
         -------
-        np.ndarray
-            The flattened array with values scaled between 0 and 1.
+        Device
+            A new instance of the Device with the flattened geometry.
         """
         flattened_device_array = geometry.flatten(device_array=self.device_array)
         return self.model_copy(update={"device_array": flattened_device_array})

prefab/models.py

@@ -10,7 +10,7 @@ class Fab(BaseModel):
     """
     Represents a fabrication process in the PreFab model library.
 
-    Parameters
+    Attributes
     ----------
     foundry : str
         The name of the foundry where the fabrication process takes place.

prefab/predict.py

@@ -0,0 +1,307 @@
+"""Provides prediction functions for ndarrays of device geometries."""
+
+import base64
+import io
+import json
+import os
+
+import numpy as np
+import requests
+import toml
+from autograd import primitive
+from autograd.extend import defvjp
+from PIL import Image
+from tqdm import tqdm
+
+from .geometry import binarize_hard
+from .models import Model
+
+BASE_URL = "https://prefab-photonics--predict"
+
+
+def predict_array(
+    device_array: np.ndarray,
+    model: Model,
+    model_type: str,
+    binarize: bool,
+    gpu: bool = False,
+) -> np.ndarray:
+    """
+    Predict the nanofabrication outcome of a device array using a specified model.
+
+    This function sends the device array to a serverless prediction service, which uses
+    a specified machine learning model to predict the outcome of the nanofabrication
+    process. The prediction can be performed on a GPU if specified.
+
+    Parameters
+    ----------
+    device_array : np.ndarray
+        A 2D array representing the planar geometry of the device. This array undergoes
+        various transformations to predict the nanofabrication process.
+    model : Model
+        The model to use for prediction, representing a specific fabrication process and
+        dataset. This model encapsulates details about the fabrication foundry, process,
+        material, technology, thickness, and sidewall presence, as defined 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 prediction is tailored to
+        specific fabrication parameters.
+    model_type : str
+        The type of model to use (e.g., 'p', 'c', 's').
+    binarize : bool
+        If True, the predicted device geometry will be binarized using a threshold
+        method. This is useful for converting probabilistic predictions into binary
+        geometries.
+    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
+    -------
+    np.ndarray
+        The predicted output array.
+
+    Raises
+    ------
+    RuntimeError
+        If the request to the prediction service fails.
+    """
+    headers = _prepare_headers()
+    predict_data = _prepare_predict_data(device_array, model, model_type, binarize)
+    endpoint_url = f"{BASE_URL}-gpu-v1.modal.run" if gpu else f"{BASE_URL}-v1.modal.run"
+
+    try:
+        with requests.post(
+            endpoint_url,
+            data=json.dumps(predict_data),
+            headers=headers,
+            stream=True,
+        ) as response:
+            response.raise_for_status()
+            return _process_response(response, model_type, binarize)
+    except requests.RequestException as e:
+        raise RuntimeError(f"Request failed: {e}") from e
+
+
+def _predict_array_with_grad(
+    device_array: np.ndarray, model: Model
+) -> tuple[np.ndarray, np.ndarray]:
+    headers = _prepare_headers()
+    predict_data = _prepare_predict_data(device_array, model, "p", False)
+    endpoint_url = f"{BASE_URL}-with-grad-v1.modal.run"
+
+    response = requests.post(
+        endpoint_url, data=json.dumps(predict_data), headers=headers
+    )
+    prediction_array = _decode_array(response.json()["prediction_array"])
+    gradient_array = _decode_array(response.json()["gradient_array"])
+    gradient_min = response.json()["gradient_min"]
+    gradient_max = response.json()["gradient_max"]
+    gradient_range = gradient_max - gradient_min
+    gradient_array = gradient_array * gradient_range + gradient_min
+
+    return (prediction_array, gradient_array)
+
+
+@primitive
+def predict_array_with_grad(device_array: np.ndarray, model: Model) -> np.ndarray:
+    """
+    Predict the nanofabrication outcome of a device array and compute its gradient.
+
+    This function predicts the outcome of the nanofabrication process for a given
+    device array using a specified model. It also computes the gradient of the
+    prediction with respect to the input device array.
+
+    Parameters
+    ----------
+    device_array : np.ndarray
+        A 2D array representing the planar geometry of the device.
+    model : Model
+        The model to use for prediction, representing a specific fabrication process.
+
+    Returns
+    -------
+    np.ndarray
+        The predicted output array.
+    """
+    prediction_array, gradient_array = _predict_array_with_grad(
+        device_array=device_array, model=model
+    )
+    predict_array_with_grad.gradient_array = gradient_array
+    return prediction_array
+
+
+def predict_array_with_grad_vjp(ans: np.ndarray, x: np.ndarray, model: Model):
+    """
+    Define the vector-Jacobian product (VJP) for the prediction function.
+
+    This function provides the VJP for the `predict_array_with_grad` function,
+    which is used in reverse-mode automatic differentiation to compute gradients.
+
+    Parameters
+    ----------
+    ans : np.ndarray
+        The output of the `predict_array_with_grad` function.
+    x : np.ndarray
+        The input device array for which the gradient is computed.
+    model : Model
+        The model used for prediction.
+
+    Returns
+    -------
+    function
+        A function that computes the VJP given an upstream gradient `g`.
+    """
+    grad_x = predict_array_with_grad.gradient_array
+
+    def vjp(g: np.ndarray) -> np.ndarray:
+        return g * grad_x
+
+    return vjp
+
+
+defvjp(predict_array_with_grad, predict_array_with_grad_vjp)
+
+
+def _encode_array(array):
+    """Encode an ndarray as a base64 encoded image for transmission."""
+    image = Image.fromarray(np.uint8(array * 255))
+    buffered = io.BytesIO()
+    image.save(buffered, format="PNG")
+    encoded_png = base64.b64encode(buffered.getvalue()).decode("utf-8")
+    return encoded_png
+
+
+def _decode_array(encoded_png):
+    """Decode a base64 encoded image and return an ndarray."""
+    binary_data = base64.b64decode(encoded_png)
+    image = Image.open(io.BytesIO(binary_data))
+    return np.array(image) / 255
+
+
+def _read_tokens():
+    """Read access and refresh tokens from the configuration file."""
+    token_file_path = os.path.expanduser("~/.prefab.toml")
+    try:
+        with open(token_file_path) as file:
+            tokens = toml.load(file)
+            access_token = tokens.get("access_token")
+            refresh_token = tokens.get("refresh_token")
+            if not access_token or not refresh_token:
+                raise ValueError("Tokens not found in the configuration file.")
+            return access_token, refresh_token
+    except FileNotFoundError:
+        raise FileNotFoundError(
+            "Could not validate user.\n"
+            "Please update prefab using: pip install --upgrade prefab.\n"
+            "Signup/login and generate a new token.\n"
+            "See https://www.prefabphotonics.com/docs/guides/quickstart."
+        ) from None
+
+
+def _prepare_headers():
+    """Prepare HTTP headers for the request."""
+    access_token, refresh_token = _read_tokens()
+    return {
+        "Authorization": f"Bearer {access_token}",
+        "X-Refresh-Token": refresh_token,
+    }
+
+
+def _prepare_predict_data(device_array, model, model_type, binarize):
+    """Prepare the data payload for the prediction request."""
+    return {
+        "device_array": _encode_array(np.squeeze(device_array)),
+        "model": model.to_json(),
+        "model_type": model_type,
+        "binary": binarize,
+    }
+
+
+def _process_response(response, model_type, binarize):
+    """Process the streaming response from the prediction request."""
+    event_type = None
+    model_descriptions = {
+        "p": "Prediction",
+        "c": "Correction",
+        "s": "SEMulate",
+    }
+    progress_bar = tqdm(
+        total=100,
+        desc=model_descriptions.get(model_type, "Processing"),
+        unit="%",
+        colour="green",
+        bar_format="{l_bar}{bar:30}{r_bar}{bar:-10b}",
+    )
+
+    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)[1].strip()
+            elif decoded_line.startswith("data:"):
+                data_content = _parse_data_line(decoded_line)
+                result = _handle_event(event_type, data_content, progress_bar, binarize)
+                if result is not None:
+                    progress_bar.close()
+                    return result
+    progress_bar.close()
+
+
+def _parse_data_line(decoded_line):
+    """Parse a data line from the response stream."""
+    data_line = decoded_line.split(":", 1)[1].strip()
+    try:
+        return json.loads(data_line)
+    except json.JSONDecodeError:
+        raise ValueError(f"Failed to decode JSON: {data_line}") from None
+
+
+def _handle_event(event_type, data_content, progress_bar, binarize):
+    """Handle different types of events received from the server."""
+    if event_type == "progress":
+        _update_progress(progress_bar, data_content)
+    elif event_type == "result":
+        return _process_result(data_content, binarize)
+    elif event_type == "end":
+        print("Stream ended.")
+    elif event_type == "auth":
+        _update_tokens(data_content.get("auth", {}))
+    elif event_type == "error":
+        raise ValueError(f"{data_content['error']}")
+
+
+def _update_progress(progress_bar, data_content):
+    """Update the progress bar based on the progress event."""
+    progress = round(100 * data_content.get("progress", 0))
+    progress_bar.update(progress - progress_bar.n)
+
+
+def _process_result(data_content, binarize):
+    """Process the result event and return the prediction."""
+    results = [
+        _decode_array(data_content[key])
+        for key in sorted(data_content.keys())
+        if key.startswith("result")
+    ]
+    if results:
+        prediction = np.stack(results, axis=-1)
+        if binarize:
+            prediction = binarize_hard(prediction)
+        return prediction
+
+
+def _update_tokens(auth_data):
+    """Update tokens if new tokens are provided in the auth event."""
+    new_access_token = auth_data.get("new_access_token")
+    new_refresh_token = auth_data.get("new_refresh_token")
+    if new_access_token and new_refresh_token:
+        prefab_file_path = os.path.expanduser("~/.prefab.toml")
+        with open(prefab_file_path, "w", encoding="utf-8") as toml_file:
+            toml.dump(
+                {
+                    "access_token": new_access_token,
+                    "refresh_token": new_refresh_token,
+                },
+                toml_file,
+            )

{prefab-1.1.2.dist-info → prefab-1.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prefab
-Version: 1.1.2
+Version: 1.1.4
 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

prefab-1.1.4.dist-info/RECORD

@@ -0,0 +1,13 @@
+prefab/__init__.py,sha256=7MmkG6X6FZ7c4lS8eAF5cNu_NYnwIeDVgwCiX9ysYPw,425
+prefab/__main__.py,sha256=aAgt1WXa44k1nJqsiSD3uAfNeGpwtjWqMUYCHN5_Qrw,2759
+prefab/compare.py,sha256=2MKUT7N2A639tUGCnJHpfF9MmS-v3oARDkTqHbWJ9OM,3239
+prefab/device.py,sha256=l0etqB0559xa9Frb0IKl5N3kU56vWHlwHc-qehINTlw,52292
+prefab/geometry.py,sha256=0sa6ietUWZGkxOnUPUzD3q2QpFuOpWkSANoopGpPd6s,11035
+prefab/models.py,sha256=JpBqNFIqbo1ymKEl0NWWF4ZkhvK23rEVVBEFl05TXCI,3671
+prefab/predict.py,sha256=upGTeNC6vY9Tdko6JEM0gKQH1PGUVYXACpep1OT8EVs,10593
+prefab/read.py,sha256=MuF-cugFQ7MWBJ8DOvQuwktIk0fJ8PXBeLye0ydrB8o,14734
+prefab/shapes.py,sha256=2qaqyNzu5WG3wVdk4oQzeNXmhwXRHcPnRZlgRrM4MoA,25576
+prefab-1.1.4.dist-info/METADATA,sha256=FDqQukBN09Eg4BDhn7Q7p46nWOoLwxjWk9CP2VeRoxo,34824
+prefab-1.1.4.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+prefab-1.1.4.dist-info/licenses/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
+prefab-1.1.4.dist-info/RECORD,,

prefab-1.1.2.dist-info/RECORD

@@ -1,12 +0,0 @@
-prefab/__init__.py,sha256=fbGTDuVA76ol5cM6fXbPAZMB0BCT2zmHD7Pgr9I-zV0,401
-prefab/__main__.py,sha256=aAgt1WXa44k1nJqsiSD3uAfNeGpwtjWqMUYCHN5_Qrw,2759
-prefab/compare.py,sha256=2MKUT7N2A639tUGCnJHpfF9MmS-v3oARDkTqHbWJ9OM,3239
-prefab/device.py,sha256=dpx4dDspruImy__bp3X11y_s-CBJZr6dKpxn8wGtmSA,58314
-prefab/geometry.py,sha256=0sa6ietUWZGkxOnUPUzD3q2QpFuOpWkSANoopGpPd6s,11035
-prefab/models.py,sha256=UMzYZzKouroxlwkXCMKIYozmQCMhNhvt8kQrZmwmZB4,3671
-prefab/read.py,sha256=MuF-cugFQ7MWBJ8DOvQuwktIk0fJ8PXBeLye0ydrB8o,14734
-prefab/shapes.py,sha256=2qaqyNzu5WG3wVdk4oQzeNXmhwXRHcPnRZlgRrM4MoA,25576
-prefab-1.1.2.dist-info/METADATA,sha256=wZOFUncUh7ZmZRoJ8AxH_SfpKwd2KdxDnVvmTyiLSR0,34824
-prefab-1.1.2.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-prefab-1.1.2.dist-info/licenses/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
-prefab-1.1.2.dist-info/RECORD,,