prefab 0.5.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

prefab/__init__.py

@@ -1,47 +1,19 @@
 """
-The PreFab module provides functionality for predicting and processing photonics
-device layouts, and utilities for interacting with GDSII files.
+The prefab module predicts and corrects nanofabrication variations in photonic devices.
 
 Usage:
     import prefab as pf
 """
 
-# Prediction and Correction
-from prefab.predictor import predict
-from prefab.predictor import correct
+from . import compare, geometry, read
+from .device import BufferSpec, Device
+from .models import models
 
-# I/O Utilities
-# Function to load/save device images and gds files
-from prefab.io import (
-    load_device_img,  # Load device from an image file
-    load_device_gds,  # Load device from a GDSII file
-    device_to_cell,  # Convert a device layout to a gdstk cell
-)
-
-# Import image processing utilities
-# Functions to modify and manipulate device images
-from prefab.processor import (
-    binarize,  # Soft binarization of grayscale images
-    binarize_hard,  # Hard binarization of grayscale images
-    ternarize,  # Ternarization of grayscale images
-    remove_padding,  # Trims excess padding from device images
-    zero_boundary,  # Applies zero boundary to device images
-    generate_device_contour,  # Generates contour of device images
-    calculate_prediction_uncertainty,  # Computes prediction uncertainty for device images
-    mse,  # Computes mean squared error between two images
-)
-
-__all__ = (
-    "predict",
-    "load_device_img",
-    "load_device_gds",
-    "device_to_cell",
-    "binarize",
-    "binarize_hard",
-    "ternarize",
-    "remove_padding",
-    "zero_boundary",
-    "generate_device_contour",
-    "calculate_prediction_uncertainty",
-    "mse",
-)
+__all__ = [
+    "Device",
+    "BufferSpec",
+    "geometry",
+    "read",
+    "compare",
+    "models",
+]

prefab/__main__.py

@@ -1,17 +1,18 @@
-"""Main entry point for the Prefab CLI."""
+"""Provides the main entry point for the Prefab CLI."""
+
 import argparse
 import os
 import threading
 import webbrowser
+from contextlib import suppress
 from http.server import BaseHTTPRequestHandler, HTTPServer
 
 import toml
 
 
 def store_jwt_securely(jwt, refresh_token):
-    """
-    Store the JWT and refresh token securely in a TOML file.
-    """
+    """Store the JWT and refresh token securely in a TOML file."""
+
     prefab_file_path = os.path.expanduser("~/.prefab.toml")
     with open(prefab_file_path, "w", encoding="utf-8") as toml_file:
         toml.dump({"access_token": jwt, "refresh_token": refresh_token}, toml_file)
@@ -28,9 +29,7 @@ class GracefulHTTPServer(HTTPServer):
 
 
 class CallbackHandler(BaseHTTPRequestHandler):
-    """
-    A request handler for the HTTP server that handles the OAuth callback.
-    """
+    """A request handler for the HTTP server that handles the OAuth callback."""
 
     def do_GET(self):
         if self.path.startswith("/callback"):
@@ -56,6 +55,7 @@ class CallbackHandler(BaseHTTPRequestHandler):
 
 
 def main():
+    """Main function for the Prefab CLI."""
     parser = argparse.ArgumentParser(description="Prefab CLI")
     parser.add_argument("command", help="The command to run", choices=["setup"])
     parser.add_argument(
@@ -68,10 +68,8 @@ def main():
         webbrowser.open("https://www.prefabphotonics.com/token-flow")
         httpd = GracefulHTTPServer(("localhost", args.port), CallbackHandler)
         print("Started token authentication flow on the web browser...")
-        try:
+        with suppress(KeyboardInterrupt):
             httpd.serve_forever()
-        except KeyboardInterrupt:
-            pass
         httpd.server_close()
     else:
         print(f"Command {args.command} not recognized.")

prefab/compare.py

@@ -0,0 +1,92 @@
+"""Provides functions to measure the similarity between devices."""
+
+import numpy as np
+
+from .device import Device
+
+
+def mean_squared_error(device_a: Device, device_b: Device) -> float:
+    """
+    Calculate the mean squared error (MSE) between two non-binarized devices.
+
+    Parameters
+    ----------
+    device_a : Device
+        The first device.
+    device_b : Device
+        The second device.
+
+    Returns
+    -------
+    float
+        The mean squared error between two devices. A lower value indicates more
+        similarity.
+    """
+    return np.mean((device_a.device_array - device_b.device_array) ** 2)
+
+
+def intersection_over_union(device_a: Device, device_b: Device) -> float:
+    """
+    Calculates the Intersection over Union (IoU) between two binary devices.
+
+    Parameters
+    ----------
+    device_a : Device
+        The first device.
+    device_b : Device
+        The second device.
+
+    Returns
+    -------
+    float
+        The Intersection over Union between two devices. A value closer to 1 indicates
+        more similarity (more overlap).
+    """
+    return np.sum(
+        np.logical_and(device_a.device_array, device_b.device_array)
+    ) / np.sum(np.logical_or(device_a.device_array, device_b.device_array))
+
+
+def hamming_distance(device_a: Device, device_b: Device) -> int:
+    """
+    Calculates the Hamming distance between two binary devices.
+
+    Parameters
+    ----------
+    device_a : Device
+        The first device.
+    device_b : Device
+        The second device.
+
+    Returns
+    -------
+    int
+        The Hamming distance between two devices. A lower value indicates more
+        similarity.
+    """
+    return np.sum(device_a.device_array != device_b.device_array)
+
+
+def dice_coefficient(device_a: Device, device_b: Device) -> float:
+    """
+    Calculates the Dice coefficient between two binary devices.
+
+    Parameters
+    ----------
+    device_a : Device
+        The first device.
+    device_b : Device
+        The second device.
+
+    Returns
+    -------
+    float
+        The Dice coefficient between two devices. A value closer to 1 indicates more
+        similarity.
+    """
+    intersection = 2.0 * np.sum(
+        np.logical_and(device_a.device_array, device_b.device_array)
+    )
+    size_a = np.sum(device_a.device_array)
+    size_b = np.sum(device_b.device_array)
+    return intersection / (size_a + size_b)