Refactoring Branch

build_tools/requirements.txt

@@ -25,7 +25,7 @@ pyparsing
 PySide6
 pytools
 qtconsole
-sasdata
+sasdata @ git+https://github.com/SasView/sasdata.git@refactor_24
 sasmodels
 scipy
 siphash24
@@ -38,4 +38,4 @@ zope
 requests
 
 # Alphabetized list of OS-specific packages
-pywin32; platform_system == "Windows"
+pywin32; platform_system == "Windows"

pyproject.toml

@@ -13,10 +13,7 @@ requires = [
     "periodictable",
     "pyopengl",
     "pyside6",
-    "qtconsole",
-    "scipy",
-    "superqt",
-    "sasdata",
+    "sasdata @ git+https://github.com/SasView/sasdata.git@refactor_24",
     "sasmodels",
     "twisted",
     "uncertainties",

src/ascii_dialog/col_editor.py

@@ -0,0 +1,89 @@
+from typing import cast
+
+from PySide6.QtCore import Signal, Slot
+from PySide6.QtWidgets import QHBoxLayout, QWidget
+
+from sasdata.ascii_reader_metadata import bidirectional_pairings
+from sasdata.quantities.units import NamedUnit
+
+from ascii_dialog.column_unit import ColumnUnit
+
+
+class ColEditor(QWidget):
+    """An editor widget which allows the user to specify the columns of the data
+    from a set of options based on which dataset type has been selected."""
+    column_changed = Signal()
+
+    def __init__(self, cols: int, options: list[str]):
+        super().__init__()
+
+        self.cols = cols
+        self.options = options
+        self.layout = QHBoxLayout(self)
+        self.option_widgets: list[ColumnUnit] = []
+        for _ in range(cols):
+            new_widget = ColumnUnit(self.options)
+            new_widget.column_changed.connect(self.onColumnUpdate)
+            self.layout.addWidget(new_widget)
+            self.option_widgets.append(new_widget)
+
+    @Slot()
+    def onColumnUpdate(self):
+        column_changed = cast(ColumnUnit, self.sender())
+        pairing = bidirectional_pairings.get(column_changed.currentColumn)
+        if pairing is not None:
+            for col_unit in self.option_widgets:
+                # Second condition is important because otherwise, this event will keep being called, and the GUI will
+                # go into an infinite loop.
+                if col_unit.currentColumn == pairing and col_unit.currentUnit != column_changed.currentUnit:
+                    col_unit.currentUnit = column_changed.currentUnit
+
+    def setCols(self, new_cols: int):
+        """Set the amount of columns for the user to edit."""
+
+        # Decides whether we need to extend the current set of combo boxes, or
+        # remove some.
+        if self.cols < new_cols:
+            for _ in range(new_cols - self.cols):
+                new_widget = ColumnUnit(self.options)
+                new_widget.column_changed.connect(self.onColumnUpdate)
+                self.layout.addWidget(new_widget)
+                self.option_widgets.append(new_widget)
+
+            self.cols = new_cols
+        if self.cols > new_cols:
+            excess_cols = self.cols - new_cols
+            length = len(self.option_widgets)
+            excess_combo_boxes = self.option_widgets[length - excess_cols:length]
+            for box in excess_combo_boxes:
+                self.layout.removeWidget(box)
+                box.setParent(None)
+            self.option_widgets = self.option_widgets[0:length - excess_cols]
+            self.cols = new_cols
+        self.column_changed.emit()
+
+    def setColOrder(self, cols: list[str]):
+        """Sets the series of currently selected columns to be cols, in that
+        order. If there are not enough column widgets include as many of the
+        columns in cols as possible.
+
+        """
+        try:
+            for i, col_name in enumerate(cols):
+                self.option_widgets[i].setCurrentColumn(col_name)
+        except IndexError:
+            pass # Can ignore because it means we've run out of widgets.
+
+    def colNames(self) -> list[str]:
+        """Get a list of all of the currently selected columns."""
+        return [widget.currentColumn for widget in self.option_widgets]
+
+    @property
+    def columns(self) -> list[tuple[str, NamedUnit | None]]:
+        return [(widget.currentColumn, widget.currentUnit if widget.currentColumn != "<ignore>" else None) for widget in self.option_widgets]
+
+    def replaceOptions(self, new_options: list[str]) -> None:
+        """Replace options from which the user can choose for each column."""
+        self.options = new_options
+        for widget in self.option_widgets:
+            widget.replaceOptions(new_options)

src/ascii_dialog/column_unit.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+
+from PySide6.QtCore import Signal, Slot
+from PySide6.QtGui import QRegularExpressionValidator
+from PySide6.QtWidgets import QComboBox, QHBoxLayout, QSizePolicy, QWidget
+
+from sasdata.dataset_types import unit_kinds
+from sasdata.default_units import defaults_or_fallback
+from sasdata.quantities.units import NamedUnit
+
+from ascii_dialog.unit_selector import UnitSelector
+
+
+def configure_size_policy(combo_box: QComboBox) -> None:
+    policy = combo_box.sizePolicy()
+    policy.setHorizontalPolicy(QSizePolicy.Policy.Ignored)
+    combo_box.setSizePolicy(policy)
+
+class ColumnUnit(QWidget):
+    """Widget with 2 combo boxes: one allowing the user to pick a column, and
+    another to specify the units for that column."""
+    def __init__(self, options) -> None:
+        super().__init__()
+        self.col_widget = self.createColComboBox(options)
+        self.unit_widget = self.createUnitComboBox(self.col_widget.currentText())
+        self.layout = QHBoxLayout(self)
+        self.layout.addWidget(self.col_widget)
+        self.layout.addWidget(self.unit_widget)
+        self.current_option: str
+
+    column_changed = Signal()
+
+    def createColComboBox(self, options: list[str]) -> QComboBox:
+        """Create the combo box for specifying the column based on the given
+        options."""
+        new_combo_box = QComboBox()
+        configure_size_policy(new_combo_box)
+        for option in options:
+            new_combo_box.addItem(option)
+        new_combo_box.setEditable(True)
+        validator = QRegularExpressionValidator(r"[a-zA-Z0-9]+")
+        new_combo_box.setValidator(validator)
+        new_combo_box.currentTextChanged.connect(self.onOptionChange)
+        return new_combo_box
+
+    def createUnitComboBox(self, selected_option: str) -> QComboBox:
+        """Create the combo box for specifying the unit for selected_option"""
+        new_combo_box = QComboBox()
+        configure_size_policy(new_combo_box)
+        new_combo_box.setEditable(True)
+        self.updateUnits(new_combo_box, selected_option)
+        new_combo_box.currentTextChanged.connect(self.onUnitChange)
+        return new_combo_box
+
+    def updateUnits(self, unit_box: QComboBox, selected_option: str):
+        unit_box.clear()
+        self.current_option = selected_option
+        # Use the list of preferred units but fallback to the first 5 if there aren't any for this particular column.
+        if self.current_option == '<ignore>':
+            unit_box.setDisabled(True)
+        else:
+            unit_box.setDisabled(False)
+            unit_options = defaults_or_fallback(self.current_option)
+            option_symbols = [unit.symbol for unit in unit_options]
+            for option in option_symbols[:5]:
+                unit_box.addItem(option)
+            unit_box.addItem('Select More')
+
+
+    def replaceOptions(self, new_options) -> None:
+        """Replace the old options for the column with new_options"""
+        self.col_widget.clear()
+        self.col_widget.addItems(new_options)
+
+    def setCurrentColumn(self, new_column_value: str) -> None:
+        """Change the current selected column to new_column_value"""
+        self.col_widget.setCurrentText(new_column_value)
+        self.updateUnits(self.unit_widget, new_column_value)
+
+
+    @Slot()
+    def onOptionChange(self):
+        # If the new option is empty string, its probably because the current
+        # options have been removed. Can safely ignore this.
+        self.column_changed.emit()
+        new_option = self.col_widget.currentText()
+        if new_option == '':
+            return
+        try:
+            self.updateUnits(self.unit_widget, new_option)
+        except KeyError:
+            # Means the units for this column aren't known. This shouldn't be
+            # the case in the real version so for now we'll just clear the unit
+            # widget.
+            self.unit_widget.clear()
+
+    @Slot()
+    def onUnitChange(self):
+        new_text = self.unit_widget.currentText()
+        if new_text == 'Select More':
+            selector = UnitSelector(unit_kinds[self.col_widget.currentText()].name, False)
+            selector.exec()
+            # We need the selection unit in the list of options, or else QT has some dodgy behaviour.
+            self.unit_widget.insertItem(-1, selector.selected_unit.symbol)
+            self.unit_widget.setCurrentText(selector.selected_unit.symbol)
+        # This event could get triggered when the units have just been cleared, and not actually updated. We don't want
+        # to trigger it in this case.
+        elif not new_text == '':
+            self.column_changed.emit()
+
+    @property
+    def currentColumn(self):
+        """The currently selected column."""
+        return self.col_widget.currentText()
+
+    @property
+    def currentUnit(self) -> NamedUnit:
+        """The currently selected unit."""
+        current_unit_symbol = self.unit_widget.currentText()
+        for unit in unit_kinds[self.current_option].units:
+            if current_unit_symbol == unit.symbol:
+                return unit
+        # This error shouldn't really happen so if it does, it indicates there is a bug in the code.
+        raise ValueError("Current unit doesn't seem to exist")
+
+    @currentUnit.setter
+    def currentUnit(self, new_value: NamedUnit):
+        self.unit_widget.setCurrentText(new_value.symbol)

src/ascii_dialog/constants.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python
+
+
+TABLE_MAX_ROWS = 1000
+NOFILE_TEXT = "Click the button below to load a file."