cgse 2024.7.0__py3-none-any.whl → 2025.0.2__py3-none-any.whl

egse/dyndummy.py

@@ -1,179 +0,0 @@
-"""
-This module provides dummy implementation for classes of the Commanding chain.
-"""
-import logging
-import sys
-
-import click
-import zmq
-
-from egse.control import ControlServer
-from egse.device import DeviceTransport
-from egse.mixin import DynamicCommandMixin
-from egse.mixin import dynamic_command
-from egse.protocol import DynamicCommandProtocol
-from egse.proxy import DynamicProxy
-from egse.settings import Settings
-from egse.system import AttributeDict
-from egse.system import format_datetime
-from egse.zmq_ser import bind_address
-from egse.zmq_ser import connect_address
-
-logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-logger = logging.getLogger("egse.dyndummy")
-
-# We use AttributeDict here to define the settings, because that is how the Settings.load() returns
-# settings loaded from a YAML file.
-
-ctrl_settings = AttributeDict(
-    {
-        'HOSTNAME': 'localhost',
-        'COMMANDING_PORT': 5553,
-        'SERVICE_PORT': 5554,
-        'MONITORING_PORT': 5555,
-        'PROTOCOL': 'tcp'
-    }
-)
-
-
-class DummyDeviceInterface(DeviceTransport):
-    def __init__(self):
-        self._read_counter = 0
-        self._write_counter = 0
-        self._trans_counter = 0
-
-    def read(self) -> bytes:
-        self._read_counter += 1
-        logger.info(f"executing read() – [read count = {self._read_counter}]")
-        return f"read count = {self._read_counter}".encode()
-
-    def trans(self, command: str) -> bytes:
-        self._trans_counter += 1
-        logger.info(f"executing trans('{command}') – [trans count = {self._trans_counter}]")
-
-        self.write(command)
-        self.read()
-
-        return f"trans count = {self._trans_counter}".encode()
-
-    def write(self, command: str):
-        self._write_counter += 1
-        logger.info(f"executing write('{command}') – [write count = {self._write_counter}]")
-
-
-class DummyInterface:
-    @dynamic_command(cmd_type="query", cmd_string="INFO?")
-    def info(self) -> str:
-        """Return an info string from the device."""
-        raise NotImplementedError
-
-    @dynamic_command(cmd_type='transaction', cmd_string="RESPONSE:${msg}")
-    def response(self, msg: str) -> str:
-        """Return a response to the message sent."""
-        raise NotImplementedError
-
-
-class DummyController(DummyInterface, DynamicCommandMixin):
-    def __init__(self):
-        self.transport = DummyDeviceInterface()
-        super().__init__()
-
-
-class DummyProtocol(DynamicCommandProtocol):
-
-    def __init__(self, control_server: ControlServer):
-        super().__init__(control_server)
-        self.control_server = control_server
-
-        self.device_controller = DummyController()
-
-    def get_device(self):
-        return self.device_controller
-
-    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:
-        return {
-            'timestamp': format_datetime(),
-        }
-
-
-class DummyControlServer(ControlServer):
-    """
-    DummyControlServer - Command and monitor dummy device controllers.
-
-    The sever binds to the following ZeroMQ sockets:
-
-    * a REQ-REP socket that can be used as a command server. Any client can connect and
-      send a command to the dummy device controller.
-
-    * a PUB-SUP socket that serves as a monitoring server. It will send out status
-      information to all the connected clients every DELAY seconds.
-
-    """
-
-    def __init__(self):
-        super().__init__()
-
-        self.device_protocol = DummyProtocol(self)
-
-        self.logger.info(f"Binding ZeroMQ socket to {self.device_protocol.get_bind_address()}")
-
-        self.device_protocol.bind(self.dev_ctrl_cmd_sock)
-
-        self.poller.register(self.dev_ctrl_cmd_sock, zmq.POLLIN)
-
-    def get_communication_protocol(self):
-        return 'tcp'
-
-    def get_commanding_port(self):
-        return ctrl_settings.COMMANDING_PORT
-
-    def get_service_port(self):
-        return ctrl_settings.SERVICE_PORT
-
-    def get_monitoring_port(self):
-        return ctrl_settings.MONITORING_PORT
-
-
-class DummyProxy(DynamicProxy, DummyInterface):
-    def __init__(self,
-                 protocol=ctrl_settings.PROTOCOL, hostname=ctrl_settings.HOSTNAME, port=ctrl_settings.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))
-
-
-@click.group()
-def cli():
-    pass
-
-
-@cli.command()
-def control_server():
-    """Start the dummy control server on localhost."""
-    from egse.dyndummy import DummyControlServer
-
-    try:
-        control_server = DummyControlServer()
-        control_server.serve()
-    except KeyboardInterrupt:
-        print("Shutdown requested...exiting")
-    except SystemExit as exit_code:
-        print(f"System Exit with code ({exit_code})")
-        sys.exit(exit_code)
-    except Exception:
-        import traceback
-        traceback.print_exc(file=sys.stdout)
-
-
-if __name__ == "__main__":
-    cli()

egse/env.py

@@ -1,278 +0,0 @@
-"""
-This module provides functionality to work with and check your Python environment.
-"""
-from pathlib import Path
-
-from egse.system import all_logging_disabled
-from egse.system import ignore_m_warning
-
-ENV_PLATO_COMMON_EGSE = "PLATO_COMMON_EGSE_PATH"
-ENV_PLATO_INSTALL = "PLATO_INSTALL_LOCATION"
-ENV_PLATO_CONF_DATA = "PLATO_CONF_DATA_LOCATION"
-ENV_PLATO_CONF_REPO = "PLATO_CONF_REPO_LOCATION"
-ENV_PLATO_STORAGE_DATA = "PLATO_DATA_STORAGE_LOCATION"
-ENV_PLATO_LOG_DATA = "PLATO_LOG_FILE_LOCATION"
-ENV_PLATO_LOCAL_SETTINGS = "PLATO_LOCAL_SETTINGS"
-
-PLATO_ENV_VARIABLES = [globals()[x] for x in globals() if x.startswith('ENV_PLATO_')]
-
-__all__ = [
-    "get_data_storage_location",
-    "get_conf_data_location",
-    "get_log_file_location",
-    *PLATO_ENV_VARIABLES
-]
-
-
-def get_data_storage_location(setup=None, site_id: str = None) -> str:
-    """
-    Returns the full path of the data storage location for the Site as
-    in the given Setup. If the Setup is not given, it is requested from the
-    configuration manager unless the `site_id` argument is given.
-
-    Note: when you specify the `site_id` as an argument, it takes precedence
-          over the site_id that is specified in the Setup.
-
-    Args:
-        setup: the Setup from which the Camera name and Site ID are taken
-        site_id: the site identifier (to be used instead of the site_id in the Setup)
-
-    Returns:
-        The full path of data storage location as a string.
-
-    Raises:
-        A ValueError when no Setup can be loaded.
-    """
-
-    import os
-    from egse.setup import load_setup
-
-    if site_id is None:
-
-        from egse.setup import Setup
-        setup: Setup = setup or load_setup()
-
-        if setup is None:
-            raise ValueError("Could not determine Setup, which is None, even after loading from the configuration manager.")
-
-        site = setup.site_id
-    else:
-        site = site_id
-
-    data_root = os.environ[ENV_PLATO_STORAGE_DATA]
-    data_root = data_root.rstrip('/')
-
-    return data_root if data_root.endswith(site) else f"{data_root}/{site}"
-
-
-def get_conf_data_location(setup=None) -> str:
-    """
-    Returns the full path of the location of the Setups for the Site.
-    If the Setup is not given, it is requested from the configuration manager.
-
-    Args:
-        setup: the Setup from which the Camera name and Site ID are taken
-
-    Returns:
-        The full path of location of the Setups as a string.
-
-    Raises:
-        A ValueError when no Setup can be loaded.
-    """
-
-    data_root = get_data_storage_location(setup=setup)
-
-    return f"{data_root}/conf"
-
-
-def get_log_file_location() -> str:
-    """
-    Returns the full path of the location of the log files. The log file location is read from the environment
-    variable PLATO_LOG_FILE_LOCATION. The location shall be independent of the Setup, Camera ID or any other
-    setting that is subject to change.
-
-    If the environment variable is not set, a default log file location is created from the data storage location as
-    follows: $PLATO_DATA_STORAGE_LOCATION/<SITE_ID>/log.
-
-    Returns:
-        The full path of location of the log files as a string.
-
-    """
-    import os
-
-    try:
-        log_data_root = os.environ[ENV_PLATO_LOG_DATA]
-    except KeyError:
-        data_root = os.environ[ENV_PLATO_STORAGE_DATA]
-        data_root = data_root.rstrip('/')
-
-        from egse.settings import get_site_id
-        site = get_site_id()
-
-        log_data_root = f"{data_root}/{site}/log"
-
-    return log_data_root
-
-
-ignore_m_warning('egse.env')
-
-if __name__ == "__main__":
-
-    import argparse
-    import os
-    import sys
-    import rich
-
-    from egse.config import get_common_egse_root
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--full",
-        default=False,
-        action="store_true",
-        help="Print a full report on environment variables and paths.",
-    )
-    parser.add_argument(
-        "--doc",
-        default=False,
-        action="store_true",
-        help="Print help on the environment variables and paths.",
-    )
-
-    args = parser.parse_args()
-
-    def check_env_dir(env_var: str):
-
-        value = os.environ.get(env_var)
-
-        if value is None:
-            value = "[bold red]not set"
-        elif not value.startswith('/'):
-            value = f"[default]{value} [bold orange3](this is a relative path!)"
-        elif not os.path.exists(value):
-            value = f"[default]{value} [bold red](location doesn't exist!)"
-        elif not os.path.isdir(value):
-            value = f"[default]{value} [bold red](location is not a directory!)"
-        else:
-            value = f"[default]{value}"
-        return value
-
-
-    def check_env_file(env_var: str):
-
-        value = os.environ.get(env_var)
-
-        if value is None:
-            value = "[bold red]not set"
-        elif not os.path.exists(value):
-            value = f"[default]{value} [bold red](location doesn't exist!)"
-        else:
-            value = f"[default]{value}"
-        return value
-
-    rich.print("Environment variables:")
-
-    for var in PLATO_ENV_VARIABLES:
-        if var.endswith("_SETTINGS"):
-            rich.print(f"    {var} = {check_env_file(var)}")
-        else:
-            rich.print(f"    {var} = {check_env_dir(var)}")
-
-    rich.print()
-    rich.print("Generated locations and filenames")
-
-    with all_logging_disabled():
-        try:
-            rich.print(f"    {get_common_egse_root() = !s}", flush=True)
-            location = get_common_egse_root()
-            if not Path(location).exists():
-                rich.print("[red]ERROR: The generated Common-EGSE location doesn't exist![/]")
-        except ValueError as exc:
-            rich.print(f"    get_common_egse_path() = [red]{exc}[/]")
-
-        try:
-            rich.print(f"    {get_data_storage_location() = }", flush=True)
-            location = get_data_storage_location()
-            if not Path(location).exists():
-                rich.print("[red]ERROR: The generated data storage location doesn't exist![/]")
-        except ValueError as exc:
-            rich.print(f"    get_data_storage_location() = [red]{exc}[/]")
-
-        try:
-            rich.print(f"    {get_conf_data_location() = }", flush=True)
-            location = get_conf_data_location()
-            if not Path(location).exists():
-                rich.print("[red]ERROR: The generated configuration data location doesn't exist![/]")
-        except ValueError as exc:
-            rich.print(f"    get_conf_data_location() = [red]{exc}[/]")
-
-        try:
-            rich.print(f"    {get_log_file_location() = }", flush=True)
-            location = get_log_file_location()
-            if not Path(location).exists():
-                rich.print("[red]ERROR: The generated log files location doesn't exist![/]")
-        except ValueError as exc:
-            rich.print(f"    get_log_file_location() = [red]{exc}[/]")
-
-    if args.full:
-        rich.print()
-        rich.print(f"    PYTHONPATH=[default]{os.environ.get('PYTHONPATH')}")
-        rich.print(f"    PYTHONSTARTUP=[default]{os.environ.get('PYTHONSTARTUP')}")
-        rich.print()
-        python_path_msg = "\n      ".join(sys.path)
-        rich.print(f"    sys.path=[\n      {python_path_msg}\n    ]")
-        path_msg = "\n      ".join(os.environ.get("PATH").split(":"))
-        rich.print(f"    PATH=[\n      {path_msg}\n    ]")
-
-    help_msg = f"""
-[bold]{ENV_PLATO_COMMON_EGSE}[/bold]:
-    This variable should point to the root of the working copy of the 'plato-common-egse' 
-    project. Its value is usually '~/git/plato-common-egse' which is considered the default 
-    location.
-
-[bold]{ENV_PLATO_INSTALL}[/bold]:
-    This variable shall point to the location where the CGSE will be installed and is 
-    usually set to `/cgse`. The variable is used by the [blue]update_cgse[/blue] script.
-
-[bold]{ENV_PLATO_CONF_DATA}[/bold]:
-    This directory is the root folder for all the Setups of the site, the site is part
-    of the name. By default, this directory is located in the overall data storage folder.
-
-[bold]{ENV_PLATO_CONF_REPO}[/bold]:
-    This variable is the root of the working copy of the 'plato-cgse-conf' project. 
-    The value is usually set to `~/git/plato-cgse-conf`.
-
-[bold]{ENV_PLATO_STORAGE_DATA}[/bold]:
-    This directory contains all the data files from the control servers and other
-    components. This folder is the root folder for all data from all cameras and 
-    all sites. Below this folder shall be a folder for each of the cameras and in 
-    there a sub-folder for each of the sites where that camera was tested. The 
-    hierarchy is therefore: `$PLATO_DATA_STORAGE_LOCATION/<camera name>/<site id>.
-    Each of those folder shall contain at least the sub-folder [blue]daily[/blue], and [blue]obs[/blue]. 
-    
-    There is also a file called [blue]obsid-table-<site id>.txt[/blue] which is maintained by 
-    the configuration manager and contains information about the observations that
-    were run and the commands to start those observation.
-
-[bold]{ENV_PLATO_LOG_DATA}[/bold]:
-    This directory contains the log files with all messages that were sent to the 
-    logger control server. The log files are rotated on a daily basis at midnight UTC.
-    By default, this directory is also located in the overall data storage folder.
-
-[bold]{ENV_PLATO_LOCAL_SETTINGS}[/bold]:
-    This file is used for local site-specific settings. When the environment 
-    variable is not set, no local settings will be loaded. By default, this variable
-    is assumed to be '/cgse/local_settings.yaml'.
-"""
-
-    if args.doc:
-        rich.print(help_msg)
-
-    if not args.full:
-        rich.print()
-        rich.print("use the '--full' flag to get a more detailed report, '--doc' for help on the variables.")
-
-    # Do we still use these environment variables?
-    #
-    # PLATO_WORKDIR
-    # PLATO_COMMON_EGSE_PATH - YES

egse/exceptions.py

@@ -1,88 +0,0 @@
-"""
-The Exception Hierarchy:
-
-Exception
- +-- CommonEGSEException
-      +-- Warning
-      +-- Error
-          +-- InvalidOperationError
-          +-- DeviceNotFoundError (should move to sub class of DeviceError)
-          +-- InternalStateError
-          +-- DeviceError
-               +-- DeviceControllerError
-               +-- DeviceConnectionError
-               +-- DeviceTimeoutError
-               +-- DeviceInterfaceError
- +-- Failure
- +-- HexapodError
- +-- PMACError
- +-- OGSEError
- +-- ESLError
- +-- FilterWheelError
- +-- FilterWheel8smc4Error
- +-- ShutterKSC1010Error
- +-- WindowSizeError
- +-- SettingsError
- +-- StagesError
-
-"""
-
-
-class CommonEGSEException(Exception):
-    """The base exception for all errors and warnings in the Common-EGSE."""
-
-    pass
-
-
-class Error(CommonEGSEException):
-    """The base class for all Common-EGSE Errors."""
-
-    pass
-
-
-class Warning(CommonEGSEException):
-    """The base class for all Common-EGSE Warnings."""
-
-    pass
-
-
-class FileIsEmptyError(Error):
-    """Raised when a file is empty and that is unexpected."""
-    pass
-
-
-class InvalidOperationError(Error):
-    """
-    Raised when a certain operation is not valid in the given state,
-    circumstances or environment.
-    """
-
-    pass
-
-
-class InvalidInputError(Error):
-    """ Exception raised when the input is invalid after editing."""
-
-    pass
-
-
-class DeviceNotFoundError(Error):
-    """Raised when a device could not be located, or loaded."""
-
-    pass
-
-
-class InternalStateError(Error):
-    """Raised when an object encounters an internal state inconsistency."""
-
-    pass
-
-
-class InternalError(Error):
-    """Raised when an internal inconsistency occurred in a function, method or class."""
-
-    pass
-
-
-class Abort(RuntimeError):
-    """Internal Exception to signal a process to abort."""

egse/fdir/__init__.py

@@ -1,26 +0,0 @@
-from egse.control import Response
-from PyQt5.QtWidgets import QMessageBox, QApplication
-
-def generate_popup(code: str, actions: str, success: bool) -> Response:
-    app = QApplication([])
-    msg = QMessageBox()
-    msg.setModal(False)
-    msg.setWindowModality(0)
-    msg.setWindowTitle("FDIR signal notification")
-    msg.setIcon(QMessageBox.Critical)
-    msg.setText(f"<h1><bold>An FDIR signal with code:<br><blockquote>{code}</blockquote><br> has fired!</bold></h1>")
-    if success:
-        msg.setInformativeText(f"The associated recovery script was executed: <br><h2> succesfully! </h2><br> \n\nPlease press OK to clear FDIR signal")
-    else:
-        msg.setInformativeText(f"The associated recovery script has: <br> <h2>FAILED!</h2> <br> Please take action to recover the system\n\nAfter recovery press OK to clear FDIR signal")
-    
-    msg.setDetailedText(f"Required actions:\n\n {actions}")
-    msg.setStandardButtons(QMessageBox.Ok)
-    msg.setDefaultButton(QMessageBox.Ok)
-    
-    ret = msg.exec_()
-    
-    if ret == QMessageBox.Ok:
-        pass
-    else:
-        pass

egse/fdir/fdir_manager.py

@@ -1,85 +0,0 @@
-import logging
-
-from prometheus_client import Gauge
-
-from egse.command import ClientServerCommand
-from egse.control import ControlServer
-from egse.proxy import Proxy
-from egse.protocol import CommandProtocol
-from egse.settings import Settings
-from egse.zmq_ser import connect_address, bind_address
-from egse.system import format_datetime
-from egse.fdir.fdir_manager_interface import FdirManagerInterface
-from egse.fdir.fdir_manager_controller import FdirManagerController
-
-logger = logging.getLogger(__name__)
-
-CTRL_SETTINGS = Settings.load("FDIR Manager Control Server")
-DEVICE_SETTINGS = Settings.load(filename="fdir_manager.yaml")
-SITE_ID = Settings.load("SITE").ID
-
-gauge_state = Gauge(f"G{SITE_ID}_FDIR_STATE", "")
-
-
-class FdirManagerCommand(ClientServerCommand):
-    pass
-
-
-
-class FdirManagerProxy(Proxy, FdirManagerInterface):
-    """ The FDIR Manager Proxy class is used to connect to the FDIR Manager
-        control server and send commands and requests for the FDIR manager.
-    """
-
-    def __init__(
-        self,
-        protocol=CTRL_SETTINGS.PROTOCOL,
-        hostname=CTRL_SETTINGS.HOSTNAME,
-        port=CTRL_SETTINGS.COMMANDING_PORT,
-    ):
-        super().__init__(connect_address(protocol, hostname, port))
-
-
-class FdirManagerProtocol(CommandProtocol):
-
-    def __init__(self, control_server: ControlServer):
-
-        super().__init__()
-
-        self.control_server = control_server
-        self.controller = FdirManagerController()
-
-        self.load_commands(
-            DEVICE_SETTINGS.Commands,
-            FdirManagerCommand,
-            FdirManagerController,
-        )
-
-        self.build_device_method_lookup_table(self.controller)
-
-
-    def get_bind_address(self):
-
-        return bind_address(
-            self.control_server.get_communication_protocol(),
-            self.control_server.get_commanding_port(),
-        )
-
-
-    def get_status(self):
-
-        status = super().get_status()
-        status.update({"state": self.controller.get_state()})
-
-        return status
-
-
-    def get_housekeeping(self):
-
-        state = self.controller.get_state()
-        gauge_state.set(state)
-
-        return {
-            "timestamp": format_datetime(),
-            f"G{SITE_ID}_FDIR_STATE": state,
-        }

egse/fdir/fdir_manager.yaml

@@ -1,37 +0,0 @@
-BaseClass:
-    egse.fdir.FdirManagerInterface
-
-ProxyClass:
-    egse.fdir.FdirManagerProxy
-
-ControlServerClass:
-    egse.alert.FdirManagerControlServer
-
-ControlServer:
-    egse.fdir.fdir_manager_cs
-
-
-Commands:
-    is_connected:
-        description:
-        args:
-        cmd:                ""
-
-    is_simulator:
-        descripton:
-        args:
-        cmd:                ""
-
-    signal_fdir:
-        description:        Alert the CS that an FDIR situation occured
-        args:
-            fdir_code:      str | Predefined FDIR code.
-            script_args:    list | optional arguments for recovery script.
-        cmd:                "{fdir_code}{kwargs}"
-
-    clear_fdir:
-        description:        Clear all asserted FDIR codes. The CS will return to it's initial state.
-
-    get_state:
-        description:        Check if the CS is in it's idle or some FDIR code was triggered.
-        returns:            str | active FDIR code (empty string if idle)