cgse 2023.38.0__py3-none-any.whl → 2024.1.4__py3-none-any.whl

egse/ni/alarms/cdaq9375_protocol.py

@@ -1,48 +0,0 @@
-import logging
-import datetime
-
-
-from egse.control import ControlServer
-from egse.ni.alarms.cdaq9375 import cdaq9375Controller, cdaq9375Simulator, cdaq9375Interface
-from egse.ni.alarms.cdaq9375_devif import cdaq9375Command
-
-from egse.protocol import CommandProtocol
-from egse.device import DeviceConnectionState
-from egse.settings import Settings
-from egse.system import format_datetime
-from egse.zmq_ser import bind_address
-
-COMMAND_SETTINGS = Settings.load(filename="cdaq9375.yaml")
-logger = logging.getLogger(__name__)
-
-
-
-class cdaq9375Protocol(CommandProtocol):
-    def __init__(self, control_server: ControlServer):
-        super().__init__()
-        self.control_server = control_server
-
-        if Settings.simulation_mode():
-            self.cdaq = cdaq9375Simulator()
-        else:
-            self.cdaq = cdaq9375Controller()
-
-        self.load_commands(
-            COMMAND_SETTINGS.Commands, cdaq9375Command, cdaq9375Interface
-        )
-
-        self.build_device_method_lookup_table(self.cdaq)
-
-    def get_bind_address(self):
-        return bind_address(
-            self.control_server.get_communication_protocol(),
-            self.control_server.get_commanding_port(),
-        )
-
-    def get_status(self):
-        return super().get_status()
-
-    def get_housekeeping(self) -> dict:
-
-        result = dict()
-        return result

egse/obs_inspection.py

@@ -1,163 +0,0 @@
-import argparse
-
-from rich.console import Console
-from rich.progress import Progress, SpinnerColumn, TimeElapsedColumn, BarColumn, TaskProgressColumn
-from rich.table import Table
-
-from egse import h5
-from egse.dpu.fitsgen import get_hdf5_filenames_for_obsid
-from egse.fee.nfee import HousekeepingData
-from egse.spw import DataPacket, HousekeepingPacket
-from egse.state import GlobalState
-
-
-def parse_arguments():
-
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument(
-        "--obsid",
-        type=str,
-        help="Observation Identifier.",
-    )
-
-    parser.add_argument(
-        "--location",
-        type=str,
-        help="Location where the data is stored.  This is the folder with the /daily and /obs sub-folders.",
-    )
-
-    return parser.parse_args()
-
-
-def print_table(obsid: str, location: str):
-    obs_hdf5_filenames = get_hdf5_filenames_for_obsid(obsid, location)
-    num_hdf5_files = len(obs_hdf5_filenames)
-    print(f"Found {num_hdf5_files} HDF5 files for obsid {obsid}")
-
-    ccd_bin_to_id = GlobalState.setup.camera.fee.ccd_numbering.CCD_BIN_TO_ID
-    n_fee_side = GlobalState.setup.camera.fee.ccd_sides.enum
-    
-    table = Table(title=f"Report for obsid {obsid}", expand=False)
-    table.add_column("HDF5", justify="right")
-    table.add_column("Group", no_wrap=True, justify="center")
-    table.add_column("Timestamp", no_wrap=True)
-    table.add_column("CCD", no_wrap=True)
-    table.add_column("Command")
-
-    console = Console(width=200)
-
-    with Progress(
-            SpinnerColumn(),
-            BarColumn(),
-            TaskProgressColumn(),
-            # *Progress.get_default_columns(),
-            TimeElapsedColumn(),
-            console=Console(),
-            transient=False,
-    ) as progress:
-
-        hdf5_file_task = progress.add_task("[red]Opening HDF5 file", total=num_hdf5_files)
-
-        progress_index = 0
-
-        while not progress.finished:
-            progress.update(hdf5_file_task, advance=1)
-            hdf5_filename = obs_hdf5_filenames[progress_index]
-
-            try:
-                hdf5_index = int(hdf5_filename.split("_")[-1].split(".")[0])
-                with h5.get_file(hdf5_filename, mode="r", locking=False) as hdf5_file:
-
-                    for group_index in range(0, 4):
-
-                        end_section = group_index == 3 if "3" in hdf5_file else True
-
-                        ccd = None
-
-                        try:
-                            group = hdf5_file[str(group_index)]
-
-                            has_e_side = False
-                            has_f_side = False
-
-                            try:
-                                timestamp = group["timecode"].attrs["timestamp"]
-
-                                hk = HousekeepingData(HousekeepingPacket(group["hk"]).data)
-                                has_error_flags = hk["error_flags"] != 0
-
-                                data = group["data"]
-
-                                for packet_index in [0, len(data) - 1]:
-                                    packet_type = DataPacket(data[str(packet_index)]).type
-
-                                    ccd_number = ccd_bin_to_id[packet_type.ccd_number]
-
-                                    ccd_side = packet_type.ccd_side
-                                    if ccd_side == n_fee_side.E:
-                                        has_e_side = True
-                                    else:
-                                        has_f_side = True
-                                if has_e_side and has_f_side:
-                                    ccd = f"{ccd_number} BOTH"
-                                elif has_e_side:
-                                    ccd = f"{ccd_number}E"
-                                elif has_f_side:
-                                    ccd = f"{ccd_number}F"
-                                if has_error_flags:
-                                    ccd = f"{ccd} (!)"
-                            except KeyError:
-                                ccd = None  # No data transmitted
-
-                            # Command
-
-                            try:
-                                commands = group["commands"]
-
-                                for command_index in range(len(commands)):
-                                    command = commands[str(command_index)][()]
-
-                                    if command_index == 0:
-                                        table.add_row(str(hdf5_index), str(group_index), timestamp, ccd,
-                                                      f"{command_index}: {command}",
-                                                      end_section=end_section and len(commands) == 1)
-                                    elif command_index == len(commands) - 1:
-                                        table.add_row(None, None, None, None, f"{command_index}: {command}",
-                                                      end_section=end_section)
-                                    else:
-                                        table.add_row(None, None, None, None, f"{command_index}: {command}",
-                                                      end_section=False)
-                            except KeyError:
-                                table.add_row(str(hdf5_index), str(group_index), timestamp, ccd, None,
-                                              end_section=end_section)  # No commands sent
-                        except KeyError:
-                            pass  # Internal sync
-            except OSError as exc:
-                print("OS error")
-            except RuntimeError as exc:
-                print("Runtime error")
-            # table.add_row(None, None, None, None)
-
-            progress_index += 1
-
-    console.print(table)
-
-
-if __name__ == "__main__":
-    """ Print table with status of the given observation.
-    
-    We loop over all HDF5 files for the given observation and extract the following information for all data groups
-    in each of them:
-        - Number of the HDF5 files (extracted from the filename);
-        - Group number;
-        - CCD number (1/2/3/4);
-        - CCD side (E/F/BOTH);
-        - Commands.
-        
-    Example: python -m egse.obs_inspection --obsid 00135_IAS --location /STER/platodata/IAS/data/IAS
-    """
-
-    args = parse_arguments()
-    print_table(args.obsid, args.location)
-

egse/observer.py

@@ -1,41 +0,0 @@
-import abc
-
-
-class Observer(abc.ABC):
-    @abc.abstractmethod
-    def update(self, changed_object):
-        pass
-
-    @abc.abstractmethod
-    def do(self, actions):
-        pass
-
-
-class Observable:
-    def __init__(self):
-        self.observers = []
-
-    def addObserver(self, observer):
-        if observer not in self.observers:
-            self.observers.append(observer)
-
-    def deleteObserver(self, observer):
-        self.observers.remove(observer)
-
-    def clearObservers(self):
-        self.observers = []
-
-    def countObservers(self):
-        return len(self.observers)
-
-    def notifyObservers(self, changedObject):
-        # FIXME: put a try..except here to log any problem that occurred in the observer's update()
-        #        method
-        for observer in self.observers:
-            observer.update(changedObject)
-
-    def actionObservers(self, actions):
-        # FIXME: put a try..except here to log any problem that occurred in the observer's do()
-        #        method
-        for observer in self.observers:
-            observer.do(actions)

egse/obsid.py

@@ -1,163 +0,0 @@
-"""
-An ObservationIdentifier or OBSID is a unique identifier for an observation or test.
-
-Each observation or test needs a unique identification that can be used as a key in a
-database or in a filename for test data etc.
-
-"""
-import os
-from pathlib import Path
-from typing import Union
-
-from egse.config import find_dir
-from egse.env import get_data_storage_location
-from egse.settings import Settings
-
-LAB_SETUP_TEST = 0
-TEST_LAB_SETUP = 1
-TEST_LAB = 3
-
-SITE = Settings.load("SITE")
-
-
-class ObservationIdentifier:
-    """A unique identifier for each observation or test."""
-
-    def __init__(self, lab_id: str = None, setup_id: int = None, test_id: int = None):
-        """
-        Args:
-            lab_id: the identifier for the site or lab that performs the test
-            setup_id: the identifier for the setup that is used for the test
-            test_id: the test identifier or test number
-        """
-        if lab_id is None or setup_id is None or test_id is None:
-            raise ValueError("arguments can not be None or an empty string")
-
-        self._lab_id = lab_id
-        self._setup_id = setup_id
-        self._test_id = test_id
-
-        # Construct the OBSID as it will be used in serialisation etc.
-
-        self._obsid = f"{lab_id}_{setup_id:05d}_{test_id:05d}"
-
-    @staticmethod
-    def create_from_string(obsid: str, order: int = LAB_SETUP_TEST):
-        if order == LAB_SETUP_TEST:
-            lab_id, setup_id, test_id = obsid.split("_")
-        elif order == TEST_LAB_SETUP:
-            test_id, lab_id, setup_id = obsid.split("_")
-        else:
-            raise ValueError(
-                f"The order argument can only be {LAB_SETUP_TEST=} or {TEST_LAB_SETUP=}")
-
-        return ObservationIdentifier(lab_id, int(setup_id), int(test_id))
-
-    @property
-    def lab_id(self):
-        return self._lab_id
-
-    @property
-    def setup_id(self):
-        return self._setup_id
-
-    @property
-    def test_id(self):
-        return self._test_id
-
-    def __eq__(self, other):
-        if not isinstance(other, ObservationIdentifier):
-            return NotImplemented
-        return self._obsid == other._obsid
-
-    def __hash__(self):
-        return hash(self._obsid)
-
-    def __str__(self):
-        return self._obsid
-
-    def create_id(self, *, order: int = LAB_SETUP_TEST, camera_name: str = None) -> str:
-        """
-        Creates a string representation of the observation identifier.
-
-        Args:
-            order: the order in which the parts are concatenated
-            camera_name: if a camera name is given, it will be appended in lower case
-
-        Returns:
-            A string representation of the obsid with or without camera name attached.
-        """
-        camera = f"{f'_{camera_name.lower()}' if camera_name else ''}"
-
-        if order == TEST_LAB_SETUP:
-            return f"{self._test_id:05d}_{self._lab_id}_{self._setup_id:05d}{camera}"
-        if order == TEST_LAB:
-            return f"{self._test_id:05d}_{self._lab_id}{camera}"
-        if order == LAB_SETUP_TEST:
-            return f"{self._lab_id}_{self._setup_id:05d}_{self._test_id:05d}{camera}"
-
-
-def obsid_from_storage(obsid: Union[ObservationIdentifier, str, int], data_dir: str,
-                       site_id: str = None, camera_name: str = None) -> str:
-    """
-    Return the name of the folder for the given obsid in the 'obs' sub-folder of data_dir.
-
-    For the oldest observations, the obsid used in the directory structure and filenames was of the format
-    TEST_LAB_SETUP.  All files in this folder also have the obsid in that format in their name.  At some point, we
-    decided to change this to TEST_LAB, but we still need to be able to re-process the old data (with the setup ID in
-    the names of the directories and files).
-
-    For newer observations (>= 2023.6.0+CGSE), the camera name is appended to the folder name and also included
-    in the filenames in that folder.
-
-    Args:
-        obsid: Observation identifier.  This can be an ObservationIdentifier object, a string in format TEST_LAB or
-            TEST_LAB_SETUP, or an integer representing the test ID. In this last case, the site id is taken from the
-            Settings.
-        data_dir: root folder in which the observations are stored. This folder shall have a sub-folder 'obs'.
-        site_id: a site id like 'CSL1' or 'IAS', when `None`, the `SITE.ID` from the Settings will be used
-        camera_name: if not None, append the camera name to the result
-
-    Returns:
-        The name of the folder for the given obsid in the 'obs' sub-folder of data_dir.
-    """
-
-    obs_dir = f"{data_dir}/obs/"
-    site_id = site_id or SITE.ID
-    camera = f"_{camera_name.lower()}" if camera_name else ""
-
-    if isinstance(obsid, ObservationIdentifier):
-        test, site = obsid.test_id, obsid.lab_id
-    elif isinstance(obsid, str):    # TEST_LAB or TEST_LAB_SETUP
-        test, site = obsid.split("_")[:2]
-    else:
-        test, site = obsid, site_id
-
-    test = int(test)
-
-    # Remember the camera name can be an empty string, so this will match both
-    # '00313_CSL' and '00313_CSL_achel'.
-
-    result_without_setup = Path(f"{obs_dir}/{test:05d}_{site}{camera}")
-
-    if result_without_setup.exists():
-        return result_without_setup.stem
-
-    # If a camera name was provided, but we try to find an old observation where the
-    # camera name was not appended to the folder name yet, the following will match
-    # that folder name.
-
-    result_without_camera = Path(f"{obs_dir}/{test:05d}_{site}")
-
-    if result_without_camera.exists():
-        return result_without_camera.stem
-
-    # When we come here, we can still match old observations that included the setup id in their
-    # folder name.
-
-    pattern = f"{test:05d}_{site}_*{camera}"
-
-    if (match := find_dir(pattern=pattern, root=obs_dir)) is None:
-        raise ValueError(f"Could not find a folder matching '{pattern}' in '{obs_dir}'")
-
-    return match.stem

egse/powermeter/ni/__init__.py

@@ -1,38 +0,0 @@
-"""
-Device control for the NI photodiode meter model cdaq9184 that will be used during IAS TVAC.
-
-This package contains the classes and modules to work with the Thorlabs Power meter Controller.
-
-The main entry point for the user of this package is through the `cdaq9184Proxy` class:
-
-```python
->>> from egse.powermeter.ni.cdaq9184 import cdaq9184Proxy
-```
-
-This class will connect to the control server of the CDAQ 9184 Controller and provides all
-commands to
-control and monitor the photodiode sensor readout and status. The control server is a small
-server application
-that is started as shown below. The control server directly connects to the cdaq9184 readout Controller
-through an Ethernet
-interface. When you have now hardware available, the control server can be started in simulator
-mode by appending the
-`--sim` string to the command below.
-
-CDAQ9184 has 4 NI slots that will be equipped with NI9226, NI9239 and NI9219 compact daqs.
-
-NI9239 will read the voltage signal from the 2x photodiodes inside the integrating sphere.
-Current to voltage is converted and pre amplified by TIAs.
-NI9226 will read 3x PT100 4 wire sensors: 2x on each collimator extremity, 1x on the integrating sphere in order
-to perform thermal drift compensations of the photodiodes' signals.
-In the final config NI9219 stays as a backup daq, to be used whenever needed -but the code does not read now any
-output from it-.
-
-All these signals can be read (mean and dev from 5 samples acquired at 100Hz) and will be required to monitor the
-flux of the OGSE if an integrating sphere is used in the setup. It can then provide the capability to perform
-Long term stability test as well as to monitor the full flux range from cam_tvpt_080_dynamic_range.py (tbc).
-
-```bash
-$ python -m egse.powermeter.ni.cdaq9184_cs
-```
-"""

egse/powermeter/ni/cdaq9184.py

@@ -1,224 +0,0 @@
-"""
-This module defines the basic classes to access the photodiodes readout ensured by
-NI CDAQ9184 controller that will be used in the IAS TVAC setup.
-"""
-import logging
-from typing import List
-
-from egse.decorators import dynamic_interface
-from egse.device import DeviceConnectionState
-from egse.device import DeviceInterface
-from egse.powermeter.ni.cdaq9184_devif import cdaq9184Error, cdaq9184SocketInterface
-from egse.proxy import Proxy
-from egse.settings import Settings
-from egse.zmq_ser import connect_address
-from egse.mixin import dynamic_command
-from egse.mixin import add_lf
-
-
-LOGGER = logging.getLogger(__name__)
-
-CTRL_SETTINGS = Settings.load("NI Control Server")
-CDAQ9184_SETTINGS = Settings.load("NI Controller")
-DEVICE_SETTINGS = Settings.load(filename="cdaq9184.yaml")
-
-
-class cdaq9184Interface(DeviceInterface):
-    """
-    Interface definition for the Signals acquisitions of the CDAQ9184 Controller, Simulator and Proxy..
-    """
-    @dynamic_interface
-    def info(self) -> str:
-        """
-        Returns basic information about the device, its name, firmwre version etc.
-
-        The string returned is subject to change without notice and can not be used for parsing
-        information.
-
-        Returns:
-            An identification string of the instrument.
-        """
-        raise NotImplementedError
-
-
-    @dynamic_interface
-    def read_values(self):
-        """
-        Reads the signals of the  channels of the CDAQ9181. Adds timestamp and returns a list.
-        Channels read are:
-        Photodiode_1 (V) from the integrating sphere, read as ch0 from NI9239
-        Photodiode_2 (V) from the integrating sphere, read as ch1 from NI9239
-
-        collimator_1_temp (°C) from the OGSE collimator, read as ch0 from NI9226
-        collimator_2_temp (°C) from the OGSE collimator, read as ch1 from NI9226
-        sphere_temp (°C) from the integrating sphere, read as ch2 from NI9226
-
-        the returned values are mean and dev from 5 samples acquired at 100Hz.
-        The values are sent by a Labview application installed in the Keynes working station
-
-        """
-
-        raise NotImplementedError
-
-    @dynamic_interface
-    def read_photodiodes(self):
-        """
-
-        Returns: echo values from read_values method, timestamp and photodides' signals in V
-
-        """
-        raise NotImplementedError
-
-    @dynamic_interface
-    def read_temperatures(self):
-        """
-
-        Returns: echo values from read_values method, timestamp and temperature values in °C
-
-        """
-        raise NotImplementedError
-
-
-
-class cdaq9184Simulator(cdaq9184Interface):
-    """
-    The pcdaq9184 Simulator class.
-    """
-
-    def __init__(self):
-        self._is_connected = True
-        self.temp_operation = False
-
-    def is_connected(self):
-        return self._is_connected
-
-    def is_simulator(self):
-        return True
-
-    def connect(self):
-        self._is_connected = True
-
-    def disconnect(self):
-        self._is_connected = False
-
-    def reconnect(self):
-        self.connect()
-
-    def get_id(self):
-        pass
-
-    def info(self):
-        pass
-
-    def read_values(self):
-        pass
-
-    def read_photodiodes(self):
-        pass
-
-    def read_temperatures(self):
-        pass
-
-
-class cdaq9184Controller(cdaq9184Interface):
-    """The cdaq9184Controller allows controlling a NI CDAQ 9184 photodiode measurement device."""
-
-    def __init__(self):
-        """Initialize the cdaq9184 Controller interface."""
-
-        super().__init__()
-
-        LOGGER.debug("Initializing NI CDAQ 9184")
-
-        try:
-            self.cdaq = cdaq9184SocketInterface()
-            self.cdaq.connect(CDAQ9184_SETTINGS.HOSTNAME) # IP address of the computer with Labview
-
-        except cdaq9184Error as exc:
-            LOGGER.warning(f"TempError caught: Couldn't establish connection ({exc})")
-            raise cdaq9184Error(
-                "Couldn't establish a connection with the NI CDAQ 9184 controller."
-            ) from exc
-
-    def connect(self):
-        """Connects to the photodiode measurement device.
-
-        Raises:
-            DeviceNotFoundError: when the photodiode device is not connected.
-        """
-        try:
-            self.cdaq.connect(CDAQ9184_SETTINGS.HOSTNAME)
-        except cdaq9184Error as exc:
-             LOGGER.warning(f"cdaqError caught: Couldn't establish connection ({exc})")
-             raise ConnectionError("Couldn't establish a connection with the NI DAQ9184 controller.") from exc
-
-        self.notify_observers(DeviceConnectionState.DEVICE_CONNECTED)
-
-
-    def disconnect(self):
-        try:
-            self.cdaq.disconnect()
-        except cdaq9184Error as exc:
-            raise ConnectionError("Couldn't establish a connection with the NI CDAQ 9184 controller.") from exc
-
-        self.notify_observers(DeviceConnectionState.DEVICE_NOT_CONNECTED)
-
-
-    def reconnect(self):
-        if self.is_connected():
-            self.disconnect()
-        self.connect()
-
-    def is_connected(self):
-        """Check if the Temp Controller is connected."""
-        return self.cdaq.is_connected()
-
-    def is_simulator(self):
-        return False
-
-    def get_id(self):
-        return self.cdaq.get_id()
-
-    def info(self):
-        pass
-
-    def read_values(self) -> list:
-        data = self.cdaq.trans("get_value")
-        return data
-
-    def read_temperatures(self) -> dict:
-        values = self.read_values()
-        all_temp = values[14:26]
-
-        temp_mean = [all_temp[i] for i in range(0, len(all_temp), 2)]
-        temp_mean = values[2:] + temp_mean # c'est pas plutôt values[:2] ?
-        temp_std = [all_temp[i] for i in range(1, len(all_temp), 2)]
-        temp_std = values[2:] + temp_std # c'est pas plutôt values[:2] ?
-
-        temperatures = {"temp_mean": temp_mean, "temp_std": temp_std}
-
-        return temperatures
-
-    def read_photodiodes(self):
-        pass
-
-
-class cdaq9184Proxy(Proxy, cdaq9184Interface):
-    """The cdaq9184Proxy class is used to connect to the control server and send commands to
-    the NI CDAQ 9184 device remotely."""
-    def __init__(
-        self,
-        protocol=CTRL_SETTINGS.PROTOCOL,
-        hostname=CTRL_SETTINGS.HOSTNAME,
-        port=CTRL_SETTINGS.CDAQ9184.get("COMMANDING_PORT"),
-    ):
-        """
-        Args:
-            protocol: the transport protocol [default is taken from settings file]
-            hostname: location of the control server (IP address)
-                [default is taken from settings file]
-            port: TCP port on which the control server is listening for commands
-                [default is taken from settings file]
-        """
-        super().__init__(connect_address(protocol, hostname, port))
-