sqil-core 0.1.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

sqil_core/experiment/helpers/_function_override_handler.py

@@ -0,0 +1,111 @@
+from abc import ABC, abstractmethod
+from contextlib import contextmanager
+from types import MethodType
+from typing import Callable
+
+
+class FunctionOverrideHandler(ABC):
+    """
+    A base class that allows functions to be overridden, restored, and temporarily replaced.
+
+    Attributes
+    ----------
+    _default_functions : dict
+        A dictionary storing the default functions of the object.
+    _functions : dict
+        A dictionary storing the current functions, which may include overridden versions.
+    """
+
+    def __init__(self):
+        """
+        Initializes the handler with empty dictionaries for default and overridden functions.
+        """
+        self._default_functions = {}
+        self._functions = {}
+
+    def override_function(self, func_name, new_func):
+        """
+        Overrides a function with a new implementation.
+
+        Parameters
+        ----------
+        func_name : str
+            The name of the function to override.
+        new_func : function
+            The new function implementation.
+        """
+        if func_name in self._functions:
+            self._functions[func_name] = MethodType(new_func, self)
+        else:
+            raise AttributeError(f"Function '{func_name}' not found in the object.")
+
+    def restore_function(self, func_name):
+        """
+        Restores a function to its default implementation.
+
+        Parameters
+        ----------
+        func_name : str
+            The name of the function to restore.
+        """
+        if func_name in self._default_functions:
+            self._functions[func_name] = self._default_functions[func_name]
+        else:
+            raise AttributeError(
+                f"Default for function '{func_name}' not found in the object."
+            )
+
+    @contextmanager
+    def temporary_override(self, func_name, temp_func):
+        """
+        Temporarily overrides a function within a context manager.
+
+        Parameters
+        ----------
+        func_name : str
+            The name of the function to override temporarily.
+        temp_func : function
+            The temporary function implementation.
+
+        Yields
+        ------
+        None
+        """
+        if func_name not in self._functions:
+            raise AttributeError(f"Function '{func_name}' not found in the object.")
+
+        original_func = self._functions[func_name]
+        try:
+            self._functions[func_name] = MethodType(temp_func, self)
+            yield
+        finally:
+            self._functions[func_name] = original_func  # Restore the original
+
+    def restore_all_functions(self):
+        """
+        Restores all overridden functions to their default implementations.
+        """
+        self._functions = self._default_functions.copy()
+
+    def call(self, func_name, *args, **kwargs):
+        """
+        Calls a function by its name, passing any provided arguments.
+
+        Parameters
+        ----------
+        func_name : str
+            The name of the function to call.
+        *args : tuple
+            Positional arguments to pass to the function.
+        **kwargs : dict
+            Keyword arguments to pass to the function.
+
+        Returns
+        -------
+        Any
+            The return value of the called function.
+        """
+        if func_name in self._functions:
+            return self._functions[func_name](*args, **kwargs)
+        else:
+            raise AttributeError(f"Function '{func_name}' not found in Instrument.")

sqil_core/experiment/helpers/_labone_wrappers.py

@@ -0,0 +1,12 @@
+import json
+
+from laboneq import serializers
+
+
+def w_save(obj, path):
+    serializers.save(obj, path)
+    # Re-open the file, read the content, and re-save it pretty-printed
+    with open(path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=4, ensure_ascii=False)

sqil_core/experiment/instruments/__init__.py

@@ -0,0 +1,2 @@
+from ._instrument import Instrument
+from .local_oscillator import LocalOscillator

sqil_core/experiment/instruments/_instrument.py

@@ -0,0 +1,190 @@
+from abc import ABC, abstractmethod
+
+import Pyro5.server
+from blinker import NamedSignal
+
+from sqil_core.config_log import logger
+from sqil_core.experiment._events import (
+    after_experiment,
+    after_sequence,
+    before_experiment,
+    before_sequence,
+    one_time_listener,
+)
+from sqil_core.experiment.helpers._function_override_handler import (
+    FunctionOverrideHandler,
+)
+
+
+@Pyro5.server.expose
+class Instrument(FunctionOverrideHandler, ABC):
+    """
+    Base class for instruments with configurable behavior.
+
+    Supports overriding `connect`, `setup`, and `disconnect` methods
+    via a configuration dictionary.
+    """
+
+    def __init__(self, id: str, config: dict):
+        """
+        Initializes the instrument with an ID and configuration.
+
+        If `connect`, `setup`, or `disconnect` are provided in `config`,
+        they override the default implementations.
+        """
+        super().__init__()
+
+        self._id = id
+        self._type = config.get("type", "")
+        self._model = config.get("model", "")
+        self._name = config.get("name", "")
+        self._address = config.get("address", "")
+        self._variables = config.get("variables", {})
+        self._config = config
+        self._device = None
+
+        self._default_functions = {
+            "connect": self._default_connect,
+            "setup": self._default_setup,
+            "disconnect": self._default_disconnect,
+            "on_before_experiment": self._default_on_before_experiment,
+            "on_after_experiment": self._default_on_after_experiment,
+            "on_before_sequence": self._default_on_before_sequence,
+            "on_after_sequence": self._default_on_after_sequence,
+        }
+        self._functions = self._default_functions.copy()
+
+        # Override functions if provided in config
+        for method_name in self._default_functions:
+            if method := config.get(method_name):
+                self.override_function(method_name, method)
+
+        self._default_functions = self._functions.copy()
+        self._device = self.connect()  # Auto-connect on instantiation
+
+        # Subscribe to events
+        self._subscribe_to_events()
+
+    def _subscribe_to_events(self):
+        before_experiment.connect(
+            lambda *a, **kw: self.call("on_before_experiment", *a, **kw), weak=False
+        )
+        before_sequence.connect(
+            lambda *a, **kw: self.call("on_before_sequence", *a, **kw), weak=False
+        )
+        after_sequence.connect(
+            lambda *a, **kw: self.call("on_after_sequence", *a, **kw), weak=False
+        )
+        after_experiment.connect(
+            lambda *a, **kw: self.call("on_after_experiment", *a, **kw), weak=False
+        )
+
+    def connect(self, *args, **kwargs):
+        """Calls the overridden or default `connect` method."""
+        return self.call("connect", *args, **kwargs)
+
+    @abstractmethod
+    def _default_connect(self, *args, **kwargs):
+        """Default `connect` implementation (must be overridden)."""
+        pass
+
+    def setup(self, *args, **kwargs):
+        """Calls the overridden or default `setup` method."""
+        return self.call("setup", *args, **kwargs)
+
+    @abstractmethod
+    def _default_setup(self, *args, **kwargs):
+        """Default `setup` implementation (must be overridden)."""
+        pass
+
+    def disconnect(self, *args, **kwargs):
+        """Calls the overridden or default `disconnect` method."""
+        return self.call("disconnect", *args, **kwargs)
+
+    @abstractmethod
+    def _default_disconnect(self, *args, **kwargs):
+        pass
+
+    def on_before_experiment(self, *args, **kwargs):
+        """Calls the overridden or default `on_before_experiment` method."""
+        return self.call("on_before_experiment", *args, **kwargs)
+
+    def _default_on_before_experiment(self, *args, **kwargs):
+        pass
+
+    def on_before_sequence(self, *args, **kwargs):
+        """Calls the overridden or default `on_before_sequence` method."""
+        return self.call("on_before_sequence", *args, **kwargs)
+
+    def _default_on_before_sequence(self, *args, **kwargs):
+        pass
+
+    def on_after_experiment(self, *args, **kwargs):
+        """Calls the overridden or default `on_after_experiment` method."""
+        return self.call("on_after_experiment", *args, **kwargs)
+
+    def _default_on_after_experiment(self, *args, **kwargs):
+        pass
+
+    def on_after_sequence(self, *args, **kwargs):
+        """Calls the overridden or default `on_after_sequence` method."""
+        return self.call("on_after_sequence", *args, **kwargs)
+
+    def _default_on_after_sequence(self, *args, **kwargs):
+        pass
+
+    def __getattr__(self, name):
+        """
+        Dynamically expose all attributes to Pyro server.
+        """
+        if name in self.__dict__:
+            return self.__dict__[name]
+        raise AttributeError(
+            f"'{self.__class__.__name__}' object has no attribute '{name}'"
+        )
+
+    def get_variable(self, key, *args, **kwargs):
+        var = self._variables.get(key, None)
+        if callable(var):
+            var = var(*args, **kwargs)
+        return var
+
+    @property
+    def id(self):
+        """Instrument ID (read-only)."""
+        return self._id
+
+    @property
+    def type(self):
+        """Instrument type (read-only)."""
+        return self._type
+
+    @property
+    def model(self):
+        """Instrument model (read-only)."""
+        return self._model
+
+    @property
+    def name(self):
+        """Instrument name (read-only)."""
+        return self._name
+
+    @property
+    def address(self):
+        """Instrument address (read-only)."""
+        return self._address
+
+    @property
+    def variables(self):
+        """Instrument variables (read-only)."""
+        return self._variables
+
+    @property
+    def config(self):
+        """Instrument configuration dictionary (read-only)."""
+        return self._config
+
+    @property
+    def device(self):
+        """Raw instrument instance (read-only)."""
+        return self._device