quantnet-agent 1.0.0__py3-none-any.whl

quantnet_agent/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

quantnet_agent/cli.py

@@ -0,0 +1,80 @@
+import socket
+import click
+import sys
+from quantnet_agent.service import QuantnetAgent
+from quantnet_agent.common import Constants, Config
+from quantnet_agent.common.logging import setup_logging
+
+
+@click.command("Quantnet Agent")
+@click.option("-c",
+              "--config",
+              default=Constants.DEFAULT_CONFIG_FILE,
+              help="Main configuration file",
+              show_default=True)
+@click.option("-n",
+              "--node-config",
+              default=None,
+              help="Node configuration file",
+              show_default=True)
+@click.option("-a",
+              "--agent_id",
+              default=socket.getfqdn(),
+              help="Specify an agent identifier",
+              show_default=True)
+@click.option("--mq-broker-host",
+              "mq_broker_host",
+              type=str,
+              help="Message queue broker host",
+              show_default=True)
+@click.option("--mq-broker-port",
+              "mq_broker_port",
+              type=int,
+              help="Message queue broker port",
+              show_default=True)
+@click.option("-d",
+              "--debug",
+              is_flag=True,
+              show_default=True,
+              default=False,
+              help="Enable debug logging")
+@click.option("--interpreter-path",
+              "interpreter_path",
+              type=str,
+              help="Location of additional command interpreters",
+              show_default=True)
+@click.option("--schema-path",
+              "schema_path",
+              type=str,
+              help="Specify a path containing additional schema files",
+              show_default=True
+              )
+def main(config,
+         agent_id,
+         node_config,
+         mq_broker_host,
+         mq_broker_port,
+         debug,
+         interpreter_path,
+         schema_path):
+    cobj = Config(config,
+                  node_config,
+                  debug,
+                  agent_id,
+                  mq_broker_host,
+                  mq_broker_port,
+                  interpreter_path,
+                  schema_path)
+
+    if cobj.node_file is None:
+        print("No node configuration file specified. Use --node-config (-n) to provide one.")
+        sys.exit(1)
+
+    setup_logging(cobj)
+
+    agent = QuantnetAgent(cobj)
+    agent.run()
+
+
+if __name__ == "__main__":
+    sys.exit(main())  # pragma: no cover

quantnet_agent/common/__init__.py

@@ -0,0 +1,2 @@
+from .constants import Constants
+from .config import Config

quantnet_agent/common/calibration_status.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class Calibration_status(Enum):
+    FULL = "Full_scale_calibration"
+    LIGHT = "Lightweight_calibration"
+    CHECK = "Status_check"

quantnet_agent/common/config.py

@@ -0,0 +1,135 @@
+import os
+import logging
+import configobj
+import json
+from quantnet_agent.common.constants import Constants
+
+log = logging.getLogger(__name__)
+
+
+def get_config(config_file):
+    config_files = []
+    if config_file:
+        config_files.append(config_file)
+    if "QUANTNET_HOME" in os.environ:
+        config_files.append(f"{os.environ['QUANTNET_HOME']}/etc/agent.cfg")
+    else:
+        config_files.append("/etc/quantnet/agent.cfg")
+
+    for cf in config_files:
+        try:
+            config = configobj.ConfigObj(cf)
+        except IOError:
+            continue
+    return config
+
+
+class Config:
+    def __init__(
+        self,
+        config_file: str = None,
+        node_file: str = None,
+        debug: bool = False,
+        agent_id: str = None,
+        mq_broker_host: str = None,
+        mq_broker_port: int = None,
+        interpreter_path: str = None,
+        schema_path: str = None,
+    ):
+        self._config = None
+        self.devices = {}
+
+        self._config = get_config(config_file)
+
+        if not self._config:
+            log.warning("No configuration file found, continuing with defaults")
+
+        if node_file:
+            self.node_file = node_file
+        else:
+            self.node_file = self.config_get("agent", "node_file", raise_exception=False)
+
+        if mq_broker_host:
+            self.mq_broker_host = mq_broker_host
+        else:
+            self.mq_broker_host = self.config_get("mq", "host", default="127.0.0.1")
+
+        if mq_broker_port:
+            self.mq_broker_port = mq_broker_port
+        else:
+            self.mq_broker_port = self.config_get("mq", "port", default="1883")
+
+        self.threads = int(self.config_get("agent", "threads", default=8))
+
+        if debug:
+            self.debug = debug
+        else:
+            self.config_get("agent", "debug", default=False)
+
+        if agent_id:
+            self.cid = agent_id
+        else:
+            try:
+                self.cid = self.config_get("agent", "agent_id")
+            except Exception:
+                self.cid = None
+
+        if interpreter_path:
+            self.interpreter_path = interpreter_path
+        else:
+            self.interpreter_path = self.config_get("interpreters", "path", raise_exception=False)
+
+        if "protocols" in self._config and len(self._config["protocols"]) > 0:
+            if self.interpreter_path is None:
+                raise Exception("Interpreter location for protocols is not found")
+            self.proto_plugins = self._config["protocols"]
+        else:
+            self.proto_plugins = {}
+
+        if schema_path:
+            self.schema_path = schema_path
+        else:
+            self.schema_path = self.config_get("schemas", "path", raise_exception=False)
+
+        if "devices" in self._config:
+            self.devices = self._config["devices"]
+
+        self.tasks = []
+        self.task_properties = {}
+
+        if "tasks" in self._config:
+            for task, property in self._config["tasks"].items():
+                try:
+                    if type(property) is configobj.Section:
+                        with open(os.path.join(Constants.DEFAULT_TASK_PATH, property["path"]), "r") as file:
+                            calibration_task = json.load(file)
+                            if float(calibration_task["Periodicity"]) <= Constants.SLOTSIZE.total_seconds():
+                                raise Exception(
+                                    f"Task {task} interval is too short."
+                                    "It should be larger than the TDMA slot size "
+                                    f"{Constants.SLOTSIZE.total_seconds() * 1e3 }"
+                                )
+                            self.tasks.append(calibration_task)
+                    else:
+                        self.task_properties[task] = property
+                except Exception as e:
+                    log.error(f"Cannot load local task {task} : {e}")
+
+    def config_get(self, section, option, raise_exception=True, default=None, check_config_table=True):
+        """
+        Return the string value for a given option in a section
+
+        :param section: the named section.
+        :param option: the named option.
+        :param raise_exception: Boolean to raise or not NoOptionError or NoSectionError.
+        :param default: the default value if not found.
+        :param check_config_table: if not set, avoid looking at config table
+        .
+        :returns: the configuration value.
+        """
+        try:
+            return self._config[section][option]
+        except (configobj.ConfigObjError, KeyError) as err:
+            if raise_exception and default is None:
+                raise err
+            return default

quantnet_agent/common/constants.py

@@ -0,0 +1,28 @@
+import os
+from datetime import timedelta
+import quantnet_agent
+
+
+class Constants:
+    DEFAULT_CONFIG_FILE = "./config/agent.cfg"
+    DEFAULT_NODE_CONFIG_FILE = "./config/conf-alice.json"
+    DEFAULT_LOGGING_CONFIG_FILE = "./config/logging.conf"
+    DEFAULT_INTERPRETERS = {
+        "scheduler": "scheduler.py",
+        "calibration": "calibration.py",
+        "experiment": "exp_framework.py",
+    }
+    DEFAULT_TASK_PATH = os.path.join(os.path.dirname(os.path.dirname(quantnet_agent.__file__)), "config/")
+    DEFAULT_TASK_INTERPRETER = os.path.join(
+        os.path.dirname(quantnet_agent.__file__), "hal/interpreter/calibration_interpreter.py"
+    )
+    DEFAULT_TASK_NS = "quantnet_agent.task"
+    HEARTBEAT_INTERVAL = 10
+    REGISTRATION_RETRY_INTERVAL = 10
+    MAX_TIMESLOTS = 20000
+    SLOTSIZE = timedelta(milliseconds=100)
+    SCHEDULER_GRACE_PERIOD = timedelta(milliseconds=50)
+    # TODO: Check SCHEDULER_GRACE_PERIOD < SLOTSIZE * MAX_TIMESLOTS
+    UPDATE_INTERVAL = SLOTSIZE * MAX_TIMESLOTS / 2
+    # TODO: Check if update_interval is appropriate
+    DAG_CHECK_INTERVAL = timedelta(milliseconds=1000)

quantnet_agent/common/logging.py

@@ -0,0 +1,60 @@
+import os
+import sys
+import logging
+import logging.config
+
+
+def quantnet_log_formatter(cobj=None):
+    config_logformat = cobj.config_get(
+        "common",
+        "logformat",
+        raise_exception=False,
+        default="{asctime} {name:<29} {process} {levelname:>8} {message}",
+    )
+    return logging.Formatter(fmt=config_logformat, style='{')
+
+
+def setup_default_logging(cobj=None):
+    """
+    Configures the logging by setting the output stream to stdout and
+    configures log level and log format.
+    """
+    config_loglevel = getattr(logging, cobj.config_get("common", "loglevel",
+                              raise_exception=False, default="INFO").upper())
+
+    stdouthandler = logging.StreamHandler(stream=sys.stdout)
+    stdouthandler.setFormatter(quantnet_log_formatter(cobj))
+    stdouthandler.setLevel(config_loglevel)
+    logging.basicConfig(level=config_loglevel, handlers=[stdouthandler])
+
+
+def setup_logging(cobj=None):
+    """
+    Configures the logging by setting the output stream to stdout and
+    configures log level and log format.
+    """
+
+    configfiles = list()
+
+    if cobj:
+        logging_config_path = cobj.config_get("common", "logging_config", raise_exception=False, default=None)
+        if logging_config_path:
+            configfiles.append(logging_config_path)
+
+    for i in ["QUANTNET_HOME", "VIRTUAL_ENV"]:
+        if i in os.environ:
+            configfiles.append(f"{os.environ[i]}/etc/logging.conf")
+    configfiles.append("/opt/quantnet/etc/logging.conf")
+
+    has_config = False
+    for configfile in configfiles:
+        try:
+            logging.config.fileConfig(configfile, disable_existing_loggers=False)
+            has_config = True
+        except Exception:
+            has_config = False
+        if has_config:
+            break
+
+    if not has_config and cobj:
+        setup_default_logging(cobj)

quantnet_agent/hal/HAL.py

@@ -0,0 +1,231 @@
+import logging
+import ast
+import os
+import importlib
+import sys
+from abc import ABC, abstractmethod
+import traceback
+from pydantic import TypeAdapter
+
+log = logging.getLogger(__name__)
+driver_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "driver")
+
+
+def get_driver_module(classname):
+    for filename in os.listdir(driver_path):
+        f_path = os.path.join(driver_path, filename)
+        if not os.path.isfile(f_path):
+            continue
+        with open(f_path) as file:
+            node = ast.parse(file.read())
+            classes = [n for n in node.body if isinstance(n, ast.ClassDef)]
+            for class_ in classes:
+                if classname == class_.name:
+                    try:
+                        spec = importlib.util.spec_from_file_location(
+                            os.path.splitext(filename)[0], os.path.join(driver_path, filename)
+                        )
+                        module = importlib.util.module_from_spec(spec)
+                        sys.modules["module.name"] = module
+                        spec.loader.exec_module(module)
+                        mod = getattr(module, classname)
+                        return mod
+                    except Exception:
+                        log.error(f"Cannot load driver class {class_.name}")
+                        log.error(traceback.format_exc())
+                        return
+    log.error(f"Cannot find class {classname} from plugin dir")
+
+
+class HardwareAbstractionLayer:
+    def __init__(self, config,  msgclient):
+
+        self.devs = {}
+        self._msgclient = msgclient
+        self._config = config
+
+        for device, property in config.devices.items():
+            enabled = property.get("enabled")
+            if enabled and not TypeAdapter(bool).validate_python(enabled):
+                continue
+            if device in self.devs:
+                log.error(f"Duplicated Device {device}")
+                continue
+            dev_cls = get_driver_module(property["driver"])
+            if dev_cls is None:
+                continue
+            try:
+                dev = dev_cls(property,
+                              config.node_file,
+                              config.mq_broker_host,
+                              config.mq_broker_port)
+            except Exception as e:
+                log.error(f"Cannot instantiate driver class {dev_cls}: {e}")
+                continue
+            self.devs[device] = dev
+
+
+class Interpreter(ABC):
+    """Abstract base class for the Agent Interpreter module.
+
+    Example::
+
+        i = Interpreter(hal)
+
+    :param hal: :doc:`HAL </hal>` object created by :class:`~quantnet_agent.hal.node`.
+    """
+
+    def __init__(self, hal):
+        self.hal = hal
+
+
+class CoreInterpreter(Interpreter):
+    """Abstract base class for the built-in Agent Interpreter module (e.g.,
+    :class:`~quantnet_agent.hal.interpreter.scheduler`).
+
+    Example::
+
+        i = CoreInterpreter(node)
+
+    :param node: :class:`~quantnet_agent.hal.node` object created by :class:`~quantnet_agent.service.node`.
+    """
+
+    def __init__(self, node) -> None:
+        self.node = node
+
+    @abstractmethod
+    def get_commands(self):
+        """Returns a dictionary of RPC handlers for a built-in interpreter to register with the RPC server
+        in the controller. The dictionary keys are the names of RPC endpoints, and the values are lists composed
+        of an RPC handler pointer and a schema model corresponding to the RPC.
+
+        Example::
+
+            def get_commands(self):
+                commands = {
+                    "scheduler.getSchedule": [self.get_schedule, "quantnet_mq.schema.models.scheduler.getSchedule"]
+                }
+                return commands
+        """
+        pass
+
+
+class CMDInterpreter(Interpreter):
+    """Abstract base class for the Agent command Interpreter module (e.g., Link calibration module
+    :class:`~quantnet_agent.hal.interpreter.calibration`).
+
+    Example::
+
+        i = CMDInterpreter(hal)
+
+    :param hal: :doc:`HAL </hal>` object created by :class:`~quantnet_agent.hal.node`.
+    """
+
+    def __init__(self, hal) -> None:
+        super().__init__(hal)
+
+    @abstractmethod
+    def get_commands(self):
+        """Returns a dictionary of RPC handlers for a command interpreter to register with the RPC server
+        in the controller. The dictionary keys are the names of RPC endpoints, and the values are lists
+        composed of an RPC handler pointer and a schema model corresponding to the RPC.
+
+        Example::
+
+            def get_commands(self):
+                commands = {
+                    "calibration.calibration": [self.measure, "quantnet_mq.schema.models.calibration.calibration"]
+                }
+                return commands
+        """
+        pass
+
+
+class ScheduleableInterpreter(CMDInterpreter):
+    """Abstract base class for a schedulable Agent command Interpreter module (e.g.,
+    :class:`~quantnet_agent.hal.interpreter.ExperimentFramework`).
+
+    Example::
+
+        i = ScheduleableInterpreter(hal)
+
+    :param hal: :doc:`HAL </hal>` object created by :class:`~quantnet_agent.hal.node`.
+    """
+
+    def __init__(self, hal) -> None:
+        super().__init__(hal)
+
+    @abstractmethod
+    def get_commands(self):
+        """Returns a dictionary of RPC handlers for a schedulable command interpreter to register with the RPC server
+        in the controller. The dictionary keys are the names of RPC endpoints, and the values are lists composed
+        of an RPC handler pointer and a schema model corresponding to the RPC.
+
+        Example::
+
+            def get_commands(self):
+                commands = {
+                    "experiment.getState": [self.get_state, "quantnet_mq.schema.models.experiment.getState"]
+                }
+                return commands
+        """
+        pass
+
+    @abstractmethod
+    def get_schedulable_commands(self):
+        """Returns a dictionary of RPC handlers for a schedulable command interpreter to register with the RPC server
+        in the two-level scheduler. The RPC endpoints returned by this function are used by the agent scheduler
+        instead of the agent node, enabling the scheduler to allocate a handler to an available timeslot when
+        requested by the global scheduler.
+
+        Keys in the dictionary are the names of the RPC endpoints, and the values are lists composed of
+        an RPC handler pointer, a schema model corresponding to the RPC, and a schema model for the response.
+
+        Example::
+
+            def get_schedulable_commands(self):
+                commands = {
+                    "experiment.submit": [
+                        self.submit,
+                        "quantnet_mq.schema.models.experiment.submit",
+                        experiment.submitResponse,
+                    ]
+                }
+                return commands
+        """
+        pass
+
+
+class LocalTaskInterpreter(Interpreter):
+    """Abstract base class for a local Agent command Interpreter module (e.g., local device calibration).
+
+    Example::
+
+        i = LocalTaskInterpreter(hal)
+
+    :param hal: :doc:`HAL </hal>` object created by :class:`~quantnet_agent.hal.node`.
+    """
+
+    def __init__(self, hal):
+        super().__init__(hal)
+
+    @abstractmethod
+    def run(self, *args, **kwargs):
+        """Execute a local task (e.g., device calibration).
+
+        :param args: Parameters to use for running the local task.
+        :type args: list
+        :param kwargs: Keyword parameter to use for running the local task.
+        :type kwargs: dict
+        """
+        pass
+
+    @abstractmethod
+    def stop(self):
+        """Stops a local task started with the `run` method."""
+        pass
+
+    @abstractmethod
+    async def receive(self, *args, **kwargs):
+        """Receive result of the `run` method."""
+        pass

quantnet_agent/hal/driver/OZoptics.py

@@ -0,0 +1,46 @@
+import serial
+from quantnet_agent.hal.hwclasses import Filter
+import logging
+
+log = logging.getLogger(__name__)
+
+
+class OZOptics(Filter):
+    def __init__(self, config):
+        self.ser = serial.Serial(
+            port=config["port"],
+            baudrate=config["baudrate"],
+            timeout=1,
+            bytesize=serial.EIGHTBITS,
+            stopbits=serial.STOPBITS_ONE,
+        )
+
+        log.info(f"Initialized OZOptics EPC with port={config['port']}")
+        self.buflen = 2048
+
+    @property
+    def okay(self):
+        return True if self.ser else False
+
+    def __ask(self, cmd):
+        if self.ser:
+            self.ser.write(f"{cmd}\r\n".encode())
+            return self.ser.read(self.buflen).decode()
+
+    @property
+    def help(self):
+        return self.__ask("?")
+
+    def _mode_ac(self):
+        self.__ask("MAC")
+
+    def _mode_dc(self):
+        self.__ask("MDC")
+
+    def dst_init(self, request):
+        log.info("Initializing for Calibration")
+        return 0
+
+    def calibrate(self, request):
+        log.info("Starting Calibration")
+        return 0

quantnet_agent/hal/driver/Thorlabs.py

@@ -0,0 +1,39 @@
+from ThorlabsPM100 import ThorlabsPM100, USBTMC
+import numpy as np
+from quantnet_agent.hal.hwclasses import LightMeasurement
+import logging
+
+log = logging.getLogger(__name__)
+
+
+class PM100D(LightMeasurement):
+    def __init__(self, config):
+        inst = USBTMC(device=config["device"])
+        self.dev = ThorlabsPM100(inst=inst)
+        self.pd_bandwidth = self.dev.input.pdiode.filter.lpass.state
+        self.avg_count = self.dev.sense.average.count
+        log.info(f"Initialized PM100D with bw={self.pd_bandwidth} avr={self.avg_count} wavelength={self.wavelength}")
+        log.info(f"Configuration: {self.getconfigure}")
+
+    @property
+    def read(self):
+        return self.dev.read
+
+    @property
+    def wavelength(self):
+        return self.dev.sense.correction.wavelength
+
+    @property
+    def power(self, count=10):
+        request = type('', (), {})()
+        request.count = count
+        self.measure(request)
+
+    @property
+    def getconfigure(self):
+        return self.dev.getconfigure
+
+    def measure(self, request):
+        log.info(f"Reading: {request.count} measurements")
+        power = np.array([self.dev.read for _ in range(request.count)])
+        return power