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

egse/vacuum/pfeiffer/tpg261_cs.py

@@ -1,109 +0,0 @@
-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.vacuum.pfeiffer.tpg261 import Tpg261Protocol, Tpg261Proxy
-
-
-logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-
-logger = logging.getLogger(__name__)
-
-CTRL_SETTINGS = Settings.load("Pfeiffer TPG261 Control Server")
-
-
-class Tpg261ControlServer(ControlServer):
-    """
-    tpg261ControlServer - Command and monitor the tpg261 roots pump controller.
-    This class works as a command and monitoring server to control the device remotely.
-    The sever binds to the following ZeroMQ sockets:
-    * a REP socket that can be used as a command server. Any client can connect and
-      send a command to the Lamp controller.
-    * a PUB socket that serves as a monitoring server. It will send out Lamp status
-      information to all the connected clients every DELAY seconds.
-    """
-
-    def __init__(self):
-        super().__init__()
-
-        self.device_protocol = Tpg261Protocol(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 AttributeError:
-            return "TPG261"
-
-    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 tpg261 Simulator as the backend.")
-def start(simulator):
-    """Start the tpg261 Control Server."""
-
-    if simulator:
-        Settings.set_simulation_mode(True)
-    try:
-        controller = Tpg261ControlServer()
-        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 tpg261 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 tpg261 Control Server."""
-
-    with Tpg261Proxy() as proxy:
-
-        sp = proxy.get_service_proxy()
-        sp.quit_server()
-
-
-if __name__ == "__main__":
-
-    sys.exit(cli())

egse/vacuum/pfeiffer/tpg261_interface.py

@@ -1,60 +0,0 @@
-from calendar import day_abbr, day_name
-from egse.device import DeviceInterface
-from egse.decorators import dynamic_interface
-from egse.command import ClientServerCommand
-
-class Tpg261Command(ClientServerCommand):
-    pass
-
-class Tpg261Interface(DeviceInterface):
-    @dynamic_interface
-    def connect(self):
-        return NotImplemented
-    
-    @dynamic_interface
-    def disconnect(self):
-        return NotImplemented
-    
-    @dynamic_interface
-    def reconnect(self):
-        return NotImplemented
-    
-    @dynamic_interface
-    def is_connected(self):
-        return NotImplemented
-    
-    @dynamic_interface
-    def is_simulator(self):
-        return NotImplemented
-    
-    @dynamic_interface
-    def get_idn(self):
-        return NotImplemented
-    
-    @dynamic_interface
-    def get_errors(self):
-        return NotImplemented
-    
-    @dynamic_interface
-    def reset(self):
-        return NotImplemented
-    
-    @dynamic_interface
-    def turn_off_gauge(self, gauge):
-        return NotImplemented
-    
-    @dynamic_interface
-    def turn_on_gauge(self, gauge):
-        return NotImplemented
-    
-    @dynamic_interface
-    def get_gauge_pressure(self, gauge):
-        return NotImplemented
-    
-    @dynamic_interface
-    def request(self, command):
-        return NotImplemented
-    
-    @dynamic_interface
-    def enquire(self):
-        return NotImplemented

egse/vacuum/pfeiffer/tpg261_simulator.py

@@ -1,24 +0,0 @@
-import logging
-
-from egse.settings import Settings
-from egse.simulator import Simulator
-from egse.command import Command
-from egse.vacuum.pfeiffer.tpg261_interface import Tpg261Interface
-
-logger = logging.getLogger(__name__)
-
-# Load the device protocol
-DEVICE_PROTOCOL = Settings.load(filename='tpg261.yaml')['Commands']
-
-
-class Tpg261Simulator(Tpg261Interface, Simulator):
-
-    def __init__(self):
-        super().__init__()
-        self.connect()
-
-    def is_simulator(self):
-        return True
-    
-    def get_idn(self):
-        return "TPG261 (simulator)"

egse/version.py

@@ -1,174 +0,0 @@
-"""
-This module defines the version for the Common-EGSE release. Whenever a version number
-or the release number is needed, this module shall be imported. The version and release
-number is then available as:
-
-    >>> import egse.version
-    >>> print(f"version = {egse.version.VERSION}")
-
-The actual numbers are updated for each release in the `settings.yaml` configuration file.
-
-"""
-from __future__ import annotations
-
-# WARNING: Make sure you are not importing any `egse` packages at the module level.
-# This module is magically loaded by pip to determine the VERSION number before the
-# package has been installed (see pyproject.py).
-# Any imports from an 'egse' package will result in a ModuleNotFound error.
-
-import os
-import subprocess
-from pathlib import Path
-
-HERE = Path(__file__).parent.resolve()
-
-__all__ = [
-    "get_version_installed",
-    "get_version_from_git",
-    "get_version_from_settings",
-    "VERSION",
-]
-
-
-def get_version_from_settings_file_raw(group_name: str, location: Path | str = None) -> str:
-    """
-    Reads the VERSION field from the `settings.yaml` file in raw mode, meaning the file
-    is not read using the PyYAML module, but using the `readline()` function of the file
-    descriptor.
-
-    Args:
-        group_name: major group name that contains the VERSION field, i.e. Common-EGSE or PLATO_TEST_SCRIPTS.
-        location: the location of the `settings.yaml` file or None in which case the location of this file is used.
-
-    Raises:
-        A RuntimeError when the group_name is incorrect and unknown or the VERSION field is not found.
-
-    Returns:
-        The version from the `settings.yaml` file as a string.
-    """
-    basedir = location or os.path.dirname(__file__)
-
-    with open(os.path.join(basedir, "settings.yaml"), mode="r") as yaml_fd:
-        line = yaml_fd.readline()
-        if not line.startswith(group_name):
-            raise RuntimeError(f"Incompatible format for the settings.yaml file, should start with '{group_name}'")
-
-        line = yaml_fd.readline().lstrip()
-        if not line.startswith("VERSION"):
-            raise RuntimeError("Incompatible format for the settings.yaml file, no VERSION found.")
-        _, version = line.split(":")
-
-        # remove possible trailing comment starting with '#'
-        version, *_ = version.split("#")
-        version = version.strip()
-
-    return version
-
-
-def get_version_from_settings(group_name: str, location: Path = None):
-    """
-    Reads the VERSION field from the `settings.yaml` file. This function first tries to load the proper Settings
-    and Group and if that fails uses the raw method.
-
-    Args:
-        group_name: major group name that contains the VERSION field, i.e. Common-EGSE or PLATO_TEST_SCRIPTS.
-        location: the location of the `settings.yaml` file or None in which case the location of this file is used.
-
-    Raises:
-        A RuntimeError when the group_name is incorrect and unknown or the VERSION field is not found.
-
-    Returns:
-        The version from the `settings.yaml` file as a string.
-    """
-    from egse.settings import Settings, SettingsError
-
-    try:
-        settings = Settings.load(group_name, location=location)
-        version = settings.VERSION
-    except (ModuleNotFoundError, SettingsError):
-        version = get_version_from_settings_file_raw(group_name, location=location)
-
-    return version
-
-
-def get_version_from_git(location: str = None):
-    """
-    Returns the Git version number for the repository at the given location.
-
-    The returned string has the following format: YYYY.X.Y+REPO.TH-N-HASH, where:
-
-    * YYYY is the year
-    * X is the major version number and equal to the week number of the release
-    * Y is the minor version patch number
-    * REPO is the name of the repository, i.e. CGSE or TS
-    * TH is the name of the test house, i.e. CSL1, CSL2, IAS, INTA, SRON
-    * N is the number of commits since the release
-    * HASH is the Git hash number of the commit
-
-    Args:
-        location: The absolute path of the root or a sub-folder of the repo.
-
-    Returns:
-        The Git version number.
-    """
-    from egse.system import chdir
-
-    location = location or Path().cwd()
-
-    with chdir(location):
-        try:
-            std_out = subprocess.check_output(
-                ["git", "describe", "--tags", "--long", "--always"], stderr=subprocess.PIPE
-            )
-            version = std_out.strip().decode("ascii")
-            if "cgse" not in version.lower() and "ts" not in version.lower():
-                version = None
-        except subprocess.CalledProcessError as exc:
-            version = None
-
-    return version
-
-
-def get_version_installed(package_name: str) -> str:
-    """
-    Returns the version that is installed, i.e. read from the metadata in the import lib.
-
-    Args:
-        package_name: the name of the installed package, e.g. cgse or cgse-ts
-
-    Returns:
-        The version of the installed repo.
-    """
-    from egse.system import chdir
-
-    with chdir(Path(__file__).parent):
-        from importlib.metadata import version, PackageNotFoundError
-
-        try:
-            version = version(package_name)
-        except PackageNotFoundError as exc:
-            version = None
-
-    return version
-
-
-VERSION = get_version_from_settings_file_raw("Common-EGSE", location=HERE)
-
-# The __PYPI_VERSION__ is the version number that will be used for the installation.
-# The version will appear in PyPI and also as the `installed version`.
-
-__PYPI_VERSION__ = VERSION.split('+')[0]
-
-
-if __name__ == "__main__":
-    import rich
-    from egse.system import get_module_location
-
-    if VERSION:
-        rich.print(f"CGSE version in Settings: [bold default]{VERSION}[/]")
-
-    if git_version := get_version_from_git(location=get_module_location("egse")):
-        rich.print(f"CGSE git version = [bold default]{git_version}[/]")
-
-    if installed_version := get_version_installed("cgse"):
-        rich.print(f"CGSE installed version = [bold default]{installed_version}[/]")