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

egse/ups/apc/apc.py

@@ -1,236 +0,0 @@
-import logging
-import socket
-from collections import OrderedDict
-
-from egse.decorators import dynamic_interface
-from egse.device import DeviceInterface
-from egse.proxy import Proxy
-from egse.settings import Settings
-from egse.zmq_ser import connect_address
-from egse.command import ClientServerCommand
-
-logger = logging.getLogger(__name__)
-
-CTRL_SETTINGS = Settings.load("APC Control Server")
-DEVICE_SETTINGS = Settings.load(filename='apc.yaml')
-
-CMD_STATUS = "\x00\x06status".encode()
-EOF = "  \n\x00\x00"
-SEP = ":"
-BUFFER_SIZE = 1024
-ALL_UNITS = (
-    "Minutes",
-    "Seconds",
-    "Percent",
-    "Volts",
-    "Watts",
-    "Amps",
-    "Hz",
-    "C",
-    "VA",
-    "Percent Load Capacity"
-)
-
-class APCError(Exception):
-    pass
-
-
-class APCCommand(ClientServerCommand):
-    def get_cmd_string(self, *args, **kwargs):
-        out = super().get_cmd_string(*args, **kwargs)
-        return out + '\n'
-
-class APCInterface(DeviceInterface):
-    """ APC base class."""
-
-    @dynamic_interface
-    def get_bcharge(self):
-        """ Battery charge. """
-        return NotImplemented
-
-    @dynamic_interface
-    def get_onbatt(self):
-        """ On battery power. """
-        return NotImplemented
-
-    @dynamic_interface
-    def get_timeleft(self):
-        """ Timeleft when on battery. """
-        return NotImplemented
-
-
-class APCSimulator(APCInterface):
-   """ APC simulator class. """
-
-   def __init__(self):
-       self._is_connected = True
-
-   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):
-       if self.is_connected():
-           self.disconnect()
-       self.connect()
-
-   def get_bcharge(self):
-       return 90.0
-
-   def get_onbatt(self):
-       return False
-
-   def get_timeleft(self):
-       return 1000.0
-
-
-class APCController(APCInterface):
-
-    def __init__(self):
-        super().__init__()
-        self._is_connected = True
-
-    def is_simulator(self):
-        return False
-
-    def is_connected(self):
-        return self._is_connected
-
-    def connect(self):
-        self._is_connected = True
-
-    def disconnect(self):
-        self._is_connected = False
-
-
-    def reconnect(self):
-        self._is_connected = True
-
-    def get_linev(self):
-        dct = self._parse(self._get(), True)
-        return float(dct['LINEV'])
-    
-    def get_loadpct(self):
-        dct = self._parse(self._get(), True)
-        return float(dct['LOADPCT'])
-
-    def get_bcharge(self):
-        dct = self._parse(self._get(), True)
-        return float(dct['BCHARGE'])
-
-    def get_timeleft(self):
-        dct = self._parse(self._get(), True)
-        return float(dct['TIMELEFT'])
-
-    def get_onbatt(self):
-        dct = self._parse(self._get(), True)
-        return 'ONBATT' in dct['STATUS']
-    
-    def get_mbattchg(self):
-        dct = self._parse(self._get(), True)
-        return float(dct['MBATTCHG'])
-    
-    def get_mintimel(self):
-        dct = self._parse(self._get(), True)
-        return float(dct['MINTIMEL'])
-    
-    def get_maxtime(self):
-        dct = self._parse(self._get(), True)
-        return float(dct['MAXTIME'])
-    
-    def get_maxlinev(self):
-        dct = self._parse(self._get(), True)
-        return float(dct['MAXLINEV'])
-    
-    def get_minlinev(self):
-        dct = self._parse(self._get(), True)
-        return float(dct['MINLINEV'])
-    
-    def get_outputv(self):
-        dct = self._parse(self._get(), True)
-        return float(dct['OUTPUTV'])
-
-    def get_dlowbatt(self):
-        dct = self._parse(self._get(), True)
-        return float(dct['DLOWBATT'])
-
-    def get_lotrans(self):
-        dct = self._parse(self._get(), True)
-        return float(dct['LOTRANS'])
-    
-    def get_hitrans(self):
-        dct = self._parse(self._get(), True)
-        return float(dct['HITRANS'])
-    
-    def get_itemp(self):
-        dct = self._parse(self._get(), True)
-        return float(dct['ITEMP'])
-    
-    def get_alarmdel(self):
-        dct = self._parse(self._get(), True)
-        return float(dct['ALARMDEL'])
-    
-    def get_status_dict(self):
-        return self._parse(self._get(), True)
-
-    def _get(self, host="localhost", port=3551, timeout=30):
-        """
-        Connect to the APCUPSd NIS and request its status.
-        """
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        sock.settimeout(timeout)
-        sock.connect((host, port))
-        sock.send(CMD_STATUS)
-        buffr = ""
-        while not buffr.endswith(EOF):
-            buffr += sock.recv(BUFFER_SIZE).decode()
-        sock.close()
-        return buffr
-
-
-    def _split(self, raw_status):
-        """
-        Split the output from get_status() into lines, removing the length and
-        newline chars.
-        """
-        # Remove the EOF string, split status on the line endings (\x00), strip the
-        # length byte and newline chars off the beginning and end respectively.
-        return [x[1:-1] for x in raw_status[:-len(EOF)].split("\x00") if x]
-
-
-    def _parse(self, raw_status, strip_units=False):
-        """
-        Split the output from get_status() into lines, clean it up and return it as
-        an OrderedDict.
-        """
-        lines = self._split(raw_status)
-        if strip_units:
-            lines = self._strip_units_from_lines(lines)
-        # Split each line on the SEP character, strip extraneous whitespace and
-        # create an OrderedDict out of the keys/values.
-        return OrderedDict([[x.strip() for x in x.split(SEP, 1)] for x in lines])
-
-
-    def _strip_units_from_lines(self, lines):
-        """
-        Removes all units from the ends of the lines.
-        """
-        for line in lines:
-            for unit in ALL_UNITS:
-                if line.endswith(" %s" % unit):
-                    line = line[:-1-len(unit)]
-            yield line
-
-class APCProxy(Proxy, APCInterface):
-    def __init__(self, protocol=CTRL_SETTINGS.PROTOCOL,
-                 hostname=CTRL_SETTINGS.HOSTNAME,
-                 port=CTRL_SETTINGS.COMMANDING_PORT):
-        super().__init__(connect_address(protocol, hostname, port))

egse/ups/apc/apc.yaml

@@ -1,45 +0,0 @@
-BaseClass:
-    egse.ups.apc.APCInterface
-
-ProxyClass:
-    egse.ups.apc.APCProxy
-
-ControlServerClass:
-    egse.ups.apc.APControlServer
-
-ControlServer:
-    egse.ups.apc.apc_cs
-
-Commands:
-
-    # Definition of the DeviceInterface.
-
-    disconnect:
-        description: Disconnect from the APC Controller.
-
-    connect:
-        description: Connect to the APC Controller.
-
-    reconnect:
-        description: Reconnect to the APC Controller.
-
-    is_simulator:
-        description: Ask if the control server is a simulator.
-        returns:     bool | True if far end is a simulator.
-
-    is_connected:
-        description: Check if APC Controller is connected.
-
-    # Definition of the device commands.
-    get_bcharge:
-        description: Battery charge.
-        returns:  float | Percentage battery charge
-
-    get_onbatt:
-        description: On battery power.
-        returns:  bool | On battery power
-
-    get_timeleft:
-        description: Time left when on battery.
-        returns:  float | Time left in minutes.
-

egse/ups/apc/apc_cs.py

@@ -1,101 +0,0 @@
-#!/usr/bin/env python3
-import click
-import logging
-import sys
-
-import zmq
-from prometheus_client import start_http_server
-
-from egse.control import ControlServer
-from egse.settings import Settings
-from egse.ups.apc.apc_protocol import APCProtocol
-from egse.ups.apc.apc import APCProxy
-
-logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-
-logger = logging.getLogger(__name__)
-
-CTRL_SETTINGS = Settings.load("APC Control Server")
-
-
-class APCControlServer(ControlServer):
-
-    def __init__(self):
-        super().__init__()
-
-        self.device_protocol = APCProtocol(self)
-
-        self.logger.debug(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 CTRL_SETTINGS.PROTOCOL
-
-    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
-
-    def get_storage_mnemonic(self):
-        try:
-            return CTRL_SETTINGS.STORAGE_MNEMONIC
-        except:
-            return 'APC'
-
-    def before_serve(self):
-        start_http_server(CTRL_SETTINGS.METRICS_PORT)
-
-
-@click.group()
-def cli():
-    pass
-
-
-@cli.command()
-@click.option("--simulator", "--sim", is_flag=True, help="Start the APC Simulator as the backend.")
-def start(simulator):
-    """Start the APC Control Server."""
-
-    # if simulator:
-    #     Settings.set_simulation_mode(True)
-    try:
-        controller = APCControlServer()
-        controller.serve()
-
-    except KeyboardInterrupt:
-        print("Shutdown requested...exiting")
-
-    except SystemExit as exit_code:
-        print("System Exit with code {}.".format(exit_code))
-        sys.exit(exit_code)
-
-    except Exception:
-
-        logger.exception("Cannot start the APC Control Server")
-        # The above line does exactly the same as the traceback, but on the logger
-        # import traceback
-        # traceback.print_exc(file=sys.stdout)
-
-    return 0
-
-
-@cli.command()
-def stop():
-    """Send a 'quit_server' command to the Control Server."""
-
-    with APCProxy() as proxy:
-
-        sp = proxy.get_service_proxy()
-        sp.quit_server()
-
-
-if __name__ == "__main__":
-
-    sys.exit(cli())

egse/ups/apc/apc_protocol.py

@@ -1,125 +0,0 @@
-import logging
-
-from prometheus_client import Gauge
-
-from egse.control import ControlServer
-from egse.protocol import CommandProtocol
-from egse.settings import Settings
-# from egse.fdir.fdir_manager import FdirManagerProxy
-
-from egse.ups.apc.apc import APCController
-from egse.ups.apc.apc import APCInterface
-from egse.ups.apc.apc import APCSimulator
-from egse.ups.apc.apc import APCCommand
-from egse.system import format_datetime
-from egse.zmq_ser import bind_address
-
-logger = logging.getLogger(__name__)
-
-COMMAND_SETTINGS = Settings.load(filename='apc.yaml')
-
-class APCProtocol(CommandProtocol):
-    def __init__(self, control_server:ControlServer):
-        super().__init__()
-        self.control_server = control_server
-
-        if Settings.simulation_mode():
-            self.apc = APCSimulator()
-        else:
-            self.apc = APCController()
-
-        self.load_commands(COMMAND_SETTINGS.Commands, APCCommand, APCInterface)
-
-        self.build_device_method_lookup_table(self.apc)
-        
-        self.gauge_linev     = Gauge('GSRON_UPS_LINEV', '')
-        self.gauge_loadpct     = Gauge('GSRON_UPS_LOADPCT', '')
-        self.gauge_bcharge     = Gauge('GSRON_UPS_BCHARGE', '')
-        self.gauge_timeleft     = Gauge('GSRON_UPS_TIMELEFT', '')
-        self.gauge_mbattchg     = Gauge('GSRON_UPS_MBATTCHG', '')
-        self.gauge_mintimel     = Gauge('GSRON_UPS_MINTIMEL', '')
-        self.gauge_maxtime     = Gauge('GSRON_UPS_MAXTIME', '')
-        self.gauge_maxlinev     = Gauge('GSRON_UPS_MAXLINEV', '')
-        self.gauge_minlinev     = Gauge('GSRON_UPS_MINLINEV', '')
-        self.gauge_outputv     = Gauge('GSRON_UPS_OUTPUTV', '')
-        self.gauge_dlowbatt     = Gauge('GSRON_UPS_DLOWBATT', '')
-        self.gauge_lotrans     = Gauge('GSRON_UPS_LOTRANS', '')
-        self.gauge_hitrans     = Gauge('GSRON_UPS_HITRANS', '')
-        self.gauge_itemp     = Gauge('GSRON_UPS_ITEMP', '')
-        self.gauge_alarmdel     = Gauge('GSRON_UPS_ALARMDEL', '')
-        self.gauge_battv     = Gauge('GSRON_UPS_BATTV', '')
-        self.gauge_linefreq     = Gauge('GSRON_UPS_LINEFREQ', '')
-        self.gauge_lastxfer     = Gauge('GSRON_UPS_LASTXFER', '')
-        self.gauge_numxfers     = Gauge('GSRON_UPS_NUMXFERS', '')
-        self.gauge_tonbatt     = Gauge('GSRON_UPS_TONBATT', '')
-        self.gauge_cumonbatt     = Gauge('GSRON_UPS_CUMONBATT', '')
-        self.gauge_xoffbatt     = Gauge('GSRON_UPS_XOFFBATT', '')
-        self.gauge_statflag     = Gauge('GSRON_UPS_STATFLAG', '')
-        self.gauge_onbatt       = Gauge('GSRON_UPS_ONBATT', '')
-
-
-    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:
-
-        hk_dict = {'timestamp': format_datetime()}
-
-        try:
-            dct = self.apc.get_status_dict()
-            hk_dict[f'GSRON_UPS_LINEV'] = dct['LINEV']
-            hk_dict[f'GSRON_UPS_LOADPCT'] = dct['LOADPCT']
-            hk_dict[f'GSRON_UPS_BCHARGE'] = dct['BCHARGE']
-            hk_dict[f'GSRON_UPS_TIMELEFT'] = dct['TIMELEFT']
-            hk_dict[f'GSRON_UPS_MBATTCHG'] = dct['MBATTCHG']
-            hk_dict[f'GSRON_UPS_MINTIMEL'] = dct['MINTIMEL']
-            hk_dict[f'GSRON_UPS_MAXTIME'] = dct['MAXTIME']
-            hk_dict[f'GSRON_UPS_MAXLINEV'] = dct['MAXLINEV']
-            hk_dict[f'GSRON_UPS_MINLINEV'] = dct['MINLINEV']
-            hk_dict[f'GSRON_UPS_OUTPUTV'] = dct['OUTPUTV']
-            hk_dict[f'GSRON_UPS_DLOWBATT'] = dct['DLOWBATT']
-            hk_dict[f'GSRON_UPS_LOTRANS'] = dct['LOTRANS']
-            hk_dict[f'GSRON_UPS_HITRANS'] = dct['HITRANS']
-            hk_dict[f'GSRON_UPS_ITEMP'] = dct['ITEMP']
-            hk_dict[f'GSRON_UPS_ALARMDEL'] = dct['ALARMDEL']
-            hk_dict[f'GSRON_UPS_BATTV'] = dct['BATTV']
-            hk_dict[f'GSRON_UPS_LINEFREQ'] = dct['LINEFREQ']
-            hk_dict[f'GSRON_UPS_NUMXFERS'] = dct['NUMXFERS']
-            hk_dict[f'GSRON_UPS_TONBATT'] = dct['TONBATT']
-            hk_dict[f'GSRON_UPS_CUMONBATT'] = dct['CUMONBATT']
-            hk_dict[f'GSRON_UPS_STATFLAG'] = int(dct['STATFLAG'], 16)
-            hk_dict[f'GSRON_UPS_ONBATT']   = 'ONBATT' in dct['STATUS']
-
-        except Exception as exc:
-            logger.exception("failed to get HK: %s", exc)
-
-            return hk_dict
-        
-        self.gauge_linev.set(hk_dict[f'GSRON_UPS_LINEV'])
-        self.gauge_loadpct.set(hk_dict[f'GSRON_UPS_LOADPCT'])
-        self.gauge_bcharge.set(hk_dict[f'GSRON_UPS_BCHARGE'])
-        self.gauge_timeleft.set(hk_dict[f'GSRON_UPS_TIMELEFT'])
-        self.gauge_mbattchg.set(hk_dict[f'GSRON_UPS_MBATTCHG'])
-        self.gauge_mintimel.set(hk_dict[f'GSRON_UPS_MINTIMEL'])
-        self.gauge_maxtime.set(hk_dict[f'GSRON_UPS_MAXTIME'])
-        self.gauge_maxlinev.set(hk_dict[f'GSRON_UPS_MAXLINEV'])
-        self.gauge_minlinev.set(hk_dict[f'GSRON_UPS_MINLINEV'])
-        self.gauge_outputv.set(hk_dict[f'GSRON_UPS_OUTPUTV'])
-        self.gauge_dlowbatt.set(hk_dict[f'GSRON_UPS_DLOWBATT'])
-        self.gauge_lotrans.set(hk_dict[f'GSRON_UPS_LOTRANS'])
-        self.gauge_hitrans.set(hk_dict[f'GSRON_UPS_HITRANS'])
-        self.gauge_itemp.set(hk_dict[f'GSRON_UPS_ITEMP'])
-        self.gauge_alarmdel.set(hk_dict[f'GSRON_UPS_ALARMDEL'])
-        self.gauge_battv.set(hk_dict[f'GSRON_UPS_BATTV'])
-        self.gauge_linefreq.set(hk_dict[f'GSRON_UPS_LINEFREQ'])
-        self.gauge_numxfers.set(hk_dict[f'GSRON_UPS_NUMXFERS'])
-        self.gauge_tonbatt.set(hk_dict[f'GSRON_UPS_TONBATT'])
-        self.gauge_cumonbatt.set(hk_dict[f'GSRON_UPS_CUMONBATT'])
-        self.gauge_statflag.set(hk_dict[f'GSRON_UPS_STATFLAG'])
-        self.gauge_onbatt.set(hk_dict[f'GSRON_UPS_ONBATT'])
-
-        return hk_dict

egse/user.yaml

@@ -1,7 +0,0 @@
-# User settings
-
-META_DATA:
-
-    VERSION:                1
-    DATE   :       26-07-2018
-

egse/vacuum/beaglebone/beaglebone.py

@@ -1,149 +0,0 @@
-import logging
-import random
-
-from egse.decorators import dynamic_interface
-from egse.device import DeviceInterface
-from egse.proxy import Proxy
-from egse.settings import Settings
-from egse.vacuum.beaglebone.beaglebone_devif import BeagleboneDeviceInterface
-from egse.zmq_ser import connect_address
-
-logger = logging.getLogger(__name__)
-
-CTRL_SETTINGS = Settings.load("BeagleBone Valve Control Server")
-DEVICE_SETTINGS = Settings.load(filename='beaglebone.yaml')
-
-
-class BeagleboneError(Exception):
-    pass
-
-
-class BeagleboneInterface(DeviceInterface):
-    """ BeagleBone Valve controller base class."""
-
-    @dynamic_interface
-    def set_valve(self, valve_idx, valve_state):
-        """ Sets the state of the selected valve to the given state """
-        return NotImplemented
-
-    @dynamic_interface
-    def get_valve(self, valve_idx):
-        """ Returns the state of the selected valve """
-        return NotImplemented
-
-
-
-class BeagleboneSimulator(BeagleboneInterface):
-   """ BeagleBone Valve controller simulator class. """
-
-   def __init__(self):
-        self.valvefb = {
-            "LN2_SHROUD_RMT"     : 1,
-            "LN2_TEB-FEE_RMT"    : 1,
-            "LN2_TEB-TOU_RMT"    : 1,
-            "LN2_TRAP_RMT"       : 1,
-            "N2_SHROUD_RMT"      : 1,
-            "N2_TEB-FEE_RMT"     : 1,
-            "N2_TEB-TOU_RMT"     : 1,
-            "N2_TRAP_RMT"        : 1,
-            "VENT_VALVE_RMT"     : 1,
-            "GATE_VALVE_RMT"     : 1,
-            "LN2_SHROUD_FB"      : random.getrandbits(1),
-            "LN2_TEB-FEE_FB"     : random.getrandbits(1),
-            "LN2_TEB-TOU_FB"     : random.getrandbits(1),
-            "LN2_TRAP_FB"        : random.getrandbits(1),
-            "N2_SHROUD_FB"       : random.getrandbits(1),
-            "N2_TEB-FEE_FB"      : random.getrandbits(1),
-            "N2_TEB-TOU_FB"      : random.getrandbits(1),
-            "N2_TRAP_FB"         : random.getrandbits(1),
-            "VENT_VALVE_FB"      : random.getrandbits(1),
-            "GATE_OPEN_FB"       : random.getrandbits(1),
-            "GATE_CLOSE_FB"      : random.getrandbits(1),
-            "INTRLCK_DOOR_FB"    : random.getrandbits(1)
-        }
-        
-        self.valves = {
-            "MV011" : self.valvefb['LN2_SHROUD_FB'],
-            "MV012" : self.valvefb['LN2_TEB-FEE_FB'],
-            "MV013" : self.valvefb['LN2_TEB-TOU_FB'],
-            "MV014" : self.valvefb['LN2_TRAP_FB'],
-            "MV021" : self.valvefb['N2_SHROUD_FB'],
-            "MV022" : self.valvefb['N2_TEB-FEE_FB'],
-            "MV032" : self.valvefb['N2_TEB-TOU_FB'],
-            "MV042" : self.valvefb['N2_TRAP_FB'],
-            'MV001' : self.valvefb['VENT_VALVE_FB'],
-            'MV002' : self.valvefb['GATE_OPEN_FB']
-        }
-        
-        self._is_connected = True
-
-   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):
-       if self.is_connected():
-           self.disconnect()
-       self.connect()
-
-   def set_valve(self, valve_idx, valve_state):
-       logger.info(f"Settings {valve_idx} to {valve_state}")
-       self.valves[valve_idx] = valve_state
-
-   def get_valve(self, valve_idx):
-       return self.valvefb[valve_idx]
-
-
-class BeagleboneController(BeagleboneInterface):
-
-    def __init__(self):
-        super().__init__()
-
-        logger.debug('Initalizing BeagleBone Valve Controller')
-
-        try:
-            self.beaglebone = BeagleboneDeviceInterface()
-            self.beaglebone.connect()
-        except BeagleboneError as exc:
-            logger.warning(f"BeagleboneError caught: Couldn't establish connection ({exc})")
-            raise BeagleboneError(
-                "Couldn't establish a connection with BeagleBone controller."
-            ) from exc
-
-    def is_simulator(self):
-        return False
-
-    def is_connected(self):
-        return self.beaglebone.is_connected()
-
-    def connect(self):
-        if not self.beaglebone.is_connected():
-            self.beaglebone.connect()
-
-    def disconnect(self):
-        self.beaglebone.disconnect()
-
-    def reconnect(self):
-        self.beaglebone.reconnect()
-
-    def set_valve(self, valve_idx, valve_state):
-        return self.beaglebone.set_valve(valve_idx, valve_state)
-
-    def get_valve(self, valve_idx):
-        return self.beaglebone.get_valve(valve_idx)
-
-
-
-class BeagleboneProxy(Proxy, BeagleboneInterface):
-    def __init__(self, protocol=CTRL_SETTINGS.PROTOCOL,
-                 hostname=CTRL_SETTINGS.HOSTNAME,
-                 port=CTRL_SETTINGS.COMMANDING_PORT):
-        super().__init__(connect_address(protocol, hostname, port))