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

egse/dpu/hdf5_model.py

@@ -1,332 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-from typing import List
-from typing import Optional
-
-import h5py
-import natsort
-from PyQt5.QtCore import QAbstractItemModel
-from PyQt5.QtCore import QAbstractTableModel
-from PyQt5.QtCore import QModelIndex
-from PyQt5.QtCore import QObject
-from PyQt5.QtCore import Qt
-
-from egse.bits import beautify_binary
-from egse.reg import RegisterMap
-
-
-def get_type_name(x) -> str:
-    """Return a readable representation of the type of the given object."""
-    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))
-
-
-class TreeItem:
-    """
-    An item (node or leaf) in a generic tree structure.
-    """
-    def __init__(self, data: Any, parent: TreeItem = None):
-        self._child_items = []
-        self._item_data = data
-        self._parent_item = parent
-
-    def append_child(self, child: TreeItem):
-        """Adds a child HDF5Item to this object."""
-        self._child_items.append(child)
-
-    def child(self, row: int) -> Optional[TreeItem]:
-        """Returns the child at the given row. If an invalid row is given, None will be returned."""
-        if 0 <= row < len(self._child_items):
-            return self._child_items[row]
-        return None
-
-    def child_index(self, item: TreeItem) -> int:
-        """Returns the index (=row) of the child in the list of children."""
-        return self._child_items.index(item)
-
-    def child_count(self) -> int:
-        """Returns the number of children."""
-        return len(self._child_items)
-
-    def last_child(self) -> TreeItem:
-        """Returns the last child from the list of children."""
-        return self._child_items[-1]
-
-    def column_count(self) -> int:
-        """Returns the number of columns for this item."""
-        return len(self._item_data)
-
-    def data(self, column: int):
-        """
-        Returns the data in the given column for this item. If an invalid column is provided,
-        None is returned.
-        """
-        if 0 <= column < len(self._item_data):
-            return self._item_data[column]
-        return None
-
-    def row(self) -> int:
-        """
-        Returns the row index of this item in the list of children of its parent. Since the root
-        item has no parent, row=0 will be returned.
-        """
-        if self._parent_item:
-            return self._parent_item.child_index(self)
-        return 0
-
-    def parent_item(self) -> Optional[TreeItem]:
-        """Returns the parent item for this item."""
-        return self._parent_item
-
-
-class HDF5Item(TreeItem):
-    """
-    An item (node or leaf) in a tree structure representing the HDF5 file. The structure is
-    represented by a list of child items for this item and a link to the parent for this item.
-
-    The parent item (HDF5TreeItem) is None for the root item in this linked list. Leaf items have
-    no children, i.e. child_count=0.
-    """
-    def __init__(self, data: Any, parent: TreeItem = None, expandable: bool = False, item = None):
-        super().__init__(data, parent)
-        self._expandable = expandable
-        self._item = item
-
-    @property
-    def is_expandable(self):
-        return self._expandable
-
-    @property
-    def item_name(self):
-        return self._item.name
-
-    @property
-    def item_type(self):
-        return type(self._item)
-
-    @property
-    def item_size(self):
-        if isinstance(self._item, h5py.Dataset):
-            size = self._item.shape
-        elif isinstance(self._item, h5py.Group):
-            size = len(self._item)
-        else:
-            size = 0
-        return size
-
-    def get_item(self):
-        return self._item
-
-
-class TreeModel(QAbstractItemModel):
-    """
-    A (more or less) generic tree model.
-
-    Args:
-        data: a list of lists
-
-    """
-    ExpandableRole = Qt.UserRole + 500
-
-    def __init__(self, data: Any, header_data: List[str], parent: QObject = None):
-        super().__init__(parent)
-        self._root_item = TreeItem(header_data)
-        self.set_model_data(data, self._root_item)
-
-    def data(self, index: QModelIndex, role: int = ...) -> Any:
-        if not index.isValid():
-            return None
-
-        item: HDF5Item = index.internalPointer()
-
-        if role == Qt.DisplayRole:
-            return item.data(index.column())
-        if role == TreeModel.ExpandableRole:
-            return item.is_expandable
-        return None
-
-    def flags(self, index: QModelIndex) -> Qt.ItemFlags:
-        if not index.isValid():
-            return Qt.NoItemFlags
-        return super().flags(index)
-
-    def headerData(self, section: int, orientation: Qt.Orientation, role: int = ...) -> Any:
-        if orientation == Qt.Horizontal and role == Qt.DisplayRole:
-            return self._root_item.data(section)
-        return None
-
-    def index(self, row: int, column: int, parent: QModelIndex = ...) -> QModelIndex:
-
-        if not self.hasIndex(row, column, parent):
-            return QModelIndex()
-
-        if not parent.isValid():
-            parent_item = self._root_item
-        else:
-            parent_item = parent.internalPointer()
-
-        child_item = parent_item.child(row)
-
-        if child_item:
-            return self.createIndex(row, column, child_item)
-
-        return QModelIndex()
-
-    def parent(self, child: QModelIndex) -> QModelIndex:
-        if not child.isValid():
-            return QModelIndex()
-
-        child_item = child.internalPointer()
-        parent_item = child_item.parent_item()
-
-        if parent_item is self._root_item:
-            return QModelIndex()
-
-        return self.createIndex(parent_item.row(), 0, parent_item)
-
-    def rowCount(self, parent: QModelIndex = ...) -> int:
-        if parent.column() > 0:
-            row_count = 0
-            return row_count
-
-        if not parent.isValid():
-            parent_item = self._root_item
-        else:
-            parent_item = parent.internalPointer()
-
-        row_count = parent_item.child_count()
-        return row_count
-
-    def columnCount(self, parent: QModelIndex = ...) -> int:
-        if parent.isValid():
-            col_count = parent.internalPointer().column_count()
-        else:
-            col_count = self._root_item.column_count()
-        return col_count
-
-    def hasChildren(self, index: QModelIndex = QModelIndex(), *args, **kwargs):
-
-        if self.data(index, TreeModel.ExpandableRole):
-            has_children = True
-        else:
-            has_children = super().hasChildren(index)
-
-        return has_children
-
-    def set_model_data(self, data: Any, parent: TreeItem):
-        raise NotImplementedError
-
-
-class HDF5Model(TreeModel):
-    def __init__(self, hdf_file: h5py.File, parent: QObject = None):
-        self._hdf_file = hdf_file
-        self._hdf_root = hdf_file['/']
-
-        # Load the first items from the top level group '/' and pass them to the super class
-
-        data = self.get_model_data(self._hdf_root)
-
-        header_data = ['Datasets', 'Size', 'Type']
-
-        super().__init__(data, header_data, parent)
-
-    def set_model_data(self, data: Any, parent: TreeItem):
-
-        for item_data, expand, item in data:
-            parent.append_child(HDF5Item(item_data, parent, expandable=expand, item=item))
-
-    def get_model_data(self, group: h5py.Group):
-        data = []
-
-        if len(group) < 2000:
-            items = natsort.natsorted(group.items(), key=lambda x: x[0])
-        else:
-            items = group.items()
-
-        for name, item in items:
-            if isinstance(item, h5py.Dataset):
-                size = str(item.shape)
-                type_name = str(item.dtype)
-                expandable = False
-            else:
-                size = len(item)
-                type_name = get_type_name(item)
-                expandable = True
-            data.append(([name, size, type_name], expandable, item))
-
-        return data
-
-    def update_model_data(self, index: QModelIndex):
-
-        item: HDF5Item = index.internalPointer()
-
-        if isinstance(item, h5py.Dataset):
-            return
-
-        if not item.child_count():
-            group_name = item.item_name
-            group = self._hdf_file[group_name]
-            data = self.get_model_data(group)
-            self.set_model_data(data, item)
-            self.layoutChanged.emit()
-
-
-def convert_data_for_role(data, role):
-    if role == 0:
-        return int(data)
-    if role == 1:
-        return f"0x{data:08X}"
-    if role == 2:
-        return beautify_binary(data, prefix="0b")
-
-    return data
-
-
-class RegisterTableModel(QAbstractTableModel):
-    def __init__(self, reg_map: RegisterMap):
-        super().__init__()
-
-        self.setRegisterMap(reg_map)
-
-        self._col_names = ["Register name", "Parameter name", "Value"]
-        self._display_role = dict()
-
-    def data(self, index, role):
-        if role == Qt.DisplayRole:
-            # See below for the nested-list data structure.
-            # .row() indexes into the outer list,
-            # .column() indexes into the sub-list
-            col = index.column()
-            row = index.row()
-            if col in (0, 1):
-                return self._reg_names[row].split(':')[col]
-            if col == 2:
-                data = self._reg_data[self._reg_names[row]]
-                return convert_data_for_role(data, self._display_role.get(row, 0))
-
-    def setRegisterMap(self, reg_map: RegisterMap):
-        self._reg_map = reg_map
-        self._reg_data = reg_map.as_dict(flatten=True)
-        self._reg_names = list(self._reg_data)
-
-    def headerData(self, section: int, orientation: Qt.Orientation, role: int = None) -> Any:
-        # section is the index of the column/row.
-        if role == Qt.DisplayRole and orientation == Qt.Horizontal:
-            return self._col_names[section]
-
-    def toggleDisplayRole(self, index: QModelIndex):
-        if index.column() == 2:
-            role = self._display_role.get(index.row(), 0) + 1
-            self._display_role[index.row()] = role if role < 3 else 0
-
-    def rowCount(self, index):
-        return len(self._reg_names)
-
-    def columnCount(self, index):
-        return 3

egse/dpu/hdf5_ui.py

@@ -1,277 +0,0 @@
-"""
-This module provides all the code to generate the main GUI and the GUI components
-used by the HDF5 Viewer.
-"""
-import logging
-from pathlib import Path
-
-import h5py
-from PyQt5.QtCore import QAbstractTableModel
-from PyQt5.QtCore import QSize
-from PyQt5.QtCore import QSortFilterProxyModel
-from PyQt5.QtCore import Qt
-from PyQt5.QtGui import QFont
-from PyQt5.QtGui import QIcon
-from PyQt5.QtWidgets import QAction
-from PyQt5.QtWidgets import QLineEdit
-from PyQt5.QtWidgets import QMainWindow
-from PyQt5.QtWidgets import QScrollArea
-from PyQt5.QtWidgets import QSplitter
-from PyQt5.QtWidgets import QStackedWidget
-from PyQt5.QtWidgets import QStatusBar
-from PyQt5.QtWidgets import QTabWidget
-from PyQt5.QtWidgets import QTableView
-from PyQt5.QtWidgets import QTextEdit
-from PyQt5.QtWidgets import QToolBar
-from PyQt5.QtWidgets import QTreeView
-from PyQt5.QtWidgets import QVBoxLayout
-from PyQt5.QtWidgets import QWidget
-
-from egse.bits import humanize_bytes
-from egse.dpu.ccd_ui import NFEECCDWidget
-from egse.dpu.hk_ui import NFEEHousekeepingWidget
-from egse.resource import get_resource
-from egse.spw import DataPacket
-
-MODULE_LOGGER = logging.getLogger(__name__)
-
-
-class MainWindowGUI:
-    def setup_gui(self, main_window: QMainWindow):
-        """
-        Creates the widgets in the main window.
-
-        This method creates the following widgets that are accessible from the main window:
-
-        * tree_view (QTreeView): visualises a tree structure view of the HDF5 file
-        * table_view (QTableView): visualise a table
-        * data_view (QStackedLayout): a widget that contains different views
-        * graph_box (QtGraph ImageView): visualise a CCD image
-        * status_bar (QStatusBar): the status bar of the main window
-
-        Args:
-            main_window (QMainWindow): the main window of the application
-        """
-        main_window.setWindowTitle("N-FEE Data Inspector")
-        main_window.setObjectName("main_window")
-        main_window.resize(1400, 800)
-
-        splitter = QSplitter()
-        splitter.setContentsMargins(0, 0, 0, 0)
-
-        self.data_box = QSplitter(Qt.Vertical, splitter)
-        self.data_box.setMinimumWidth(300)
-        self.data_box.setContentsMargins(5, 5, 5, 5)
-
-        self.tree_view = QTreeView(self.data_box)
-
-        self.details_view = QTabWidget(self.data_box)
-        self.details_view.setTabsClosable(False)
-        self.details_view.setMovable(False)
-        self.details_view.setDocumentMode(True)
-        self.details_view.setElideMode(Qt.ElideRight)
-        self.details_view.setUsesScrollButtons(True)
-
-        self.properties = QTableView()
-        self.attributes = QTableView()
-        self.packet_header = QTableView()
-
-        self.details_view.addTab(self.properties, "Properties")
-        self.details_view.addTab(self.attributes, "Attributes")
-        self.details_view.addTab(self.packet_header, "Packet Header")
-
-        self.text_box: QTextEdit = QTextEdit()
-        self.text_box.setReadOnly(True)
-        self.text_box.setFont(QFont("Courier New"))
-        self.text_box.setLineWrapMode(QTextEdit.NoWrap)
-
-        self.table_view = QTableView()
-
-        self.proxy_model = QSortFilterProxyModel()
-        self.proxy_model.setFilterKeyColumn(-1)  # Search all columns
-        self.proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive)
-
-        self.table_view.setModel(self.proxy_model)
-
-        self.searchbar = QLineEdit()
-
-        # You can choose the type of search by connecting to a different slot here.
-        # see https://doc.qt.io/qt-5/qsortfilterproxymodel.html#public-slots
-
-        self.searchbar.textChanged.connect(self.proxy_model.setFilterRegExp)
-
-        layout = QVBoxLayout()
-        layout.setContentsMargins(0, 10, 10, 0)
-
-        layout.addWidget(self.searchbar)
-        layout.addWidget(self.table_view)
-
-        self.table_box = QWidget()
-        self.table_box.setLayout(layout)
-
-        self.hk_box = NFEEHousekeepingWidget()
-
-        self.graph_box = NFEECCDWidget(ccd_number=None, maximize=False)
-
-        self.data_view: QStackedWidget = QStackedWidget(splitter)
-        self.data_view.addWidget(self.text_box)
-        self.data_view.addWidget(self.table_box)
-        self.data_view.addWidget(self.hk_box)
-        self.data_view.addWidget(self.graph_box)
-        self.data_view.setCurrentIndex(0)
-
-        scroll = QScrollArea()
-        scroll.setObjectName("scroll")
-        scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
-        scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
-        scroll.setWidgetResizable(True)
-
-        main_window.setCentralWidget(splitter)
-
-        toolbar = QToolBar("Main Toolbar")
-        toolbar.setIconSize(QSize(36, 36))
-        main_window.addToolBar(toolbar)
-
-        self.open_doc_action = QAction(QIcon(str(get_resource(":/icons/open-document-hdf5.png"))),
-                                       "Open HDF5 file...", main_window)
-        self.open_doc_action.setStatusTip("Open a new HDF5 file...")
-        toolbar.addAction(self.open_doc_action)
-
-        self.status_bar = QStatusBar(main_window)
-        main_window.setStatusBar(self.status_bar)
-
-
-class PropertiesModel(QAbstractTableModel):
-    def __init__(self):
-        super().__init__()
-        self._header = ["Name", "Value"]
-        self._data = []
-
-    def data(self, index, role):
-        if role == Qt.DisplayRole:
-            value = self._data[index.row()][index.column()]
-            try:
-                return str(value)
-            except (Exception,) as exc:
-                return str(exc)
-
-    def rowCount(self, index):
-        return len(self._data)
-
-    def columnCount(self, index):
-        return len(self._data[0])
-
-    def headerData(self, section, orientation, role):
-        if role == Qt.DisplayRole:
-            if orientation == Qt.Horizontal:
-                return str(self._header[section])
-
-            if orientation == Qt.Vertical:
-                return None
-
-
-class FilePropertiesModel(PropertiesModel):
-    def __init__(self, data: h5py.File):
-        """
-        Args:
-            data: h5py.File
-        """
-        super().__init__()
-        self._data = [
-            ["Name", data.name],
-            ["Path", data.filename],
-            ["Size", humanize_bytes(Path(data.filename).stat().st_size, precision=0)]
-        ]
-
-
-class GroupPropertiesModel(PropertiesModel):
-    def __init__(self, data: h5py.Group):
-        """
-        Args:
-            data: h5py.Group
-        """
-        super().__init__()
-        self._data = [
-            ["Name", data.name],
-            ["Id", data.id],
-            ["Nr. items", len(data.items())],
-        ]
-
-
-class DatasetPropertiesModel(PropertiesModel):
-    def __init__(self, data: h5py.Dataset):
-        """
-        Args:
-            data: h5py.Dataset
-        """
-        super().__init__()
-        self._data = [
-            ["Name", data.name],
-            ["Id", data.id],
-            ["Shape", data.shape],
-            ["Type", data.dtype],
-            ["Chunks", data.chunks],
-            ["Nr. dimensions", data.ndim],
-            ["Size", humanize_bytes(data.size)],
-            ["Nr. bytes", humanize_bytes(data.nbytes)]
-        ]
-
-
-class AttributesModel(QAbstractTableModel):
-    def __init__(self, data):
-        """
-        Args:
-            data: h5py.File
-        """
-        super().__init__()
-        h5_file: h5py.File = data
-        self._header = ["Name", "Value"]
-        self._data = [[k, str(v)] for k, v in data.attrs.items()]
-
-    def data(self, index, role):
-        if role == Qt.DisplayRole:
-            return self._data[index.row()][index.column()]
-
-    def rowCount(self, index):
-        return len(self._data)
-
-    def columnCount(self, index):
-        return len(self._data[0])
-
-    def headerData(self, section, orientation, role):
-        if role == Qt.DisplayRole:
-            if orientation == Qt.Horizontal:
-                return str(self._header[section])
-
-            if orientation == Qt.Vertical:
-                return None
-
-
-class DataPacketHeaderModel(QAbstractTableModel):
-    def __init__(self, data: DataPacket):
-        """
-        Args:
-            data (DataPacket): SpaceWire data packet
-        """
-        super().__init__()
-        self._header = ["Name", "Value"]
-        packet_header = data.header
-        self._data = [[k, str(v)] for k, v in packet_header.as_dict().items()]
-
-    def data(self, index, role):
-        if role == Qt.DisplayRole:
-            return self._data[index.row()][index.column()]
-
-    def rowCount(self, index):
-        return len(self._data)
-
-    def columnCount(self, index):
-        return len(self._data[0])
-
-    def headerData(self, section, orientation, role):
-        if role == Qt.DisplayRole:
-            if orientation == Qt.Horizontal:
-                return str(self._header[section])
-
-            if orientation == Qt.Vertical:
-                return None