sqil-core 0.0.2__py3-none-any.whl → 1.0.0__py3-none-any.whl

sqil_core/__init__.py

@@ -1,3 +1,7 @@
-from .utils import extract_h5_data, read_param_dict
+import sqil_core.experiment as experiment
+import sqil_core.fit as fit
+import sqil_core.resonator as resonator
+import sqil_core.utils as utils
+from sqil_core.utils import *
 
-__all__ = ["extract_h5_data", "read_param_dict"]
+__all__ = utils.__all__ + ["utils", "fit", "resonator"]

sqil_core/config.py

@@ -0,0 +1,13 @@
+_EXCLUDED_PACKAGES = [
+    "os",
+    "sys",
+    "inspect",
+    "np",
+    "spopt",
+    "lmfit",
+    "h5py",
+    "json",
+    "tabulate",
+    "matplotlib",
+    "plt",
+]

sqil_core/config_log.py

@@ -0,0 +1,42 @@
+import logging
+
+from colorama import Fore, Style, init
+
+# Initialize Colorama
+init(autoreset=True, strip=False, convert=False)
+
+
+class SqilFormatter(logging.Formatter):
+    FORMAT = "%(asctime)s - %(levelname)s - %(message)s"
+
+    COLOR_MAP = {
+        "DEBUG": Fore.BLUE,
+        "INFO": Fore.GREEN,
+        "WARNING": Fore.YELLOW,
+        "ERROR": Fore.RED,
+        "CRITICAL": Fore.RED + Style.BRIGHT,
+    }
+
+    def format(self, record):
+        log_color = self.COLOR_MAP.get(record.levelname, "")
+        record.levelname = f"{log_color}{record.levelname}{Style.RESET_ALL}"
+        return super().format(record)
+
+
+class SqilLogger(logging.Logger):
+    # By default show the stack trace when errors are logged
+    def error(self, msg, *args, exc_info=True, **kwargs):
+        super().error(msg, *args, exc_info=exc_info, **kwargs)
+
+
+logging.setLoggerClass(SqilLogger)
+logger = logging.getLogger("sqil_logger")
+logger.setLevel(logging.DEBUG)
+
+console_handler = logging.StreamHandler()
+console_handler.setLevel(logging.DEBUG)
+console_handler.setFormatter(SqilFormatter(SqilFormatter.FORMAT))
+
+# Avoid adding multiple handlers if the logger is reused
+if not logger.hasHandlers():
+    logger.addHandler(console_handler)

sqil_core/experiment/__init__.py

@@ -0,0 +1,11 @@
+from ._analysis import AnalysisResult
+from ._events import after_experiment, before_experiment
+from ._experiment import ExperimentHandler
+from .instruments._instrument import Instrument
+from .instruments.local_oscillator import LocalOscillator
+from .instruments.server import (
+    InstrumentServer,
+    link_instrument_server,
+    start_instrument_server,
+    unlink_instrument_server,
+)

sqil_core/experiment/_analysis.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import h5py
+import mpld3
+import numpy as np
+
+from sqil_core.utils import get_measurement_id
+
+if TYPE_CHECKING:
+    from matplotlib.figure import Figure
+
+    from sqil_core.fit import FitResult
+
+
+class AnalysisResult:
+    updated_params: dict[str, dict] = {}
+    figures: dict[str, Figure] = {}
+    fits: dict[str, FitResult] = {}
+    extra_data: dict[str, np.ndarray] = {}
+
+    def __init__(
+        self,
+        updated_params: dict[str, dict] = {},
+        figures: dict[str, Figure] = {},
+        fits: dict[str, FitResult] = {},
+        extra_data: dict[str, np.ndarray] = {},
+    ):
+        self.updated_params = updated_params or {}
+        self.figures = figures or {}
+        self.fits = fits or {}
+        self.extra_data = extra_data or {}
+
+    def add_exp_info_to_figures(self, dir_path: str):
+        if not self.figures:
+            return
+        id = get_measurement_id(dir_path)
+        cooldown_name = Path(dir_path).parts[-3]
+        for _, fig in self.figures.items():
+            # Add dummy text to infer font size
+            dummy_text = fig.text(0, 0, "dummy", visible=False)
+            font_size = dummy_text.get_fontsize()
+            dummy_text.remove()
+            fig.text(
+                0.98,
+                0.98,
+                f"{cooldown_name}\n{id} | {dir_path[-16:]}",
+                ha="right",
+                va="top",
+                color="gray",
+                fontsize=font_size * 0.8,
+            )
+
+    def save_figures(self, dir_path: str):
+        """Saves figures both as png and interactive html."""
+        for key, fig in self.figures.items():
+            path = os.path.join(dir_path, key)
+            fig.savefig(os.path.join(f"{path}.png"), bbox_inches="tight", dpi=300)
+            html = mpld3.fig_to_html(fig)
+            with open(f"{path}.html", "w") as f:
+                f.write(html)
+
+    def aggregate_fit_summaries(self):
+        """Aggreate all the fit summaries and include model name."""
+        result = ""
+        for key, fit in self.fits.items():
+            summary = fit.summary(no_print=True)
+            result += f"{key}\nModel: {fit.model_name}\n{summary}\n"
+        return result
+
+    def save_fits(self, dir_path: str):
+        if not self.fits:
+            return
+        with open(os.path.join(dir_path, "fit.mono.md"), "w", encoding="utf-8") as f:
+            f.write(self.aggregate_fit_summaries())
+
+    def save_extra_data(self, dir_path: str):
+        if not self.extra_data:
+            return
+        with h5py.File(os.path.join(dir_path, "extra.ddh5"), "a") as f:
+            grp = f.require_group("data")
+            for key, array in self.extra_data.items():
+                # Overwrite if already exists
+                if key in grp:
+                    del grp[key]
+            grp.create_dataset(key, data=array)
+
+    def save_all(self, dir_path: str):
+        self.add_exp_info_to_figures(dir_path)
+        self.save_figures(dir_path)
+        self.save_fits(dir_path)
+        self.save_extra_data(dir_path)

sqil_core/experiment/_events.py

@@ -0,0 +1,25 @@
+from blinker import NamedSignal
+
+before_experiment = NamedSignal("before_experiment")
+after_experiment = NamedSignal("after_experiment")
+
+before_sequence = NamedSignal("before_sequence")
+after_sequence = NamedSignal("after_sequence")
+
+
+def clear_signal(signal):
+    """Removes all listeners (receivers) from an event (signal)."""
+    receivers = list(signal.receivers.values())
+    for receiver in receivers:
+        signal.disconnect(receiver)
+
+
+def one_time_listener(signal, func):
+    """Listens for an event only once."""
+
+    def wrapper(*args, **kwargs):
+        signal.disconnect(wrapper)
+        return func(*args, **kwargs)
+
+    signal.connect(wrapper, weak=False)
+    return wrapper