better tab handling, copy function updated

omc3_gui/plotting/classes.py

@@ -63,4 +63,4 @@ class ZoomingViewBox(ExViewBox):
  # self.getdataInRect()
  # self.changePointsColors()
  # else:
- # self.updateScaleBox(ev.buttonDownPos(), ev.pos())
+ # self.updateScaleBox(ev.buttonDownPos(), ev.pos())

omc3_gui/segment_by_segment/main_controller.py

@@ -1,7 +1,7 @@
 import logging
 from functools import partial
 from pathlib import Path
-from typing import Any, Dict, List, Sequence
+from typing import Any, Dict, List, Sequence, Tuple
 
 from omc3.sbs_propagation import segment_by_segment
 from qtpy import QtWidgets
@@ -13,10 +13,12 @@
 from omc3_gui.segment_by_segment.measurement_model import OpticsMeasurement
 from omc3_gui.segment_by_segment.measurement_view import OpticsMeasurementDialog
 from omc3_gui.segment_by_segment.segment_model import SegmentDataModel, SegmentItemModel, compare_segments
-from omc3_gui.utils.base_classes import Controller
+from omc3_gui.utils.ui_base_classes import Controller
 from omc3_gui.utils.file_dialogs import OpenDirectoriesDialog
 from omc3_gui.utils.threads import BackgroundThread
 from omc3_gui.segment_by_segment.segment_view import SegmentDialog
+from omc3.definitions.optics import ColumnsAndLabels
+from omc3_gui.plotting.classes import DualPlot
 
 LOGGER = logging.getLogger(__name__)
 
@@ -231,7 +233,11 @@ def segment_selection_changed(self, segments: Sequence[SegmentItemModel] = None)
  if len(segments) > 1:
  LOGGER.debug("More than one segment selected. Clearing Plots.")
  return
+
  # Plot segements
+ def_and_widget: Tuple[ColumnsAndLabels, DualPlot] = self._view.get_current_tab()
+ definition, widget = def_and_widget
+ # plot_segments()
 
  @Slot()
  def add_default_segments(self):
@@ -248,7 +254,7 @@ def add_default_segments(self):
  continue
 
  for segment_tuple in DEFAULT_SEGMENTS:
- segment = SegmentDataModel(*segment_tuple)
+ segment = SegmentDataModel(measurement, *segment_tuple)
  segment.start = f"{segment.start}.B{beam}"
  segment.end = f"{segment.end}.B{beam}"
  measurement.try_add_segment(segment)
@@ -291,15 +297,26 @@ def copy_segment(self, segments: Sequence[SegmentItemModel] = None):
  LOGGER.error("Please select at least one measurement.")
  return
 
- for measurement in selected_measurements:
- for segment_item in segments:
+ for segment_item in segments:
+ new_segment_name = f"{segment_item.name} - Copy"
+ for measurement in selected_measurements: 
+ # Check if copied segment name already exists in one of the measurements
  try:
- meas_segment = measurement.get_segment_by_name(segment_item.name)
- except NameError as e:
- LOGGER.warning(f"Could not copy segment. {e!s}")
- continue
- new_segment = get_segment_copy_with_unique_name(meas_segment, measurement)
- measurement.try_add_segment(new_segment)
+ measurement.get_segment_by_name(new_segment_name)
+ except NameError:
+ pass
+ else:
+ LOGGER.error(
+ f"Could not create copy \"{new_segment_name}\" as it already exists in {measurement.display()}."
+ )
+ break
+ else:
+ # None of the measurements have the copied segment name, so add to the measurements
+ for measurement in selected_measurements:
+ for segment in segment_item.segments:
+ new_segment = segment.copy()
+ new_segment.name = new_segment_name
+ measurement.try_add_segment(new_segment)
 
  self.measurement_selection_changed(selected_measurements)
 
@@ -324,7 +341,7 @@ def remove_segment(self, segments: Sequence[SegmentItemModel] = None):
  self.measurement_selection_changed(selected_measurements)
 
  @Slot()
- def run_segments(self, segments: Sequence[SegmentDataModel] = None):
+ def run_segments(self, segments: Sequence[SegmentItemModel] = None):
  if segments is None:
  segments = self._view.get_selected_segments()
  if not segments:
@@ -354,16 +371,3 @@ def run_segments(self, segments: Sequence[SegmentDataModel] = None):
 
  LOGGER.info(f"Starting {measurement_task.message}")
  measurement_task.start()
-
-
-def get_segment_copy_with_unique_name(segment: SegmentDataModel, measurement: OpticsMeasurement) -> SegmentDataModel:
- new_segment = segment.copy()
- idx = 0
- segment_names = [s.name for s in measurement.segments]
- new_name = new_segment.name
- while new_name in segment_names:
- idx += 1
- new_name = f"{segment.name}_{idx}"
- new_segment.name = new_name
- return new_segment
-

omc3_gui/segment_by_segment/main_view.py

@@ -1,26 +1,28 @@
 
 # from omc3_gui.segment_by_segment.segment_by_segment_ui import Ui_main_window
 import logging
-from typing import Dict, List, Sequence, Tuple
+from typing import Dict, Iterator, List, Sequence, Tuple
 
 from PyQt5 import QtGui
 from qtpy import QtGui, QtWidgets
-from qtpy.QtCore import QItemSelectionModel, QModelIndex, Qt, Signal, Slot
+from qtpy.QtCore import QItemSelectionModel, QModelIndex, Qt, Signal, Slot, QEvent
 
 from omc3_gui.plotting.classes import DualPlot
 from omc3_gui.segment_by_segment.main_model import MeasurementListModel, SegmentTableModel
 from omc3_gui.segment_by_segment.measurement_model import OpticsMeasurement
 from omc3_gui.segment_by_segment.segment_model import SegmentItemModel
 from omc3_gui.utils import colors
-from omc3_gui.utils.base_classes import View
+from omc3_gui.utils.ui_base_classes import View
 from omc3_gui.utils.counter import HorizontalGridLayoutFiller
 from omc3_gui.utils.styles import MONOSPACED_TOOLTIP
 from omc3_gui.utils.widgets import (DefaultButton, EditButton, OpenButton, RemoveButton, RunButton)
+from omc3.definitions.optics import ColumnsAndLabels, PHASE_COLUMN
+from omc3_gui.utils.iteration_classes import IterClass 
 
 LOGGER = logging.getLogger(__name__)
 
-class Tab:
- PHASE: str = "Phase"
+class Tabs(IterClass):
+ PHASE: ColumnsAndLabels = PHASE_COLUMN
 
 
 class SbSWindow(View):
@@ -41,7 +43,6 @@ def __init__(self, parent=None):
  # Widgets ---
  self._cental: QtWidgets.QSplitter = None
  self._tabs_widget: QtWidgets.QTabWidget = None
- self._tabs: Dict[str, DualPlot] = None
  self._list_view_measurements: QtWidgets.QListView = None
  self._table_segments: QtWidgets.QTableView = None
 
@@ -191,7 +192,8 @@ def build_segment_buttons():
 
  def build_tabs_widget(): # --- Right Hand Side
  self._tabs_widget = QtWidgets.QTabWidget()
- self._tabs = self._create_tabs(self._tabs_widget)
+ for tab in Tabs.values():
+ self._tabs_widget.addTab(DualPlot(), tab.text_label.capitalize())
  return self._tabs_widget
 
  self._central.addWidget(build_tabs_widget())
@@ -202,14 +204,10 @@ def build_tabs_widget(): # --- Right Hand Side
 
  self.setCentralWidget(self._central)
 
- def _create_tabs(self, tab_widget: QtWidgets.QTabWidget) -> Dict[str, "DualPlot"]:
- tabs = {}
-
- new_plot = DualPlot()
- tab_widget.addTab(new_plot, Tab.PHASE)
- tabs[Tab.PHASE] = new_plot
-
- return tabs
+ def get_current_tab(self) -> Tuple[ColumnsAndLabels, DualPlot]:
+ widget = self._tabs_widget.currentWidget()
+ index = self._tabs_widget.currentIndex()
+ return list(Tabs.values())[index], widget
 
  # Getters and Setters
  def set_measurements(self, measurement_model: MeasurementListModel):

omc3_gui/segment_by_segment/segment_model.py

@@ -1,19 +1,22 @@
 from __future__ import annotations # Together with TYPE_CHECKING: allow circular imports for type-hints
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import List, Optional, Union
 
 from omc3_gui.utils.dataclass_ui import metafield
 from omc3_gui.utils import colors
+from omc3.segment_by_segment.segments import SegmentDiffs
 
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
  from omc3_gui.segment_by_segment.measurement_model import OpticsMeasurement
 
 
-
-OK = f"<span color=\"{colors.GREEN_DARK}\">✓</span>"
-NO = f"<span color=\"{colors.RED_DARK}\">✗</span>"
+# HTML in tooltips does not work for me, and I cannot figure out why (jdilly)
+# OK = f"<font color=\"{colors.GREEN_DARK}\">✓</font>"
+# NO = f"<font color=\"{colors.RED_DARK}\">✗</font>"
+OK = "✓"
+NO = "✗"
 
 def not_empty(value):
  return value != ""
@@ -25,23 +28,33 @@ class SegmentDataModel:
  name: str = metafield("Name", "Name of the Segment", validate=not_empty)
  start: Optional[str] = metafield("Start", "Start of the Segment", default=None, validate=not_empty)
  end: Optional[str] = metafield("End", "End of the Segment", default=None, validate=not_empty)
- _data: Optional[dict] = None
+ _data: Optional[SegmentDiffs] = None
 
  def __str__(self):
  return self.name
 
  def is_element(self):
- return self.start is None or self.end is None
+ return is_element(self)
 
  def to_input_string(self):
  """ String representation of the segment as used in inputs."""
- if self.is_element():
- return self.name
- return f"{self.name},{self.start},{self.end}"
+ return to_input_string(self)
+
+ @property
+ def data(self) -> SegmentDiffs:
+ if self._data is None or self._data.directory != self.measurement.output_dir or self._data.segment_name != self.name:
+ self._data = SegmentDiffs(self.measurement.output_dir, self.name)
+ return self._data
 
  def has_run(self) -> bool:
- return bool(self._data)
+ try:
+ return self.data.get_path("phase_x").is_file()
+ except AttributeError:
+ return False
 
+ def clear_data(self):
+ self._data = None
+
  def copy(self):
  return SegmentDataModel(measurement=self.measurement, name=self.name, start=self.start, end=self.end)
 
@@ -112,18 +125,34 @@ def append_segment(self, segment: SegmentDataModel):
  if not compare_segments(self, segment):
  raise ValueError(f"Given segment has a different definition than this {self.__class__.name}.")
  self.segments.append(segment)
-
- @property
+
  def id(self) -> str:
  """ Unique identifier for the measurement, used in the ItemModel. """
  return self.name + str(self.start) + str(self.end)
 
  def tooltip(self) -> str:
  """ Returns a string with information about the segment, 
  as to be used in a tool-tip. """
- parts = [f"{OK if segment.has_run() else NO} {segment.measurement.display()}" for segment in self.segments]
+ parts = [f" {OK if segment.has_run() else NO}  {segment.measurement.display()}" for segment in self.segments]
  return "Run | Contained in:\n" + "\n".join(parts)
 
+ def is_element(self):
+ return is_element(self)
+
+ def to_input_string(self):
+ """ String representation of the segment as used in inputs."""
+ return to_input_string(self)
+
 def compare_segments(a: Union[SegmentDataModel, SegmentItemModel], b: Union[SegmentDataModel, SegmentItemModel]):
  return a.name == b.name and a.start == b.start and a.end == b.end
 
+
+# Common functions -------------------------------------------------------------
+
+def is_element(segment: [SegmentItemModel, SegmentDataModel]):
+ return segment.start is None or segment.end is None
+
+def to_input_string(segment: [SegmentItemModel, SegmentDataModel]):
+ if is_element(segment):
+ return segment.name
+ return f"{segment.name},{segment.start},{segment.end}"

omc3_gui/utils/iteration_classes.py

@@ -0,0 +1,53 @@
+from typing import Iterator, Tuple, Any
+
+EXCLUDED_NAME = "EXCLUDED_ATTRIBUTES"
+
+# Metaclasses ------------------------------------------------------------------
+
+class IterableAttributeNames(type):
+ """ Makes the class itself iterable over its attribute names. """
+
+
+ def __iter__(self) -> Iterator[str]:
+ for attr in dir(self):
+ if not attr.startswith("__") and attr != EXCLUDED_NAME and attr not in getattr(self, EXCLUDED_NAME, []):
+ yield attr
+
+
+class IterableAttributeValues(type):
+ """ Makes the class itself iterable over its attribute values. """
+ def __iter__(self) -> Iterator[Any]:
+ for attr, value in self.__dict__.items():
+ if not attr.startswith("__"):
+ yield value
+
+
+class IterableAttributeItems(type):
+ """ Makes the class itself iterable over its attribute name and values. """
+ def __iter__(self) -> Iterator[Tuple[str, Any]]:
+ for attr, value in self.__dict__.items():
+ if not attr.startswith("__"):
+ yield attr, value
+
+
+# Iterable Class ---------------------------------------------------------------
+
+
+class IterClass(metaclass=IterableAttributeNames):
+
+ EXCLUDED_ATTRIBUTES = ["keys", "values", "items"]
+
+ @classmethod
+ def keys(cls) -> Iterator[str]:
+ for attr in cls:
+ yield attr
+
+ @classmethod
+ def values(cls) -> Iterator[Any]:
+ for attr in cls:
+ yield getattr(cls, attr)
+
+ @classmethod
+ def items(cls) -> Iterator[Tuple[str, Any]]:
+ for attr in cls:
+ yield attr, getattr(cls, attr)