Use the new data loaders in the refactored data explorer.

src/ascii_dialog/dialog.py

@@ -14,6 +14,7 @@
 from metadata_filename_gui.metadata_tree_data import initial_metadata_dict
 from sasdata.ascii_reader_metadata import AsciiReaderMetadata
 from ascii_dialog.constants import TABLE_MAX_ROWS, NOFILE_TEXT
+from contextlib import suppress
 import re
 
 dataset_dictionary = dict([(dataset.name, dataset) for dataset in [one_dim, two_dim, sesans]])
@@ -64,8 +65,10 @@ def __init__(self):
         self.dataset_layout = QHBoxLayout()
         self.dataset_label = QLabel("Dataset Type")
         self.dataset_combobox = QComboBox()
-        for name in dataset_types:
-            self.dataset_combobox.addItem(name)
+        # TODO: Temporarily exclude SESANS until that's been fixed.
+        with suppress(ValueError):
+            dataset_types.remove('SESANS')
+        self.dataset_combobox.addItems(dataset_types)
         self.dataset_layout.addWidget(self.dataset_label)
         self.dataset_layout.addWidget(self.dataset_combobox)
 

src/sas/data_explorer_menu.py

@@ -6,27 +6,33 @@
 from src.sas.refactored import Perspective
 from dataclasses import dataclass
 
+
 # TODO: Could we perhaps enforce that, if the action is send_to, the action_data
 # should not be None?
 @dataclass
-class DataExplorerMenuAction():
-    action: Literal['remove', 'send_to']
+class DataExplorerMenuAction:
+    action: Literal["remove", "send_to", "view_data"]
     action_data: Perspective | None = None
 
+
 class DataExplorerMenu(QMenu):
     def __init__(self, parent: QWidget, data_manager: NewDataManager, send_to: bool):
         super().__init__(parent)
 
         remove_data = QAction("Remove", parent)
         # remove_data.setData('remove')
-        remove_data.setData(DataExplorerMenuAction('remove'))
+        remove_data.setData(DataExplorerMenuAction("remove"))
+
+        view_data = QAction("View Data", parent)
+        view_data.setData(DataExplorerMenuAction("view_data"))
         # TODO: There will be loads more
 
         if send_to:
             send_to_menu = self.addMenu("Send To")
 
             for perspective in data_manager.all_perspectives:
                 new_action = QAction(perspective.formatName, parent)
-                new_action.setData(DataExplorerMenuAction('send_to', perspective))
+                new_action.setData(DataExplorerMenuAction("send_to", perspective))
                 send_to_menu.addAction(new_action)
         self.addAction(remove_data)
+        self.addAction(view_data)

src/sas/data_explorer_tree.py

@@ -1,12 +1,19 @@
 from typing_extensions import cast
 from PySide6.QtCore import Qt, Signal
 from PySide6.QtGui import QCursor
-from PySide6.QtWidgets import QAbstractItemView, QMessageBox, QTreeWidget, QTreeWidgetItem, QWidget
+from PySide6.QtWidgets import (
+    QAbstractItemView,
+    QTreeWidget,
+    QTreeWidgetItem,
+    QWidget,
+)
 from sasdata.data import SasData
 from sas.data_manager import NewDataManager as DataManager, TrackedData
 from sas.refactored import Perspective
 from src.sas.data_explorer_error_message import DataExplorerErrorMessage
 from src.sas.data_explorer_menu import DataExplorerMenu, DataExplorerMenuAction
+from sas.qtgui.MainWindow.DataViewer import DataViewer
+
 
 # TODO: Is this the right place for this?
 def tracked_data_name(data: TrackedData) -> str:
@@ -15,14 +22,19 @@ def tracked_data_name(data: TrackedData) -> str:
     else:
         return data.formatName
 
+
 class DataExplorerTree(QTreeWidget):
     current_datum_removed = Signal()
+    view_data_activated = Signal()
 
-    def __init__(self, data_manager: DataManager, parent: QWidget | None = None) -> None:
+    def __init__(
+        self, data_manager: DataManager, parent: QWidget | None = None
+    ) -> None:
         super().__init__(parent)
         self._data_manager = data_manager
         _ = self._data_manager.new_data.connect(self.addToTable)
         _ = self._data_manager.data_removed.connect(self.removeFromTable)
+        _ = self.view_data_activated.connect(self.showViewData)
 
         self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
         self.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
@@ -55,13 +67,17 @@ def removeAssociation(self, datum1: TrackedData, datum2: TrackedData):
         # TODO: Again, order.
         self.removeFromTable(datum2, root_datum=datum1)
 
-
     def addToTable(self, datum: TrackedData):
         item = QTreeWidgetItem([tracked_data_name(datum)])
         item.setData(0, Qt.ItemDataRole.UserRole, datum)
         self.addTopLevelItem(item)
 
-    def removeFromTable(self, datum: TrackedData, starting_root: QTreeWidgetItem | None = None, root_datum: TrackedData | None = None):
+    def removeFromTable(
+        self,
+        datum: TrackedData,
+        starting_root: QTreeWidgetItem | None = None,
+        root_datum: TrackedData | None = None,
+    ):
         """The root_datum param is needed when you want to delete something from the tree that has a certain root item.
         This is mostly useful for getting rid of associations."""
         root = self.invisibleRootItem() if starting_root is None else starting_root
@@ -71,7 +87,10 @@ def removeFromTable(self, datum: TrackedData, starting_root: QTreeWidgetItem | N
         for i in range(root.childCount()):
             item = root.child(i)
             item_datum = cast(TrackedData, item.data(0, Qt.ItemDataRole.UserRole))
-            if item_datum == datum and (not root_datum is None or root_datum == root.data(0, Qt.ItemDataRole.UserRole)):
+            if item_datum == datum and (
+                root_datum is not None
+                or root_datum == root.data(0, Qt.ItemDataRole.UserRole)
+            ):
                 # Need to defer this to later so we don't delete data while we're doing a for loop over it.
                 to_remove.append(item)
             elif item.childCount() != 0:
@@ -89,10 +108,12 @@ def showContextMenu(self):
         result: DataExplorerMenuAction = action.data()
         errors: list[ValueError] = []
         match result.action:
-            case 'remove':
+            case "remove":
                 # TODO: Work for all data.
                 self.current_datum_removed.emit()
-            case 'send_to':
+            case "view_data":
+                self.view_data_activated.emit()
+            case "send_to":
                 # TODO: This cast might not be necessary.
                 to_perspective = cast(Perspective, result.action_data)
                 # TODO: I'm a bit worried about potential repetition if there are more actions here. Will need to
@@ -106,6 +127,10 @@ def showContextMenu(self):
             box = DataExplorerErrorMessage(self, errors)
             box.show()
 
+    def showViewData(self):
+        viewer = DataViewer(self.currentTrackedDatum)
+        viewer.exec()
+
     @property
     def currentTrackedDatum(self) -> TrackedData | None:
         if len(self.currentTrackedData) == 0:
@@ -121,7 +146,9 @@ def currentTrackedData(self) -> list[TrackedData]:
 
     # Annoyingly, there is no way to get all the items in a tree. So we have to
     # do this recursively instead.
-    def setCurrentTrackedDatum(self, datum: TrackedData, root: QTreeWidgetItem | None = None):
+    def setCurrentTrackedDatum(
+        self, datum: TrackedData, root: QTreeWidgetItem | None = None
+    ):
         if root is None:
             root = self.invisibleRootItem()
         for i in range(root.childCount()):

src/sas/qtgui/MainWindow/DataViewer.py

@@ -0,0 +1,58 @@
+from PySide6.QtWidgets import (
+    QDialog,
+    QLabel,
+    QGridLayout,
+    QPushButton,
+    QTableWidget,
+    QTableWidgetItem,
+    QHeaderView,
+)
+from sasdata.data import SasData
+from sas.qtgui.MainWindow.MetadataExplorer import MetadataExplorer
+
+
+class DataViewer(QDialog):
+    def __init__(self, to_view: SasData):
+        super().__init__()
+        self.to_view = to_view
+        self.layout = QGridLayout(self)
+
+        self.nameLabel = QLabel(f"Name: {self.to_view.name}")
+        self.viewMetadataButton = QPushButton("View Metadata")
+        self.viewMetadataButton.clicked.connect(self.openMetadataExplorer)
+        self.dataTypeLabel = QLabel(
+            f"Type: {self.to_view.dataset_type.name}"
+        )  # TODO: Probably a better way of printing this
+        self.dataTable = QTableWidget()
+        self.buildTable()
+        self.closeButton = QPushButton("Close")
+        self.closeButton.clicked.connect(self.close)
+
+        self.setWindowTitle("Data Viewer")
+        self.layout.addWidget(self.nameLabel, 0, 0, 1, 1)
+        self.layout.addWidget(self.viewMetadataButton, 0, 1, 1, 1)
+        self.layout.addWidget(self.dataTypeLabel, 1, 0, 1, 1)
+        self.layout.addWidget(self.dataTable, 2, 0, 1, 2)
+        self.layout.addWidget(self.closeButton, 3, 0, 1, 2)
+
+    def buildTable(self):
+        # Make the table readonly
+        self.dataTable.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers)
+        columns = self.to_view._data_contents.keys()
+        self.dataTable.setColumnCount(len(columns))
+        # NOTE: Assumes each column has the same amount of rows, which should be
+        # the case, although perhaps we should validate this.
+        self.dataTable.setRowCount(
+            len(next(iter(self.to_view._data_contents.values())).value)
+        )
+        self.dataTable.setHorizontalHeaderLabels(columns)
+        self.dataTable.horizontalHeader().setSectionResizeMode(
+            QHeaderView.ResizeMode.Stretch
+        )
+        for i, data in enumerate(self.to_view._data_contents.values()):
+            for j, datum in enumerate(data.value):
+                self.dataTable.setItem(j, i, QTableWidgetItem(str(datum)))
+
+    def openMetadataExplorer(self):
+        explorer = MetadataExplorer(self.to_view.metadata, self.to_view.name)
+        explorer.exec()

src/sas/qtgui/MainWindow/GuiManager.py

@@ -190,6 +190,7 @@ def addWidgets(self):
         # self.filesWidget = DataExplorerWindow(self._parent, self, manager=self._data_manager)
         # TODO: Is this a good opportunity to change this name? dataExplorer would be better I think.
         self.filesWidget = NewDataExplorer(self._data_manager ,self._parent)
+        self.filesWidget.new_perspective.connect(self.new_perspective)
         ObjectLibrary.addObject('DataExplorer', self.filesWidget)
 
         self.dockedFilesWidget = QDockWidget("Data Explorer", self._workspace)
@@ -778,6 +779,7 @@ def addTriggers(self):
 
         # File
         self._workspace.actionLoadData.triggered.connect(self.actionLoadData)
+        self._workspace.actionAdvanced_Load.triggered.connect(self.actionAdvancedLoad)
         self._workspace.actionLoad_Data_Folder.triggered.connect(self.actionLoad_Data_Folder)
         self._workspace.actionOpen_Project.triggered.connect(self.actionOpen_Project)
         self._workspace.actionOpen_Analysis.triggered.connect(self.actionOpen_Analysis)
@@ -869,6 +871,9 @@ def actionLoadData(self):
         """
         self.filesWidget.loadFile()
 
+    def actionAdvancedLoad(self):
+        self.filesWidget.onAdvancedLoad()
+
     def actionLoad_Data_Folder(self):
         """
         Menu File/Load Data Folder

src/sas/qtgui/MainWindow/MetadataExplorer.py

@@ -10,37 +10,27 @@
     QVBoxLayout,
 )
 from sasdata.metadata import MetaNode, Metadata
+from sasdata.quantities.quantity import Quantity
 from sasdata.temp_xml_reader import load_data
 
 
+def convert_raw_to_dict(to_convert: MetaNode) -> dict:
+    # converted = {to_convert.name: to_convert.contents}
+    if isinstance(to_convert.contents, str) or isinstance(
+        to_convert.contents, Quantity
+    ):
+        return {to_convert.name: to_convert.contents}
+    value = {}
+    # We can now assume that every content is a MetaNode as per the typing.
+    for content in to_convert.contents:
+        value = value | convert_raw_to_dict(content)
+    return {to_convert.name: value}
+
+
 def metadata_as_dict(to_convert: object):
-    """This is a custom implementation of asdict from dataclasses. The key
-    difference is that MetaNode class objects are preserved (as well as other
-    leaf nodes), but everything else is converted into a dict. This makes it
-    easier to iterate over.
-
-    """
-    if isinstance(to_convert, list) and all([hasattr(item, '__dict__') for item in to_convert]):
-        converted_dicts: list[dict[str, object]] = []
-        for item in to_convert:
-            converted_dicts.append(item.__dict__)
-    elif hasattr(to_convert, "__dict__"):
-        converted_dicts = [to_convert.__dict__]
-    else:
-        return to_convert
-    for single_dict in converted_dicts:
-        for key, value in single_dict.items():
-            # This if statement looks for a meta node that is a child node, and leaves it as is (i.e. it doesn't turn it
-            # into a dict). Some meta nodes contain other meta nodes, so we need to add a condition for this.
-            if not (
-                value is dict
-                or (
-                    isinstance(value, MetaNode)
-                    and [isinstance(content, MetaNode) for content in value.contents]
-                )
-            ):
-                single_dict[key] = metadata_as_dict(value)
-        return converted_dicts[0] if len(converted_dicts) == 0 else converted_dicts
+    converted = to_convert.__dict__
+    converted["raw"] = convert_raw_to_dict(converted["raw"])
+    return converted
 
 
 class MetadataExplorer(QDialog):
@@ -82,7 +72,10 @@ def buildTree(
             dicts = [current_item]
         for single_dict in dicts:
             for key, value in single_dict.items():
-                if isinstance(value, dict) or (isinstance(value, list) and any([isinstance(member, dict) for member in value])):
+                if isinstance(value, dict) or (
+                    isinstance(value, list)
+                    and any([isinstance(member, dict) for member in value])
+                ):
                     dict_root = QTreeWidgetItem([key])
                     table_root.addChild(dict_root)
                     self.buildTree(dict_root, value)

src/sas/qtgui/MainWindow/UI/MainWindowUI.ui

@@ -24,14 +24,15 @@
      <x>0</x>
      <y>0</y>
      <width>915</width>
-     <height>20</height>
+     <height>22</height>
     </rect>
    </property>
    <widget class="QMenu" name="menu_File">
     <property name="title">
      <string>&amp;File</string>
     </property>
     <addaction name="actionLoadData"/>
+    <addaction name="actionAdvanced_Load"/>
     <addaction name="actionLoad_Data_Folder"/>
     <addaction name="separator"/>
     <addaction name="actionOpen_Project"/>
@@ -650,6 +651,11 @@
     <string>Dev Tools</string>
    </property>
   </action>
+  <action name="actionAdvanced_Load">
+   <property name="text">
+    <string>Advanced Load</string>
+   </property>
+  </action>
  </widget>
  <resources/>
  <connections/>