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

egse/gui/switch.py

@@ -1,112 +0,0 @@
-#!/usr/bin/python3
-# -*- coding: utf-8 -*-
-
-"""
-A Switch button widget.
-"""
-import logging
-import sys
-
-from PyQt5.QtCore import QSize
-from PyQt5.QtGui import QPainter
-from PyQt5.QtSvg import QSvgRenderer
-from PyQt5.QtWidgets import QWidget
-
-from egse.config import find_dir
-
-logger = logging.getLogger(__name__)
-
-
-class Indic:
-    ON = 0
-    OFF = 1
-
-
-class Switch(QWidget):
-
-    IMAGE_LOCATION = find_dir("/egse/icons") or ""
-
-    def __init__(self, parent):
-        super().__init__(parent)
-
-        self.state = Indic.OFF
-        self.image_location = Switch.IMAGE_LOCATION
-
-        # logger.info(f"image_location = {self.image_location} of type({type(self.image_location)})")
-
-        self.setMinimumSize(QSize(40, 40))
-        self.setMaximumSize(QSize(40, 40))
-
-        self.states = ["switch-on.svg", "switch-off.svg"]
-
-    def paintEvent(self, event):
-        painter = QPainter()
-        painter.begin(self)
-        self.drawCustomWidget(painter)
-        painter.end()
-
-    def drawCustomWidget(self, painter):
-        renderer = QSvgRenderer()
-        renderer.load(str(self.image_location / self.states[self.state]))
-        renderer.render(painter)
-
-    def setState(self, state):
-        self.state = state
-        self.repaint()
-
-
-if __name__ == "__main__":
-
-    from PyQt5.QtWidgets import QApplication, QVBoxLayout, QHBoxLayout, QPushButton
-
-    class Example(QWidget):
-        def __init__(self):
-            super().__init__()
-
-            self.setGeometry(300, 300, 300, 200)
-            self.setWindowTitle("Switch widget")
-
-            self.initUI()
-
-        def initUI(self):
-
-            vbox = QVBoxLayout()
-            hbox = QHBoxLayout()
-
-            self.switch = Switch(self)
-
-            hbox.addWidget(self.switch)
-            vbox.addStretch(1)
-            vbox.addLayout(hbox)
-            vbox.addStretch(1)
-
-            hbox = QHBoxLayout()
-
-            self.pb1 = QPushButton("On", self)
-            self.pb2 = QPushButton("Off", self)
-
-            hbox.addWidget(self.pb1)
-            hbox.addWidget(self.pb2)
-
-            vbox.addLayout(hbox)
-
-            self.pb1.clicked.connect(self.onClick)
-            self.pb2.clicked.connect(self.onClick)
-
-            self.setLayout(vbox)
-
-        def onClick(self):
-
-            sender = self.sender()
-            text = sender.text()
-
-            print(text)
-            if text == "On":
-                self.switch.setState(Indic.ON)
-            elif text == "Off":
-                self.switch.setState(Indic.OFF)
-
-    app = QApplication([])
-    ex = Example()
-    ex.show()
-    sys.exit(app.exec_())

egse/h5.py

@@ -1,274 +0,0 @@
-"""
-H5 - Inspect HDF5 files from the commandline (REPL)
-
-This module uses the h5py module to load and navigate the HDF5. It provides
-a number of convenience methods for inspecting the HDF5 file structure and
-contents.
-
-Usage: The examples are for PlatoSim3 HDF5 output files
-
-  hfile = h5py.File(<filename>) or myh5 = h5.get_file(filename)
-
-  h5.show_file(myh5)
-
-  myh5.has_groups(hfile["StarPositions"])
-  myh5.show_groups(hfile['StarPositions'], recursive=False)
-
-  myh5.has_datasets(hfile["Images"])
-  myh5.show_datasets(hfile["Images"])
-
-  myh5.has_attributes(hfile['InputParameters/CCD'])
-  myh5.show_attributes(hfile['InputParameters/CCD'])
-
-  colPix = myh5.get_data(out["StarPositions/Exposure000000/colPix"])
-
-  position = myh5.get_attribute_value(out["InputParameters/CCD"], "Position")
-"""
-
-import sys
-
-import h5py
-
-INDENT = " " * 4
-MAX_LEVEL = 100
-
-
-def dummy_calc_size_of(x):
-    return 0
-
-
-# Trying to make an option to calc or not the size of objects.
-# This approach doesn't work, since the whole dataset is still
-# extracted from the HDF5 when choosing no.
-calc_size_of = dummy_calc_size_of
-calc_size_of = sys.getsizeof
-
-
-def get_type_id(x) -> str:
-    """
-    Returns the type of the argument as a single letter.
-
-    * 'D' - Dataset
-    * 'G' - Group
-    * 'F' - File
-
-    If the type is not one of the options above, ``type(x)`` is returned as a string.
-
-    :return: a character that identifies the type
-    """
-    if isinstance(x, h5py.Dataset):
-        return "D"
-    if isinstance(x, h5py.Group):
-        return "G"
-    if isinstance(x, h5py.File):
-        return "F"
-    return str(type(x))
-
-
-def get_type_name(x) -> str:
-    """
-    Returns the type of the argument as a single letter.
-
-    * 'D' - Dataset
-    * 'G' - Group
-    * 'F' - File
-
-    If the type is not one of the options above, ``type(x)`` is returned as a string.
-
-    :return: a character that identifies the type
-    """
-    if isinstance(x, h5py.Dataset):
-        return "Dataset"
-    if isinstance(x, h5py.Group):
-        return "Group"
-    if isinstance(x, h5py.File):
-        return "File"
-    return str(type(x))
-
-
-# FIXME: replace with egse.bits.humanize_bytes()
-
-def show_size(n) -> str:
-    """
-    Returns the size ``n`` in human readable form, i.e. as bytes, KB, MB, GB, ...
-
-    :return: human readable size
-    """
-    _n = n
-    if _n < 1024:
-        return "{} bytes".format(_n)
-
-    for dim in ['KB', 'MB', 'GB', 'TB', 'PB']:
-        _n = _n / 1024.0
-        if _n < 1024:
-            return "{:.3f} {}".format(_n, dim)
-
-    return "{} bytes".format(n)
-
-
-def show_file(x):
-    """
-    Print the top-level groups and attributes in the HDF5 file.
-
-    This will recursively crawl through the HDF5 file and calculate the total size
-    of the all the groups and attributes.
-    Only the top-level of the HDF5 structure will be printed. The total size of the
-    group includes the attributes that belong to that group. Total size of attributes
-    is only for top-level attributes.
-
-    """
-    if not isinstance(x, h5py.File):
-        print("Error: Please pass a HDF5 File argument.")
-        return
-    __show_groups__(x, recursive=True, max_level=1)
-    show_attributes(x)
-    return
-
-
-def get_file(filename, mode='r', locking=None):
-    """
-    Load the HDF5 file.
-
-    Args:
-        filename: the absolute filename of the HDF5 file
-        mode: r, r+, w, w-, x, a (see documentation of h5py module) [default='r']
-        locking: False to disable locking [default=None]
-
-    Returns:
-        a h5py File object.
-    """
-    return h5py.File(filename, mode=mode, locking=locking)
-
-
-def has_attributes(x):
-    return len(x.attrs) > 0
-
-
-def show_attributes(x):
-    _size = 0
-
-    for a in x.attrs:
-        t_size = calc_size_of(x.attrs[a])
-        print("{}: {} ({})".format(a, x.attrs[a], show_size(t_size)))
-        _size = _size + t_size
-
-    print("Total size of attributes: {}".format(show_size(_size)))
-    pass
-
-
-def get_attribute_value(x, a):
-    return x.attrs[a]
-
-
-def has_groups(x):
-    return len([g for g in x.keys() if get_type_id(x[g]) == 'G']) > 0
-
-
-def groups(x):
-    return (x[g] for g in x.keys() if get_type_id(x[g]) == 'G')
-
-
-def __show_groups__(x, recursive=True, indent="", verbose=True, max_level=MAX_LEVEL, level=0):
-    _indent = indent + INDENT
-    _level = level + 1
-    _size = 0
-
-    # print ("indent=*{}*, _indent=*{}*".format(indent, _indent))
-    if isinstance(x, h5py.Dataset):
-        print("Error: you passed in a Dataset. Please provide a HDF5 File or a Group object.")
-        return
-
-    for g in x.keys():
-        type_id = get_type_id(x[g])
-
-        if has_attributes(x[g]):
-            t_size = 0
-            for a in x[g].attrs:
-                t_size = t_size + calc_size_of(x[g].attrs[a])
-            if verbose and max_level > _level:
-                print(f"{indent}[A] Total size: {show_size(t_size)}")
-            _size = _size + t_size
-
-        if type_id == 'D':
-            t_size = calc_size_of(x[g][...])
-            if verbose and max_level > level:
-                print(f"{indent}[{type_id}] {g} ({show_size(t_size)})")
-            _size = _size + t_size
-        else:
-            if verbose and max_level > level:
-                print(f"{indent}[{type_id}] {g}")
-            if recursive:
-                _size = _size + __show_groups__(x[g], indent=_indent, verbose=verbose, max_level=max_level, level=_level)
-
-    if max_level > level:
-        print(f"{indent}Total size of Group = {show_size(_size)}")
-
-    return _size
-
-
-def show_groups(x, recursive=True, verbose=True, max_level=MAX_LEVEL):
-    """
-    :param x: HDF5 group object
-    :param recursive: crawl over all groups recursively if True
-    :param verbose:
-    :param max_level:
-    """
-    __show_groups__(x, recursive=recursive, verbose=verbose, max_level=max_level)
-
-
-def has_datasets(x):
-    return len([g for g in x.keys() if get_type_id(x[g]) == 'D']) > 0
-
-
-def datasets(x):
-    """
-    Returns a generator for all datasets in 'x'.
-
-    :param x:
-    :return:
-    """
-    return (x[g] for g in x.keys() if get_type_id(x[g]) == 'D')
-
-
-def show_datasets(x):
-    _size = 0
-    for key in x.keys():
-        type_id = get_type_id(x[key])
-
-        if type_id == 'D':
-            t_size = calc_size_of(x[key][...])
-            print("[{}] {} ({})".format(type_id, key, show_size(t_size)))
-            _size = _size + t_size
-
-    print("Total size of datasets in this group is {}".format(show_size(_size)))
-
-
-def show_dataset(x):
-    if not isinstance(x, h5py.Dataset):
-        print("Error: Please provide a HDF5 Dataset as input.")
-        return
-    print("Shape: {}, Type: {}, Size: {}".format(x.shape, x.dtype, show_size(calc_size_of(x[...]))))
-    pass
-
-
-def get_data(x):
-    if not isinstance(x, h5py.Dataset):
-        print("Error: Please provide a HDF5 Dataset as input.")
-        return None
-
-    return x[...]
-
-
-__all__ = [
-    "show_file",
-    "get_type_id",
-    "has_groups",
-    "show_groups",
-    "has_datasets",
-    "show_datasets",
-    "show_dataset",
-    "get_data",
-    "has_attributes",
-    "show_attributes",
-    "get_attribute_value"
-]

egse/help/help_ui.py

@@ -1,126 +0,0 @@
-"""
-This module provides a HelpWindow that can be used in GUIs to provide easy access to the
-documentation of the GUI. The docs are part of the  overall Common-EGSE documentation, but
-are mainly located in the man-pages section.
-
-To use this in your GUI, use the following template:
-
-    url = HELP_TOPICS["puna_ui"]
-
-    help_window = HelpWindow(url=url)
-    help_window.show()
-
-Make sure the `help_window` variable is not garbage collected (which will destroy the window).
-Keep a reference to the window somewhere in your main window or application setup. The HelpWindow
-can be closed and re-opened with the `.close()` and `.show()` methods.
-"""
-
-import sys
-
-from PyQt5.QtCore import QSize
-from PyQt5.QtCore import QUrl
-from PyQt5.QtGui import QIcon
-from PyQt5.QtWebEngineWidgets import QWebEngineView
-from PyQt5.QtWidgets import QAction
-from PyQt5.QtWidgets import QApplication
-from PyQt5.QtWidgets import QMainWindow
-from PyQt5.QtWidgets import QToolBar
-
-from egse.resource import get_resource
-
-__all__ = [
-    "HELP_TOPICS",
-    "HelpWindow",
-]
-
-BASE_URL = "https://ivs-kuleuven.github.io/plato-common-egse/"
-
-# Below are the topics for the GUIs that are known by the setup.py.
-
-HELP_TOPICS = dict(
-    home=BASE_URL,
-    ogse_ui=BASE_URL,
-    puna_ui=f'{BASE_URL}man-pages/hexapod-gui/',
-    zonda_ui=f'{BASE_URL}man-pages/hexapod-gui/',
-    smc9300_ui=f'{BASE_URL}man-pages/huber-gui/',
-    fpa_ui=f'{BASE_URL}man-pages/source-position-gui/',
-    vis_pos_ui=f'{BASE_URL}man-pages/visited-positions-gui/',
-    lsci336_ui=f'{BASE_URL}man-pages/lakeshore-gui/',
-    gimbal_ui=f'{BASE_URL}man-pages/gimbal-gui/',
-)
-
-
-class HelpWindow(QMainWindow):
-    """
-    Show the help window for a certain topic. This will open a simple browser window pointing to
-    the URL that you pass into the constructor. You will be able to navigate through the
-    documentation and used the `backward`, `forward` and `reload` buttons as expected for a
-    web browser.
-
-    The _Home_ button brings you back to the page referred to by the `topic_url` argument.
-    """
-
-    def __init__(self, topic_url: str):
-        """
-        Args:
-            topic_url (str): the starting point for the Help topic.
-        """
-        super().__init__()
-
-        self.setGeometry(300, 300, 1000, 600)
-
-        self._url = topic_url
-
-        self.browser = QWebEngineView()
-        self.browser.setUrl(QUrl(self._url))
-
-        self.setCentralWidget(self.browser)
-
-        navigation_toolbar = QToolBar("Navigation")
-        navigation_toolbar.setIconSize(QSize(32, 32))
-        self.addToolBar(navigation_toolbar)
-
-        home_btn = QAction(QIcon(str(get_resource(":/icons/home.svg"))), "Home", self)
-        home_btn.setStatusTip("Go home")
-        home_btn.triggered.connect(self.navigate_home)
-        navigation_toolbar.addAction(home_btn)
-
-        back_btn = QAction(QIcon(str(get_resource(":/icons/backward.svg"))), "Back", self)
-        back_btn.setStatusTip("Back to previous page")
-        back_btn.triggered.connect(lambda: self.browser.back())
-        navigation_toolbar.addAction(back_btn)
-
-        next_btn = QAction(QIcon(str(get_resource(":/icons/forward.svg"))), "Forward", self)
-        next_btn.setStatusTip("Forward to next page")
-        next_btn.triggered.connect(lambda: self.browser.forward())
-        navigation_toolbar.addAction(next_btn)
-
-        navigation_toolbar.addSeparator()
-
-        reload_btn = QAction(QIcon(str(get_resource(":/icons/reload.svg"))), "Reload", self)
-        reload_btn.setStatusTip("Reload")
-        reload_btn.triggered.connect(self.browser.reload)
-        navigation_toolbar.addAction(reload_btn)
-
-    def set_topic_home(self, topic: str):
-        url = HELP_TOPICS[topic]
-        self._url = url
-        self.navigate_home()
-
-    def navigate_home(self):
-        """
-        Navigate to the home page, i.e. the URL that was passed as an argument when constructing
-        the Help Window.
-        """
-        self.browser.setUrl(QUrl(self._url))
-
-
-if __name__ == "__main__":
-
-    app = QApplication(sys.argv)
-
-    url = HELP_TOPICS["puna_ui"]
-    help_window = HelpWindow(topic_url=url)
-    help_window.show()
-
-    app.exec_()

egse/hexapod/__init__.py

@@ -1,32 +0,0 @@
-"""
-The Hexapod package provides the components to interact with the PUNA Hexapod of
-Symétrie, i.e.
-
-* The Hexapod commanding concept with Command, and CommandProtocol
-* The client server access through Proxy and ControlServer
-* The interface to the hardware controller: HexapodController and its simulator
-
-This package also contains the Hexapod GUI which can be used to monitor the
-hexapod positions in different reference frames and apply simple movements.
-
-"""
-
-
-class HexapodError(Exception):
-    """A Hexapod specific error."""
-    pass
-
-
-# These are the classes and function that we would like to export. This is mainly
-# to simplify import statements in scripts. The user can now use the following:
-#
-#    >>> from egse.hexapod import HexapodProxy
-#
-# while she previously had to import the class as follows:
-#
-#    >>> from egse.hexapod.hexapodProxy import HexapodProxy
-#
-
-__all__ = [
-    'HexapodError',
-]

egse/hexapod/symetrie/__init__.py

@@ -1,138 +0,0 @@
-"""
-Device control for the Symétrie Hexapod PUNA and ZONDA.
-
-This package contains the modules and classes to work with the Hexapod PUNA and the Hexapod ZONDA
-from [Symétrie](www.symetrie.fr).
-
-The main entry point for the user of this package is through the terminal commands to start the
-control servers for the PUNA and ZONDA Hexapod, and the GUIs that are provided to interact with
-the hexapods. The following commands start the control servers for both the PUNA and the ZONDA
-in the background.
-
-    $ puna_cs start-bg
-    $ zonda_cs start-bg
-
-The GUIs can be started with the following commands:
-
-    $ puna_ui
-    $ zonda_ui
-
-For developers, the `PunaProxy` and `ZondaProxy` classes are the main interface to command the
-hardware.
-
-    >>> from egse.hexapod.symetrie.puna import PunaProxy
-    >>> puna = PunaProxy()
-
-and for the ZONDA:
-
-    >>> from egse.hexapod.symetrie.zonda import ZondaProxy
-    >>> zonda = ZondaProxy()
-
-These classes will connect to their control servers and provide all commands to
-control the hexapod and monitor its positions and status.
-
-
-"""
-from egse.device import DeviceFactoryInterface
-from egse.settings import Settings
-
-PUNA_SETTINGS = Settings.load("PMAC Controller")
-
-
-def get_hexapod_controller_pars(setup: 'Setup' = None) -> (str, int, str, str, str):
-    """
-    Returns the hostname (str), port number (int), hexapod id (str), hexapod name (str),
-    and type (str) for the hexapod controller as defined in the Setup and Settings.
-
-    Note the returned values are for the device hardware controller, not the control server.
-
-    If no setup argument is provided, the Setup will be loaded from the GlobalState.
-    """
-
-    from egse.state import GlobalState
-    from egse.setup import SetupError
-
-    setup = setup or GlobalState.setup
-
-    try:
-        try:
-            hexapod_id = setup.gse.hexapod.device_args.device_id
-            hexapod_name: str = setup.gse.hexapod.device_args.device_name
-        except AttributeError:
-            # Handle older Setups where no device_args existed for the PUNA hexapod
-            hexapod_id = setup.gse.hexapod.ID
-            hexapod_name: str = setup.gse.hexapod.device_name
-        hexapod_id = f"H_{hexapod_id}"
-        hostname: str = PUNA_SETTINGS[hexapod_id]["HOSTNAME"]
-        port: int = int(PUNA_SETTINGS[hexapod_id]["PORT"])
-        controller_type: str = PUNA_SETTINGS[hexapod_id]["TYPE"]
-    except AttributeError as exc:
-        raise SetupError("The Setup doesn't contain proper controller parameters for the Hexapod.") from exc
-
-    return hostname, port, hexapod_id, hexapod_name, controller_type
-
-
-class ProxyFactory(DeviceFactoryInterface):
-    """
-    A factory class that will create the Proxy that matches the given device name and identifier.
-
-    The device name is matched against the string 'puna' or 'zonda'. If the device name doesn't contain
-    one of these names, a ValueError will be raised.
-    """
-
-    def create(self, device_name: str, *, device_id: str = None, **_ignored):
-
-        if "puna" in device_name.lower():
-            if not device_id.startswith("H_"):
-                device_id = f"H_{device_id}"
-
-            controller_type = PUNA_SETTINGS[device_id]["TYPE"]
-            if controller_type == "ALPHA":
-                from egse.hexapod.symetrie.puna import PunaProxy
-                return PunaProxy()
-            elif controller_type == "ALPHA_PLUS":
-                from egse.hexapod.symetrie.punaplus import PunaPlusProxy
-                return PunaPlusProxy()
-            else:
-                raise ValueError(f"Unknown controller_type ({controller_type}) for {device_name} – {device_id}")
-
-        elif "zonda" in device_name.lower():
-            from egse.hexapod.symetrie.zonda import ZondaProxy
-            return ZondaProxy()
-
-        else:
-            raise ValueError(f"Unknown device name: {device_name}")
-
-
-class ControllerFactory(DeviceFactoryInterface):
-    """
-    A factory class that will create the Controller that matches the given device name and identifier.
-
-    The device name is matched against the string 'puna' or 'zonda'. If the device name doesn't contain
-    one of these names, a ValueError will be raised.
-    """
-    def create(self, device_name: str, *, device_id: str = None, **_ignored):
-
-        if "puna" in device_name.lower():
-            from egse.hexapod.symetrie.puna import PunaController
-            from egse.hexapod.symetrie.punaplus import PunaPlusController
-
-            if not device_id.startswith("H_"):
-                device_id = f"H_{device_id}"
-
-            hostname = PUNA_SETTINGS[device_id]["HOSTNAME"]
-            port = PUNA_SETTINGS[device_id]["PORT"]
-            controller_type = PUNA_SETTINGS[device_id]["TYPE"]
-            if controller_type == "ALPHA":
-                return PunaController(hostname=hostname, port=port)
-            elif controller_type == "ALPHA_PLUS":
-                return PunaPlusController(hostname=hostname, port=port)
-            else:
-                raise ValueError(f"Unknown controller_type ({controller_type}) for {device_name} – {device_id}")
-
-        elif "zonda" in device_name.lower():
-            from egse.hexapod.symetrie.zonda import ZondaController
-            return ZondaController()
-
-        else:
-            raise ValueError(f"Unknown device name: {device_name}")