mosca-client 2.0.1__py3-none-any.whl

mosca_client/tango/devices/dante.py

@@ -0,0 +1,116 @@
+import time
+
+
+from ..mca import McaBase
+
+
+# from .base import McaController, TriggerMode
+
+
+class Dante(McaBase):
+    """XGLab's Dante mosca 2 client."""
+
+    # Bounds for config_file's wait loop, in seconds.
+    CONFIG_LOAD_START_WAIT = 5.
+    CONFIG_LOAD_TIMEOUT = 60.
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def __info__(self) -> str:
+        """
+        Add specific information for XIA controllers.
+        """
+        txt = super().__info__()
+        txt += f"\n * config file:  {self.config_file}\n"
+        txt += f" * gating mode:  {self.gating_mode}\n"
+        return txt
+
+    # def _apply_settings(self, config_file=None, **kwargs):
+    #     if config_file is not None:
+    #         self.config_file = config_file
+    #     return super()._apply_settings(**kwargs)
+
+    def stats_mapping(self):
+        return {
+        "realtime": "elapsed_time",
+        "trigger_livetime": "trigger_livetime",
+        "icr": "icr",
+        "ocr": "ocr",
+    }
+
+    @property
+    def gating_mode(self):
+        return self.proxy.gating_mode
+
+    def available_configurations(self):
+        return self.proxy.available_configurations
+
+    def _load_configuration(self, configuration: str | None = None) -> None:
+        proxy = self.proxy
+        print(f"Setting config file to {configuration}. This may take a while.")
+        proxy.set_configuration_file_async(configuration)
+
+        # Wait for the server to actually start processing the request
+        # (mca_status flips to UNINITIALIZED) instead of blindly sleeping
+        # for a fixed amount of time -- avoids racing against slow thread
+        # scheduling on the server side, which could otherwise let a stale
+        # prior status (e.g. READY) slip past the checks below undetected.
+        start_deadline = time.time() + self.CONFIG_LOAD_START_WAIT
+        while proxy.mca_status != "UNINITIALIZED" and time.time() < start_deadline:
+            time.sleep(0.1)
+
+        if proxy.mca_status != "UNINITIALIZED":
+            raise RuntimeError(
+                f"Server did not start processing config [{configuration}] "
+                f"(mca_status still {proxy.mca_status!r} after "
+                f"{self.CONFIG_LOAD_START_WAIT}s)."
+            )
+
+        deadline = time.time() + self.CONFIG_LOAD_TIMEOUT
+        spin = ["\\", "-", "/", "-"]
+        i = 0
+        while proxy.mca_status == "UNINITIALIZED":
+            if time.time() > deadline:
+                raise RuntimeError(
+                    f"Timed out waiting for config [{configuration}] to load "
+                    f"(still UNINITIALIZED after {self.CONFIG_LOAD_TIMEOUT}s)."
+                )
+            init_msg = proxy.init_message
+            print(f"\033[KIn progress [{spin[i%4]}] {init_msg} ", end="\r")
+            time.sleep(0.3)
+            i = (i + 1) % 4
+
+        init_msg = proxy.init_message
+        print(f"\033[K{init_msg}")
+        if proxy.mca_status != "READY":
+            raise RuntimeError(
+                f"Failed to load config [{configuration}]. Please check server logs."
+            )
+        return self.current_configuration()
+
+    def current_configuration(self):
+        return self.proxy.configuration_file
+
+    @property
+    def config_files_list(self):
+        # legacy code
+        return self.available_configurations()
+        
+    @property
+    def config_file(self):
+        # legacy code
+        return self.current_configuration()
+
+    @config_file.setter
+    def config_file(self, config_file):
+       # legacy code
+       self.load_configuration(config_file)
+
+    @property
+    def config_dir(self):
+        # legacy code
+        return self.proxy.configuration_directory
+
+
+Mca = Dante

mosca_client/tango/devices/danteplus.py

@@ -0,0 +1,8 @@
+from .dante import Dante
+
+
+class DantePlus(Dante):
+    pass
+
+
+Mca = DantePlus

mosca_client/tango/devices/dummy.py

@@ -0,0 +1,9 @@
+from ..mca import McaBase
+from .simulation import SimulatorMixin
+
+
+class Dummy(SimulatorMixin, McaBase):
+    pass
+
+
+Mca = Dummy

mosca_client/tango/devices/falconx.py

@@ -0,0 +1,71 @@
+import numpy as np
+
+from .xia import Xia
+
+
+class FalconX(Xia):
+    def __info__(self) -> str:
+        txt = super().__info__()
+        txt += f" * mca_refresh:   {self.proxy.mca_refresh:.4f} s\n"
+        return txt
+
+    def scan_metadata(self) -> dict:
+        metadata = super().scan_metadata()
+        metadata["mca_refresh"] = self.proxy.mca_refresh
+        return metadata
+
+    def filter_parameters(self,
+                          acq_realtime=None,
+                          block_size=None,
+                          trigger_mode=None,
+                          mca_refresh=None,
+                          **kwargs):
+        """ Computes mca_refresh and block_size if not provided.
+            * mca_refresh: 0.01 <= acq_realtime or 0.1 <= 0.1
+            * block_size: 1 <= 1 / acq_realtime <= 1020
+            Attention: block_size is not changed if acq_realtime
+                is None or nul!
+        """
+
+        params = super().filter_parameters(**kwargs)
+
+        acq_realtime = params.get("acq_realtime", acq_realtime)
+        block_size = params.get("block_size", block_size)
+        trigger_mode = params.get("trigger_mode", trigger_mode)
+        mca_refresh = params.get("mca_refresh", mca_refresh)
+
+        if trigger_mode == "INT_TRIG_READOUT":
+            params["acq_nb_points"] = 1
+
+        if mca_refresh is None:
+            mca_refresh = np.clip(acq_realtime or 0.1,
+                                  0.01, 0.1)
+            params["mca_refresh"] = float(mca_refresh)
+
+        if block_size is None and acq_realtime:
+            if trigger_mode in ("GATE", "EXT_TRIG"):
+                # aiming for a buffer swap every second
+                block_size = np.clip(
+                    1. / acq_realtime,
+                    1, 1020)
+                params["block_size"] = int(block_size)
+
+        return params
+
+    def set_parameters(self,
+                       mca_refresh=None,
+                       **kwargs) -> None:
+        super().set_parameters(**kwargs)
+        if mca_refresh is not None:
+            self.proxy.mca_refresh = mca_refresh
+
+    @property
+    def mca_refresh(self) -> float:
+        return self.proxy.mca_refresh
+
+    @mca_refresh.setter
+    def mca_refresh(self, value: float) -> None:
+        self.proxy.mca_refresh = value
+
+
+Mca = FalconX

mosca_client/tango/devices/generator.py

@@ -0,0 +1,58 @@
+from tango import DeviceProxy
+
+from ..utils import is_ds_exported, Callback
+
+
+class Generator:
+    def __init__(self, name, tg_url):
+        self._name = name
+
+        self._tg_url = tg_url
+        self._proxy = None
+
+    @property
+    def proxy(self):
+        if self._proxy is None:
+            if not is_ds_exported(self._tg_url):
+                raise RuntimeError(f"Server {self._tg_url} doesn't seem to be running.")
+            self._proxy = DeviceProxy(self._tg_url)
+        return self._proxy
+
+    # TODO: put this in bliss
+    def __info__(self):
+        return f"Generator {self.__class__.__name__} ({self.proxy.name()})"
+
+    @property
+    def acq_nb_points(self):
+        return self.proxy.acq_nb_points
+
+    @acq_nb_points.setter
+    def acq_nb_points(self, acq_nb_points):
+        self.proxy.acq_nb_points = acq_nb_points
+
+    @property
+    def trigger_mode(self):
+        return self.proxy.trigger_mode
+
+    @trigger_mode.setter
+    def trigger_mode(self, trigger_mode):
+        self.proxy.trigger_mode = trigger_mode
+
+    @property
+    def acq_realtime(self):
+        return self.proxy.acq_realtime
+
+    @acq_realtime.setter
+    def acq_realtime(self, acq_realtime):
+        self.proxy.acq_realtime = acq_realtime
+
+    @property
+    def use_external_trigger(self):
+        return self.proxy.use_external_trigger
+
+    @use_external_trigger.setter
+    def use_external_trigger(self, use_external_trigger):
+        self.proxy.use_external_trigger = use_external_trigger
+
+    def hw_trig(self):
+        self.proxy.hw_trig()

mosca_client/tango/devices/simdante.py

@@ -0,0 +1,9 @@
+from .dante import Dante
+from .simulation import SimulatorMixin
+
+
+class SimDante(SimulatorMixin, Dante):
+    pass
+
+
+Mca = SimDante

mosca_client/tango/devices/simfalconx.py

@@ -0,0 +1,9 @@
+from .falconx import FalconX
+from .simulation import SimulatorMixin
+
+
+class SimFalconX(SimulatorMixin, FalconX):
+    pass
+
+
+Mca = SimFalconX

mosca_client/tango/devices/simulation.py

@@ -0,0 +1,18 @@
+from tango import DeviceProxy
+
+
+class SimulatorMixin:
+    def __init__(self, *args, **kwargs):
+        self._generator = None
+        super().__init__(*args, **kwargs)
+
+    def generator(self):
+        if self._generator is None:
+            # keep everything before "family/instance" as-is, so this
+            # also works with a fully-qualified tango://host:port/... URL
+            parts = self.tg_url.split("/")
+            prefix = "/".join(parts[:-2])
+            instance = parts[-1]
+            tg_name = f"{prefix}/generator/{instance}"
+            self._generator = DeviceProxy(tg_name)
+        return self._generator

mosca_client/tango/devices/xia.py

@@ -0,0 +1,66 @@
+from ..mca import McaBase
+from ..utils import ChangeTangoTimeout
+
+
+class Xia(McaBase):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def stats_mapping(self):
+        return {
+        # MOSCA    :  NxWriter
+        "output": "events",
+        "icr": "icr",
+        "ocr": "ocr",
+        "livetime": "trigger_livetime",
+        "deadtime": "deadtime",
+        "realtime": "realtime",
+        "triggers": "triggers",
+        "livetime_events": "energy_livetime",
+        "deadtime_correction": "deadtime_correction",
+    }
+
+    # def _apply_settings(self, ini_file=None, **kwargs):
+        # if ini_file:
+        #     self.configuration_file = ini_file
+        # return super()._apply_settings(**kwargs)
+
+    def __info__(self) -> str:
+        txt = super().__info__()
+        txt += f"\n * ini file:    {self.proxy.ini_file}\n"
+        txt += f" * gate ignore:   {self.proxy.gate_ignore}\n"
+        txt += f" * pix per buf:   {self.proxy.pixels_per_buffer}\n"
+        txt += f" * preset type:   {self.proxy.preset_type}\n"
+        txt += f" * preset value:  {self.proxy.preset_value}\n"
+        return txt
+
+    @property
+    def configuration_file(self) -> str:
+        return self.current_configuration()
+
+    @configuration_file.setter
+    def configuration_file(self, fname: str) -> None:
+        self.load_configuration(fname)
+
+    @property
+    def configuration_dir(self) -> str:
+        return self.proxy.ini_dir
+
+    def available_configurations(self) -> list[str]:
+        return self.proxy.available_ini_files()
+
+    def _load_configuration(self, configuration: str | None = None) -> None:
+        try:
+            with ChangeTangoTimeout(self.proxy, 10):
+                print(f"Loading {configuration}...")
+                if configuration is None:
+                    configuration = ""
+                self.proxy.ini_file = configuration
+        except Exception as ex:
+            # TODO: report server msg
+            raise RuntimeError(f"Loading configuration file '{configuration}' has failed.") from ex
+        return self.current_configuration()
+
+    def current_configuration(self):
+        return self.proxy.ini_file

mosca_client/tango/mca.py

@@ -0,0 +1,96 @@
+from tango import DeviceProxy
+
+from .utils import is_ds_exported, Callback
+
+
+class McaBase:
+
+    def __init__(self, name, tg_url, on_change_cb=None, **kwargs):
+        self._name = name
+
+        # settings_name = f"mosca:{name}:{self.__class__.__name__}"
+        # self._settings2 = HashObjSetting(settings_name)
+        self._settings = kwargs.get("settings", {})
+
+        self._add_setting("configuration", None)
+
+        self._tg_url = tg_url
+        self._proxy = None
+        self._on_change_cb = Callback(on_change_cb, blocked=True)
+
+    @property
+    def mca_status(self):
+        return self.proxy.mca_status
+
+    @property
+    def tg_url(self):
+        return self._tg_url
+
+    def stats_mapping(self):
+        return {}
+
+    def changed(self):
+        self._on_change_cb()
+
+    def _add_setting(self, key, value=None):
+        if key not in self._settings:
+            self._settings[key] = value
+
+    def _set_settings(self, **kwargs):
+        for key, value in kwargs.items():
+            self._settings[key] = value
+
+    def initialize(self, load_configuration=True):
+        self._on_change_cb.blocked = True
+        # iterating on KEYS, because ITEMS doesn't work (returns #ERR)
+        settings = {key: (self._settings[key] if load_configuration or key != "configuration" else None)
+                    for key in self._settings.keys()}
+        try:
+            self._apply_settings(**settings)
+        finally:
+            self._on_change_cb.blocked = False
+
+    def _apply_settings(self, configuration=None, **kwargs):
+        if configuration is not None:
+            self.load_configuration(configuration)
+
+    @property
+    def proxy(self):
+        if self._proxy is None:
+            if not is_ds_exported(self._tg_url):
+                raise RuntimeError(f"Server {self._tg_url} doesn't seem to be running.")
+            self._proxy = DeviceProxy(self._tg_url)
+        return self._proxy
+
+    # TODO: put this in bliss
+    def __info__(self):
+        return f"MCA {self.__class__.__name__} ({self.proxy.name()})"
+
+    def load_configuration(self, *args, **kwargs):
+        reply = None
+        try:
+            reply = self._load_configuration(*args, **kwargs)
+        except NotImplementedError:
+            print(f"MCA doesn't implement load_configuration.")
+        else:
+            self._set_settings(configuration=reply)
+            self.initialize(load_configuration=False)
+            self.changed()
+        return reply
+
+    # To be overridden, if necessary
+
+    def _load_configuration(self, *args, **kwargs):
+        raise NotImplementedError
+
+    def filter_parameters(self, **kwargs):
+        return {}
+
+    def set_parameters(self, **kwargs):
+        pass
+
+    def available_configurations(self, *args, **kwargs):
+        return []
+
+    def current_configuration(self, *args, **kwargs):
+        return "N/A"