2993 ascii file reader options

build_tools/requirements.txt

@@ -40,4 +40,4 @@ zope
 pywin32; platform_system == "Windows"
 
 # Alphabetized list of version-pinned packages
-PySide6==6.4.3  # Later versions do not mesh well with pyinstaller < 6.0
+PySide6

src/ascii_dialog/col_editor.py

@@ -0,0 +1,74 @@
+from PySide6.QtGui import QRegularExpressionValidator
+from PySide6.QtWidgets import QComboBox, QHBoxLayout, QWidget
+from PySide6.QtCore import Slot, Signal
+from 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()
+
+    @Slot()
+    def on_column_update(self):
+        self.column_changed.emit()
+
+
+    def __init__(self, cols: int, options: list[str]):
+        super().__init__()
+
+        self.cols = cols
+        self.options = options
+        self.layout = QHBoxLayout(self)
+        self.option_widgets = []
+        for _ in range(cols):
+            new_widget = ColumnUnit(self.options)
+            new_widget.column_changed.connect(self.on_column_update)
+            self.layout.addWidget(new_widget)
+            self.option_widgets.append(new_widget)
+
+    def set_cols(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.on_column_update)
+                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 set_col_order(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].set_current_column(col_name)
+        except IndexError:
+            pass # Can ignore because it means we've run out of widgets.
+
+    def col_names(self) -> list[str]:
+        """Get a list of all of the currently selected columns."""
+        return [widget.current_column for widget in self.option_widgets]
+
+    def replace_options(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.replace_options(new_options)

src/ascii_dialog/column_unit.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+
+from PySide6.QtCore import Signal, Slot
+from PySide6.QtWidgets import QComboBox, QCompleter, QHBoxLayout, QWidget
+from PySide6.QtGui import QRegularExpressionValidator
+from sasdata.dataset_types import unit_kinds
+from sasdata.quantities.units import symbol_lookup
+
+from unit_selector import UnitSelector
+
+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.create_col_combo_box(options)
+        self.unit_widget = self.create_unit_combo_box(self.col_widget.currentText())
+        self.layout = QHBoxLayout(self)
+        self.layout.addWidget(self.col_widget)
+        self.layout.addWidget(self.unit_widget)
+
+    column_changed = Signal()
+
+    def create_col_combo_box(self, options: list[str]) -> QComboBox:
+        """Create the combo box for specifying the column based on the given
+        options."""
+        new_combo_box = QComboBox()
+        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.on_option_change)
+        return new_combo_box
+
+    def create_unit_combo_box(self, selected_option: str) -> QComboBox:
+        """Create the combo box for specifying the unit for selected_option"""
+        new_combo_box = QComboBox()
+        new_combo_box.setEditable(True)
+        # word_list = ['alpha', 'omega', 'omicron', 'zeta']
+        # completer = QCompleter(word_list, self)
+        # new_combo_box.setCompleter(completer)
+        self.update_units(new_combo_box, selected_option)
+        new_combo_box.currentTextChanged.connect(self.on_unit_change)
+        return new_combo_box
+
+    def update_units(self, unit_box: QComboBox, selected_option: str):
+        unit_box.clear()
+        options = [unit.symbol for unit in unit_kinds[selected_option].units]
+        # We don't have preferred units yet. In order to simulate this, just
+        # take the first 5 options to display.
+        for option in options[:5]:
+            unit_box.addItem(option)
+        unit_box.addItem('Select More')
+
+
+    def replace_options(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 set_current_column(self, new_column_value: str) -> None:
+        """Change the current selected column to new_column_value"""
+        self.col_widget.setCurrentText(new_column_value)
+        self.update_units(self.unit_widget, new_column_value)
+
+
+    @Slot()
+    def on_option_change(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.update_units(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 on_unit_change(self):
+        if self.unit_widget.currentText() == 'Select More':
+            selector = UnitSelector(unit_kinds[self.col_widget.currentText()].name, False)
+            selector.exec()
+            self.unit_widget.setCurrentText(selector.selected_unit.symbol)
+
+    @property
+    def current_column(self):
+        """The currently selected column."""
+        return self.col_widget.currentText()
+
+    @property
+    def current_unit(self):
+        """The currently selected unit."""
+        return symbol_lookup[self.unit_widget.currentText()]