prefab 1.1.9__py3-none-any.whl → 1.3.0__py3-none-any.whl

prefab/__init__.py

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

prefab/device.py

@@ -242,7 +242,6 @@ class Device(BaseModel):
         self,
         model: Model,
         binarize: bool = False,
-        gpu: bool = False,
     ) -> "Device":
         """
         Predict the nanofabrication outcome of the device using a specified model.
@@ -264,10 +263,6 @@ 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
-            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
         -------
@@ -285,7 +280,6 @@ class Device(BaseModel):
             model=model,
             model_type="p",
             binarize=binarize,
-            gpu=gpu,
         )
         return self.model_copy(update={"device_array": prediction_array})
 
@@ -293,7 +287,6 @@ class Device(BaseModel):
         self,
         model: Model,
         binarize: bool = True,
-        gpu: bool = False,
     ) -> "Device":
         """
         Correct the nanofabrication outcome of the device using a specified model.
@@ -317,10 +310,6 @@ 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
-            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
         -------
@@ -338,14 +327,12 @@ 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
@@ -365,10 +352,6 @@ 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
-            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.
 
         Notes
         -----
@@ -392,11 +375,52 @@ class Device(BaseModel):
             model=model,
             model_type="s",
             binarize=False,
-            gpu=gpu,
         )
         semulated_array += np.random.normal(0, 0.03, semulated_array.shape)
         return self.model_copy(update={"device_array": semulated_array})
 
+    def segment(
+        self,
+        model: Model,
+    ) -> "Device":
+        """
+        Segment a scanning electron microscope (SEM) image into a binary mask.
+
+        This method applies a specified machine learning model to transform a grayscale
+        SEM image into a binary mask, where 1 represents the device structure and 0
+        represents the background. This is useful for extracting the device geometry
+        from experimental SEM images for analysis or comparison with design intent.
+
+        Parameters
+        ----------
+        model : Model
+            The model to use for segmentation, 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
+            segmentation is tailored to specific fabrication parameters.
+
+        Returns
+        -------
+        Device
+            A new instance of the Device class with its geometry transformed into a
+            binary mask.
+
+        Raises
+        ------
+        RuntimeError
+            If the prediction service returns an error or if the response from the
+            service cannot be processed correctly.
+        """
+        segmented_array = predict_array(
+            device_array=self.normalize().device_array,
+            model=model,
+            model_type="b",
+            binarize=False,
+        )
+        return self.model_copy(update={"device_array": segmented_array})
+
     def to_ndarray(self) -> np.ndarray:
         """
         Converts the device geometry to an ndarray.
@@ -520,7 +544,7 @@ class Device(BaseModel):
         gdstk.Cell
             The GDSTK cell object representing the device geometry.
         """
-        print(f"Creating cell '{cell_name}'...")
+        # print(f"Creating cell '{cell_name}'...")
         gdstk_cell = self.flatten()._device_to_gdstk(
             cell_name=cell_name,
             gds_layer=gds_layer,

prefab/geometry.py

@@ -133,6 +133,7 @@ def binarize_monte_carlo(
     """
     device_array = np.squeeze(device_array)
     base_threshold = np.random.normal(loc=0.5, scale=0.1)
+    base_threshold = np.clip(base_threshold, 0.2, 0.8)
     threshold_noise = np.random.normal(
         loc=0, scale=noise_magnitude, size=device_array.shape
     )

prefab/predict.py

@@ -5,19 +5,19 @@ import io
 import json
 import os
 
+import gdstk
 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_ENDPOINT_URL = "https://prefab-photonics--predict"
-ENDPOINT_VERSION = 2
+ENDPOINT_VERSION = "3"
 
 
 def predict_array(
@@ -25,14 +25,13 @@ def predict_array(
     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.
+    process.
 
     Parameters
     ----------
@@ -48,48 +47,307 @@ def predict_array(
         specific fabrication parameters.
     model_type : str
         The type of model to use (e.g., 'p' for prediction, 'c' for correction, or 's'
-        for SEMulate).
+        for SEMulate, 'b' for segmentation).
     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
-        If True, the prediction will be performed on a GPU. Defaults to False. Note: The
-        GPU option has more startup overhead and will take longer for small devices, but
-        will be faster for larger devices.
 
     Returns
     -------
     np.ndarray
-        The predicted output array.
+        The predicted output array. For single-level predictions, returns shape
+        (h, w, 1). For multi-level predictions, returns shape (h, w, n) where n is the
+        number of levels.
 
     Raises
     ------
     RuntimeError
         If the request to the prediction service fails.
+    ValueError
+        If the server returns an error or invalid response.
     """
+    endpoint_url = f"{BASE_ENDPOINT_URL}-v{ENDPOINT_VERSION}.modal.run"
+    predict_data = {
+        "device_array": _encode_array(np.squeeze(device_array)),
+        "model": model.to_json(),
+        "model_type": model_type,
+    }
     headers = _prepare_headers()
-    predict_data = _prepare_predict_data(device_array, model, model_type, binarize)
-    endpoint_url = (
-        f"{BASE_ENDPOINT_URL}-gpu-v{ENDPOINT_VERSION}.modal.run"
-        if gpu
-        else f"{BASE_ENDPOINT_URL}-v{ENDPOINT_VERSION}.modal.run"
-    )
 
     try:
-        with requests.post(
-            endpoint_url,
-            data=json.dumps(predict_data),
-            headers=headers,
-            stream=True,
-        ) as response:
-            response.raise_for_status()
-            result = _process_response(response, model_type, binarize)
-            if result is None:
-                raise RuntimeError("No prediction result received.")
-            return result
-    except requests.RequestException as e:
+        response = requests.post(
+            url=endpoint_url, data=json.dumps(predict_data), headers=headers
+        )
+        response.raise_for_status()
+
+        if not response.content:
+            raise ValueError("Empty response received from server")
+
+        response_data = response.json()
+
+        if "error" in response_data:
+            raise ValueError(f"Prediction error: {response_data['error']}")
+
+        results = response_data["results"]
+        result_arrays = [
+            _decode_array(results[key])
+            for key in sorted(results.keys())
+            if key.startswith("result")
+        ]
+
+        prediction_array = np.stack(result_arrays, axis=-1)
+
+        if binarize:
+            prediction_array = binarize_hard(prediction_array)
+
+        return prediction_array
+
+    except requests.exceptions.RequestException as e:
         raise RuntimeError(f"Request failed: {e}") from e
+    except json.JSONDecodeError as e:
+        raise ValueError(f"JSON decode error: {e}") from e
+
+
+def _predict_poly(
+    polygon_points: list,
+    model: Model,
+    model_type: str,
+    eta: float = 0.5,
+) -> list:
+    """
+    Predict the nanofabrication outcome for a geometry (list of polygons).
+
+    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.
+
+    Parameters
+    ----------
+    polygon_points : list
+        List of polygon points, where each polygon is a list of [x, y] coordinates.
+    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 ('p' for prediction, 'c' for correction).
+    eta : float
+        The threshold value for binarization. Defaults to 0.5. Because intermediate
+        values cannot be preserved in the polygon data, the predicted polygons are
+        binarized using a threshold value of eta.
+
+    Returns
+    -------
+    list
+        List of predicted polygon points with level information. Each polygon is a dict
+        with 'points' (list of coordinates) and 'level' (int) keys.
+
+    Raises
+    ------
+    RuntimeError
+        If the request to the prediction service fails.
+    ValueError
+        If the server returns an error or invalid response.
+    """
+    predict_data = {
+        "polygons": polygon_points,
+        "model": model.to_json(),
+        "model_type": model_type,
+        "eta": eta,
+    }
+
+    endpoint_url = f"{BASE_ENDPOINT_URL}-poly-v{ENDPOINT_VERSION}.modal.run"
+    headers = _prepare_headers()
+
+    try:
+        response = requests.post(
+            endpoint_url, data=json.dumps(predict_data), headers=headers
+        )
+        response.raise_for_status()
+
+        if not response.content:
+            raise ValueError("Empty response received from server")
+
+        response_data = response.json()
+
+        if "polygons" in response_data:
+            polygons = response_data["polygons"]
+            if polygons and isinstance(polygons[0], dict) and "channel" in polygons[0]:
+                return polygons
+            else:
+                return [{"points": points, "channel": 0} for points in polygons]
+        else:
+            if "error" in response_data:
+                raise ValueError(f"Prediction error: {response_data['error']}")
+            return []
+
+    except requests.exceptions.RequestException as e:
+        raise RuntimeError(f"Request failed: {e}") from e
+    except json.JSONDecodeError as e:
+        raise ValueError(f"JSON decode error: {e}") from e
+
+
+def predict_gds(
+    gds_path: str,
+    cell_name: str,
+    model: Model,
+    model_type: str,
+    gds_layer: tuple[int, int] = (1, 0),
+    eta: float = 0.5,
+    output_path: str = None,
+) -> None:
+    """
+    Predict the nanofabrication outcome for a GDS file and cell.
+
+    This function loads a GDS file, extracts the specified cell, and predicts the
+    nanofabrication outcome using the specified model. The predicted cell is
+    automatically added to the original GDS library and the file is written to the
+    specified output path (or overwrites the original if no output path is provided).
+
+    Parameters
+    ----------
+    gds_path : str
+        The file path to the GDS file.
+    cell_name : str
+        The name of the cell within the GDS file to predict.
+    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 ('p' for prediction, 'c' for correction).
+    gds_layer : tuple[int, int]
+        The layer and datatype to use within the GDS file. Defaults to (1, 0).
+    eta : float
+        The threshold value for binarization. Defaults to 0.5. Because intermediate
+        values cannot be preserved in the polygon data, the predicted polygons are
+        binarized using a threshold value of eta.
+    output_path : str, optional
+        The file path where the updated GDS file will be written. If None, the
+        original file will be overwritten. Defaults to None.
+
+    Raises
+    ------
+    RuntimeError
+        If the request to the prediction service fails.
+    ValueError
+        If the GDS file cannot be read, the specified cell is not found, or the server
+        returns an error or invalid response.
+    """
+    gdstk_library = gdstk.read_gds(gds_path)
+    gdstk_cell = gdstk_library[cell_name]
+
+    predicted_cell = predict_gdstk(
+        gdstk_cell=gdstk_cell,
+        model=model,
+        model_type=model_type,
+        gds_layer=gds_layer,
+        eta=eta,
+    )
+
+    base_name = predicted_cell.name
+    counter = 1
+    while predicted_cell.name in [cell.name for cell in gdstk_library.cells]:
+        predicted_cell.name = f"{base_name}_{counter}"
+        counter += 1
+
+    gdstk_library.add(predicted_cell)
+
+    write_path = output_path if output_path is not None else gds_path
+    gdstk_library.write_gds(write_path, max_points=8190)
+
+
+def predict_gdstk(
+    gdstk_cell: gdstk.Cell,
+    model: Model,
+    model_type: str,
+    gds_layer: tuple[int, int] = (1, 0),
+    eta: float = 0.5,
+) -> gdstk.Cell:
+    """
+    Predict the nanofabrication outcome of a gdstk cell using a specified model.
+
+    This function extracts polygons from a gdstk cell, sends them to a serverless
+    prediction service, and returns a new cell containing the predicted polygons.
+
+    Parameters
+    ----------
+    gdstk_cell : gdstk.Cell
+        The gdstk.Cell object containing polygons to predict.
+    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 ('p' for prediction, 'c' for correction).
+    gds_layer : tuple[int, int]
+        The layer and datatype to use within the GDSTK cell. Defaults to (1, 0).
+    eta : float
+        The threshold value for binarization. Defaults to 0.5. Because intermediate
+        values cannot be preserved in the polygon data, the predicted polygons are
+        binarized using a threshold value of eta.
+
+    Returns
+    -------
+    gdstk.Cell
+        A new gdstk cell containing the predicted polygons. For multi-level
+        predictions, each level's polygons will be placed on a different layer:
+        - Level 0: (layer, 99)
+        - Level 1: (layer, 100)
+
+    Raises
+    ------
+    RuntimeError
+        If the request to the prediction service fails.
+    ValueError
+        If no polygons are found in the specified layer, or the server returns an error
+        or invalid response.
+    """
+    polygons = gdstk_cell.get_polygons(layer=gds_layer[0], datatype=gds_layer[1])
+    if not polygons:
+        raise ValueError("No polygons found in the specified layer")
+
+    polygon_points = [polygon.points.tolist() for polygon in polygons]
+
+    predicted_polygon_data = _predict_poly(
+        polygon_points=polygon_points,
+        model=model,
+        model_type=model_type,
+        eta=eta,
+    )
+
+    result_cell = gdstk.Cell(f"{gdstk_cell.name}_predicted")
+
+    polygons_by_channel = {}
+    for polygon_data in predicted_polygon_data:
+        channel = polygon_data.get("channel", 0)
+        points = polygon_data.get("points", [])
+
+        if channel not in polygons_by_channel:
+            polygons_by_channel[channel] = []
+
+        polygons_by_channel[channel].append(points)
+
+    for channel, points_list in polygons_by_channel.items():
+        layer = gds_layer[0]
+        datatype = 99 + channel
+
+        for points in points_list:
+            points_array = np.array(points)
+            polygon = gdstk.Polygon(points_array, layer=layer, datatype=datatype)
+            result_cell.add(polygon)
+
+    return result_cell
 
 
 def _predict_array_with_grad(
@@ -118,21 +376,49 @@ def _predict_array_with_grad(
     -------
     tuple[np.ndarray, np.ndarray]
         The predicted output array and gradient array.
+
+    Raises
+    ------
+    RuntimeError
+        If the request to the prediction service fails.
+    ValueError
+        If the server returns an error or invalid response.
     """
     headers = _prepare_headers()
-    predict_data = _prepare_predict_data(device_array, model, "p", False)
+    predict_data = {
+        "device_array": _encode_array(np.squeeze(device_array)),
+        "model": model.to_json(),
+        "model_type": "p",
+        "binary": False,
+    }
     endpoint_url = f"{BASE_ENDPOINT_URL}-with-grad-v{ENDPOINT_VERSION}.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)
+    try:
+        response = requests.post(
+            endpoint_url, data=json.dumps(predict_data), headers=headers
+        )
+        response.raise_for_status()
+
+        if not response.content:
+            raise ValueError("Empty response received from server")
+
+        response_data = response.json()
+
+        if "error" in response_data:
+            raise ValueError(f"Prediction error: {response_data['error']}")
+
+        prediction_array = _decode_array(response_data["prediction_array"])
+        gradient_array = _decode_array(response_data["gradient_array"])
+        gradient_min = response_data["gradient_min"]
+        gradient_max = response_data["gradient_max"]
+        gradient_range = gradient_max - gradient_min
+        gradient_array = gradient_array * gradient_range + gradient_min
+        return (prediction_array, gradient_array)
+
+    except requests.exceptions.RequestException as e:
+        raise RuntimeError(f"Request failed: {e}") from e
+    except json.JSONDecodeError as e:
+        raise ValueError(f"JSON decode error: {e}") from e
 
 
 @primitive
@@ -156,6 +442,13 @@ def predict_array_with_grad(device_array: np.ndarray, model: Model) -> np.ndarra
     -------
     np.ndarray
         The predicted output array.
+
+    Raises
+    ------
+    RuntimeError
+        If the request to the prediction service fails.
+    ValueError
+        If the server returns an error or invalid response.
     """
     prediction_array, gradient_array = _predict_array_with_grad(
         device_array=device_array, model=model
@@ -209,8 +502,8 @@ def _decode_array(encoded_png):
     return np.array(image) / 255
 
 
-def _read_tokens():
-    """Read access and refresh tokens from the configuration file."""
+def _prepare_headers():
+    """Prepare HTTP headers for a server request."""
     token_file_path = os.path.expanduser("~/.prefab.toml")
     try:
         with open(token_file_path) as file:
@@ -219,7 +512,10 @@ def _read_tokens():
             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
+            return {
+                "Authorization": f"Bearer {access_token}",
+                "X-Refresh-Token": refresh_token,
+            }
     except FileNotFoundError:
         raise FileNotFoundError(
             "Could not validate user.\n"
@@ -227,111 +523,3 @@ def _read_tokens():
             "Signup/login and generate a new token.\n"
             "See https://docs.prefabphotonics.com/."
         ) 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.9.dist-info → prefab-1.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prefab
-Version: 1.1.9
+Version: 1.3.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
@@ -586,7 +586,7 @@ Before you can make PreFab requests, you will need to [create an account](https:
 To link your account, you will need an token. You can do this by running the following command in your terminal. This will open a browser window where you can log in and authenticate your token.
 
 ```sh
-python3 -m prefab setup
+prefab setup
 ```
 
 ### Guides
@@ -603,4 +603,4 @@ PreFab models are hosted on a [serverless cloud platform](https://modal.com/). P
 
 ## License
 
-This project is licensed under the LGPL-2.1 license. © 2024 PreFab Photonics.
+This project is licensed under the LGPL-2.1 license. © 2025 PreFab Photonics.

prefab-1.3.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+prefab/__init__.py,sha256=l9aFRS6H9RKpzotuXz_qmSOvW1Fdvo_tlH2vuUOa8VE,425
+prefab/__main__.py,sha256=1eXWiEoG7eetJMm1qRbK2I5MnzuRgKIoQtBeT-Ps8es,3523
+prefab/compare.py,sha256=0Xgp3tFuP4of-ce9Opc19p8i8lIyXkbVGLuwWBaHSeE,3486
+prefab/device.py,sha256=7SiawFa103ebFqii3CWy_vPO6ixigVliO6A58hoOqkU,55414
+prefab/geometry.py,sha256=fvMSJpDAqxWShhKojPGnXdB4otrBn54kbW8uk1T4Wwk,12104
+prefab/models.py,sha256=waPNGtuISyY0f8cz7dnbD451CKYCt8EpPGt-4lSOPNU,2581
+prefab/predict.py,sha256=jtB18QOlPINJRqUZCwnuMOfPuuwE1s2e353X5g3njd4,18349
+prefab/read.py,sha256=WNqC3xENlndzFwXeCF2E7H3Iq2dO_6rPEPZ58DuloqY,16259
+prefab/shapes.py,sha256=58cyXFNh1kEErq2jEbGd3dWSediU1OSmor_FWwc1V8A,25098
+prefab-1.3.0.dist-info/METADATA,sha256=Xvbt_umsD1mZY1S9phLLABxbR18MCuw4disk81IUslY,35025
+prefab-1.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+prefab-1.3.0.dist-info/entry_points.txt,sha256=h1_A9O9F3NAIoKXD1RPb3Eo-WCSiHhMB_AnagBi6XTQ,48
+prefab-1.3.0.dist-info/licenses/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
+prefab-1.3.0.dist-info/RECORD,,

prefab-1.1.9.dist-info/RECORD

@@ -1,14 +0,0 @@
-prefab/__init__.py,sha256=lrYoADI1MlequuC41Rly8vr1kAiFrG8zGw1PILM1rf4,425
-prefab/__main__.py,sha256=1eXWiEoG7eetJMm1qRbK2I5MnzuRgKIoQtBeT-Ps8es,3523
-prefab/compare.py,sha256=0Xgp3tFuP4of-ce9Opc19p8i8lIyXkbVGLuwWBaHSeE,3486
-prefab/device.py,sha256=bN-RkbjhUOXlrnYEJW4H2HqhyxvFrQa15EvhOmGXgkY,54603
-prefab/geometry.py,sha256=4fekWMlkdS_qlPNTdPXPhwKuQ5qdQ1Zjf8m9JKd1dA8,12049
-prefab/models.py,sha256=waPNGtuISyY0f8cz7dnbD451CKYCt8EpPGt-4lSOPNU,2581
-prefab/predict.py,sha256=h13523jasg1WbdiYbkXy43SWTGfQXjq6oEe0O8DT2U0,11731
-prefab/read.py,sha256=WNqC3xENlndzFwXeCF2E7H3Iq2dO_6rPEPZ58DuloqY,16259
-prefab/shapes.py,sha256=58cyXFNh1kEErq2jEbGd3dWSediU1OSmor_FWwc1V8A,25098
-prefab-1.1.9.dist-info/METADATA,sha256=Un--7bA5ihvvtaXK733Q1Zd_8d-EBl1ohWfcdJCdOBI,35036
-prefab-1.1.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-prefab-1.1.9.dist-info/entry_points.txt,sha256=h1_A9O9F3NAIoKXD1RPb3Eo-WCSiHhMB_AnagBi6XTQ,48
-prefab-1.1.9.dist-info/licenses/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
-prefab-1.1.9.dist-info/RECORD,,