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

prefab/__init__.py

@@ -1,47 +1,24 @@
 """
-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
+__version__ = "1.1.7"
 
-# 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
-)
+from . import compare, geometry, predict, read, shapes
+from .device import BufferSpec, Device
+from .models import models
 
-# 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__ = (
+__all__ = [
+    "Device",
+    "BufferSpec",
+    "geometry",
     "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",
-)
+    "read",
+    "shapes",
+    "compare",
+    "models",
+    "__version__",
+]

prefab/__main__.py

@@ -1,21 +1,26 @@
-"""Main entry point for the Prefab CLI."""
+"""Provides the main entry point for the Prefab authentication 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.
-    """
+def store_jwt(jwt, refresh_token):
+    """Store the JWT and refresh token 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)
-    print(f"Token successfully stored in {prefab_file_path}")
+    print(
+        f"Token successfully stored in {prefab_file_path}.\n\n"
+        "🎉 Welcome to PreFab!.\n"
+        "See our examples at https://docs.prefabphotonics.com/examples to start.\n"
+        "Reach out to us at hi@prefabphotonics.com if you have any questions."
+    )
 
 
 class GracefulHTTPServer(HTTPServer):
@@ -28,9 +33,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 JWT-auth callback."""
 
     def do_GET(self):
         if self.path.startswith("/callback"):
@@ -42,8 +45,8 @@ class CallbackHandler(BaseHTTPRequestHandler):
             jwt_token = params.get("token")
             refresh_token = params.get("refresh_token")
             if jwt_token and refresh_token:
-                print("Token verified!")
-                store_jwt_securely(jwt_token, refresh_token)
+                print("Token verified.")
+                store_jwt(jwt_token, refresh_token)
                 self.send_response_only(200, "OK")
                 self.send_header("Content-type", "text/html")
                 self.end_headers()
@@ -56,22 +59,20 @@ class CallbackHandler(BaseHTTPRequestHandler):
 
 
 def main():
-    parser = argparse.ArgumentParser(description="Prefab CLI")
+    """Main function for the Prefab authentication CLI."""
+    parser = argparse.ArgumentParser(description="PreFab Auth CLI")
     parser.add_argument("command", help="The command to run", choices=["setup"])
     parser.add_argument(
         "--port", help="Port number for the HTTP server", type=int, default=8000
     )
-
     args = parser.parse_args()
 
     if args.command == "setup":
         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,126 @@
+"""Functions to measure the structural similarity between devices."""
+
+import warnings
+
+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 devices. A lower value indicates
+    more similarity.
+
+    Parameters
+    ----------
+    device_a : Device
+        The first device.
+    device_b : Device
+        The second device.
+
+    Returns
+    -------
+    float
+        The mean squared error between two devices.
+    """
+    return float(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. A value
+    closer to 1 indicates more similarity (more overlap).
+
+    Parameters
+    ----------
+    device_a : Device
+        The first device (binarized).
+    device_b : Device
+        The second device (binarized).
+
+    Returns
+    -------
+    float
+        The Intersection over Union between two devices.
+
+    Warnings
+    --------
+    UserWarning
+        If one or both devices are not binarized.
+    """
+    if not device_a.is_binary or not device_b.is_binary:
+        warnings.warn(
+            "One or both devices are not binarized.", UserWarning, stacklevel=2
+        )
+
+    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. A lower value indicates
+    more similarity. The Hamming distance is calculated as the number of positions at
+    which the corresponding pixels are different.
+
+    Parameters
+    ----------
+    device_a : Device
+        The first device (binarized).
+    device_b : Device
+        The second device (binarized).
+
+    Returns
+    -------
+    int
+        The Hamming distance between two devices.
+
+    Warnings
+    --------
+    UserWarning
+        If one or both devices are not binarized.
+    """
+    if not device_a.is_binary or not device_b.is_binary:
+        warnings.warn(
+            "One or both devices are not binarized.", UserWarning, stacklevel=2
+        )
+
+    return int(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. A value closer to 1
+    indicates more similarity. The Dice coefficient is calculated as twice the number of
+    pixels in common divided by the total number of pixels in the two devices.
+
+    Parameters
+    ----------
+    device_a : Device
+        The first device (binarized).
+    device_b : Device
+        The second device (binarized).
+
+    Returns
+    -------
+    float
+        The Dice coefficient between two devices.
+
+    Warnings
+    --------
+    UserWarning
+        If one or both devices are not binarized.
+    """
+    if not device_a.is_binary or not device_b.is_binary:
+        warnings.warn(
+            "One or both devices are not binarized.", UserWarning, stacklevel=2
+        )
+
+    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)