dev: добавлено меню выбора режима работы + реализован режим работы raport

params/operator_params.json

@@ -192,7 +192,7 @@
         0.0045
     ],
     "force_target": [
-        5000.0,
+        4000.0,
         5000.0,
         5000.0,
         5000.0,

src/controller/controller.py

@@ -8,14 +8,21 @@ class Controller(BaseController):
 
     signal_widgets = pyqtSignal(list)
     signal_settings = pyqtSignal(list)
-    signal_monitor = pyqtSignal(str)
+    signal_raport_mode = pyqtSignal(str)
+    signal_seeking_mode = pyqtSignal()
 
     def send_widgets(self, widgets: list[QWidget]) -> None:
         self.signal_widgets.emit(widgets)
     
-    def push_settings(self, settings: list[dict]) -> None:
+    def update_settings(self, settings: list[dict]) -> None:
         self.signal_settings.emit(settings)
 
-    def open_custom_file (self, filepath: str) -> None:
+    def raport_mode(self, filepath: str) -> None:
-        self.signal_monitor.emit(filepath)
+        self.signal_raport_mode.emit(filepath)
+    
+    def seeking_mode(self) -> None:
+        self.signal_seeking_mode.emit()
+
+
+    
     

src/controller/mediator.py

@@ -26,9 +26,9 @@ class Mediator(BaseMediator):
         if issubclass(source.__class__, BasePlotWidget):
             self._controller.send_widgets(data)
         
-    def push_settings(self, settings: list[dict]):
+    def update_settings(self, settings: list[dict]):
         self._monitor.update_settings(settings)
         self._passportFormer.update_settings(settings)
-        self._monitor.force_all_dir()
+        self._monitor.update_plots()
 
 

src/controller/monitor.py

@@ -7,16 +7,14 @@ from utils.base.base import BaseDirectoryMonitor
 class DirectoryMonitor(BaseDirectoryMonitor):
 
     def _init_state(self):
-        files = os.listdir(self._directory_path)
+        self._files = [os.path.join(self._directory_path, file) for file in os.listdir(self._directory_path)]
-        self._files = files
 
         self.update_timer.timeout.connect(self._monitor)
         logger.info("Monitor initiated!")
 
     def _monitor(self):
-        files = os.listdir(self._directory_path)
+        files = [os.path.join(self._directory_path, file) for file in os.listdir(self._directory_path)]
-        new_files = sorted(list(map(lambda x: os.path.join(self._directory_path, x),
+        new_files = sorted(list(filter(lambda x: x not in self._files, files)))
-                                    filter(lambda x: x not in self._files, files))))
         if new_files:
             logger.info(f"New files detected: {new_files}")
             self._mediator.notify(self, new_files)
@@ -25,12 +23,22 @@ class DirectoryMonitor(BaseDirectoryMonitor):
             self._files = []
 
     def update_settings(self, data: list[dict]) -> None:
-        self.stop()
+        if self.isActive:
-        _, system_params = data
+            self.stop()
-        self._directory_path = system_params['trace_storage_path'][0]
+            _, system_params = data
-        self._update_time = system_params['monitor_update_period'][0]
+            self._directory_path = system_params['trace_storage_path'][0]
-        self._init_state()
+            self._update_time = system_params['monitor_update_period'][0]
-        self.start()
+            self._init_state()
+            self.start()
+        else:
+            _, system_params = data
+            self._directory_path = system_params['trace_storage_path'][0]
+            self._update_time = system_params['monitor_update_period'][0]
+    
+    def update_plots(self):
+        if self._files is not None:
+            print(self._files)
+            self._mediator.notify(self, self._files)
 
     def force_all_dir(self):
         files = os.listdir(self._directory_path)
@@ -45,9 +53,13 @@ class DirectoryMonitor(BaseDirectoryMonitor):
         else:
             logger.info(f"Failed pushing {str(all_files)}")
 
-    def custom_dir_extract(self, dict_path:str ):
+    def custom_csv_extract_only(self, path: str):
-        files = os.listdir(dict_path)
+        self.stop()
-        if files is not None:
+        self._files = [path]
-            all_files = [os.path.join(dict_path, file) for file in files]
+        if path is not None:
-            self._mediator.notify(self, all_files)
+            self._mediator.notify(self, [path])
+    
+    def start_seeking(self) -> None:
+        self._init_state()
+        self.start()
 

src/gui/mainGui.py

@@ -2,6 +2,7 @@ from datetime import datetime as dt
 from typing import Optional
 from PyQt5 import QtWidgets
 from PyQt5.QtCore import Qt
+from PyQt5.QtGui import QPixmap
 
 from utils.base.base import BaseMainWindow, BaseController
 from gui.settings_window import settingsWindow
@@ -12,36 +13,126 @@ class MainWindow(BaseMainWindow):
                  controller: Optional[BaseController] = None) -> None:
         super().__init__()
         self._controller = controller
-        self.initUI()
+        self._init_startUI()
-        self.set_style(self)
-        self.settings_button.clicked.connect(self._show_settings)
-        self.select_dir_button.clicked.connect(self._select_dir)
-        self.report_button.clicked.connect(self._report_window)
-        self.operSettings = settingsWindow("params/operator_params.json", 'Operator', self._updater_trigger)
-        self.sysSettings = settingsWindow("params/system_params.json", 'System', self._updater_trigger)
-        self.repSettings = ReportSettings()
         
-    def initUI(self) -> None:
+
+    def _init_startUI(self) -> None:
+        self.operSettings = settingsWindow("params/operator_params.json", 'Operator', self._transfer_settings)
+        self.sysSettings = settingsWindow("params/system_params.json", 'System', self._transfer_settings)
+        self.repSettings = ReportSettings()
+        self.tabWidget = QtWidgets.QTabWidget()
+
+        self._clear()
+        seeking_mode_btn = QtWidgets.QPushButton("Real time folder scanning")
+        seeking_mode_btn.setFixedWidth(300)
+        seeking_mode_btn.clicked.connect(self._init_seekingUI)
+        raport_mode_btn = QtWidgets.QPushButton("Raport editor")
+        raport_mode_btn.setFixedWidth(300)
+        raport_mode_btn.clicked.connect(self._init_raportUI)
+
+        button_layout = QtWidgets.QHBoxLayout()
+        button_layout.setSpacing(2)
+        button_layout.addWidget(seeking_mode_btn)
+        button_layout.addWidget(raport_mode_btn)
+        button_widget = QtWidgets.QWidget()
+        button_widget.setLayout(button_layout)
+
+        mainLayout = self.layout()
+        label = QtWidgets.QLabel("Select work mode")
+        label.setStyleSheet(
+            """QLabel{
+            color: #ffffff;
+            font-size: 40px;
+            font-weight: bold;
+            font-family: "Segoe UI", sans-serif;
+            }"""
+            )
+        mainLayout.addWidget(label, alignment=Qt.AlignCenter)
+        mainLayout.addWidget(button_widget)
+
+    def _clear(self) -> None:
+        main = self.layout()
+        if self.layout() is not None:
+            while main.count():
+                child = main.takeAt(0)
+                if child.widget() is not None:
+                    child.widget().deleteLater()
+        else: self.setLayout(QtWidgets.QVBoxLayout())
+
+    def _init_seekingUI(self) -> None:
+        self._clear()
+        self._transfer_settings()
         self.tabWidget = QtWidgets.QTabWidget()
         self.tabWidget.setTabsClosable(True)
         self.tabWidget.tabCloseRequested.connect(self._close_tab)
-        layout = QtWidgets.QVBoxLayout()
-        layout.addWidget(self.tabWidget)
 
-        self.settings_button = QtWidgets.QPushButton("Show settings")
+        sys_settings_btn = QtWidgets.QPushButton("System settings")
-        self.settings_button.setFixedWidth(160)
+        sys_settings_btn.setFixedWidth(200)
-        self.select_dir_button = QtWidgets.QPushButton("Open directory")
+        sys_settings_btn.clicked.connect(lambda: self.sysSettings.show())
-        self.select_dir_button.setFixedWidth(175)
+        oper_settings_btn = QtWidgets.QPushButton("Operator settings")
-        self.report_button = QtWidgets.QPushButton("Customize view")
+        oper_settings_btn.setFixedWidth(200)
-        self.report_button.setFixedWidth(185)
+        oper_settings_btn.clicked.connect(lambda: self.operSettings.show())
+
         button_layout = QtWidgets.QHBoxLayout()
         button_layout.setSpacing(2)
-        button_layout.addWidget(self.settings_button)
+        button_layout.addWidget(sys_settings_btn)
-        button_layout.addWidget(self.select_dir_button)
+        button_layout.addWidget(oper_settings_btn)
-        button_layout.addWidget(self.report_button)
+        button_widget = QtWidgets.QWidget()
+        button_widget.setLayout(button_layout)
+
+        title = QtWidgets.QLabel("online mode")
+        mainLayout = self.layout()
+        mainLayout.addWidget(self.tabWidget)
+        mainLayout.addWidget(button_widget)
+        mainLayout.addWidget(title, alignment=Qt.AlignRight)
+        self.resize(800,800)
+        self._controller.seeking_mode()
+        # TODO:push seeking to mediator
+
+    def _init_raportUI(self) -> None:
+        self._clear()
+        self._transfer_settings()
+        path = self._select_csv()
+        if path is None:
+            self.layout().addWidget(QtWidgets.QLabel("Error. Please select correct path to csv"))
+            self._init_startUI()
+            return
+        self._transfer_settings()
+        self.tabWidget = QtWidgets.QTabWidget()
+        self.tabWidget.setTabsClosable(True)
+        self.tabWidget.tabCloseRequested.connect(self._close_tab)
+
+        sys_settings_btn = QtWidgets.QPushButton("System settings")
+        sys_settings_btn.setFixedWidth(185)
+        sys_settings_btn.clicked.connect(lambda: self.sysSettings.show())
+        oper_settings_btn = QtWidgets.QPushButton("Operator settings")
+        oper_settings_btn.setFixedWidth(185)
+        oper_settings_btn.clicked.connect(lambda: self.operSettings.show())
+        view_settings_btn = QtWidgets.QPushButton("Customize view")
+        view_settings_btn.setFixedWidth(185)
+        view_settings_btn.clicked.connect(self._customization_window)
+        save_screen_btn = QtWidgets.QPushButton("Save state")
+        save_screen_btn.setFixedWidth(185)
+        save_screen_btn.clicked.connect(self._save_plots)
+
+        button_layout = QtWidgets.QHBoxLayout()
+        button_layout.setSpacing(2)
+        button_layout.addWidget(sys_settings_btn)
+        button_layout.addWidget(oper_settings_btn)
+        button_layout.addWidget(view_settings_btn)
+        button_layout.addWidget(save_screen_btn)
+        button_widget = QtWidgets.QWidget()
+        button_widget.setLayout(button_layout)
+
+        title = QtWidgets.QLabel("raport mode")
+        mainLayout = self.layout()
+        mainLayout.addWidget(self.tabWidget)
+        mainLayout.addWidget(button_widget)
+        mainLayout.addWidget(title, alignment=Qt.AlignRight)
+        self.resize(800,800)
+        self._controller.raport_mode(path)
+        # TODO: push only one dir to monitor
 
-        layout.addLayout(button_layout)
-        self.setLayout(layout)
 
     def show_plot_tabs(self, plot_widgets: list[QtWidgets.QWidget]) -> None:
         for plot_widget in plot_widgets:
@@ -71,29 +162,35 @@ class MainWindow(BaseMainWindow):
         self.operSettings.show()
         self.sysSettings.show()
 
-    def push_settings(self) -> None:
+    def _transfer_settings(self) -> None:
-        self._updater_trigger()
-
-    def _updater_trigger(self) -> None:
         self.tabWidget.clear()
         operator_params = self.operSettings.getParams()
         system_params = self.sysSettings.getParams()
-        self._controller.push_settings([operator_params, system_params])
+        self._controller.update_settings([operator_params, system_params])
         
     def _close_tab(self, index:int) -> None:
         self.tabWidget.removeTab(index)
     
-    def _select_dir(self):
+    def _select_csv(self) -> Optional[str]:
-        folder_path = QtWidgets.QFileDialog.getExistingDirectory(self, 'Select directory', "")
+        CSV_path, _ = QtWidgets.QFileDialog.getOpenFileName(self,"Select csv file", "", "CSV Files (*.csv)")
-        if folder_path:
+        if CSV_path:
-            self._controller.open_custom_file(folder_path)
+            print(CSV_path)
+            return CSV_path
+        return None
 
-    def _report_window(self) -> None:
+    def _customization_window(self) -> None:
         tab = self.tabWidget.currentWidget()
         reg_items = tab.property("reg_items")
         curve_items = tab.property("curve_items")
         self.repSettings.build(reg_items, curve_items)
 
+    def _save_plots(self) -> None:
+        filepath, _ = QtWidgets.QFileDialog.getSaveFileName(self, "Save file", "", "Image Files (*.png *.jpeg)")
+        tab = self.tabWidget.currentWidget()
+        pixmap = QPixmap(tab.size())
+        tab.render(pixmap)
+        pixmap.save(filepath)
+
         
         
 

src/main.py

@@ -24,10 +24,9 @@ def main():
     window.show()
 
     controller.signal_widgets.connect(window.show_plot_tabs)
-    controller.signal_settings.connect(mediator.push_settings)
+    controller.signal_settings.connect(mediator.update_settings)
-    controller.signal_monitor.connect(monitor.custom_dir_extract)
+    controller.signal_raport_mode.connect(monitor.custom_csv_extract_only)
-
+    controller.signal_seeking_mode.connect(monitor.start_seeking)
-    window.push_settings()
 
     sys.exit(app.exec_())
 

src/utils/base/base.py

@@ -35,7 +35,7 @@ class BaseMediator:
                source: Union[BaseDirectoryMonitor, BaseDataConverter, BasePointPassportFormer, BasePlotWidget],
                data: Union[list[str], list[pd.DataFrame], list[list], list[QWidget]]):
         ...
-    def push_settings (self, data: list[dict]):
+    def update_settings (self, data: list[dict]):
         ...
 
 class BaseDirectoryMonitor:
@@ -47,7 +47,8 @@ class BaseDirectoryMonitor:
         super().__init__()
         self._directory_path = None
         self._update_time = None
-
+        self.isActive = False
+        self._files = None
         self._mediator = mediator
         
 
@@ -76,14 +77,19 @@ class BaseDirectoryMonitor:
         self._files = files
 
     def start(self):
+        self.isActive = True
         self.update_timer.start(int(self._update_time))
 
     def stop(self):
+        self.isActive = False
         self.update_timer.stop()
     
     def update_settings(self, data: list[dict]) -> None:
         ...
 
+    def update_plots(self) -> None:
+        ...
+
     def force_all_dir(self):
         ...
 
@@ -334,12 +340,14 @@ class BaseController(QObject):
     def send_widgets(self, widgets: list[QWidget]) -> None:
         ...
 
-    def push_settings(self, settings: list[dict]) -> None:
+    def update_settings(self, settings: list[dict]) -> None:
         ...
     
-    def open_custom_file (self, filepath: str) -> None:
+    def raport_mode (self, filepath: str) -> None:
         ...
 
+    def  seeking_mode(self) -> None:
+        ...
 
 class BaseIdealDataBuilder(OptAlgorithm):
 
@@ -387,7 +395,8 @@ class BaseMainWindow(QWidget):
     def __init__(self, 
                  controller: Optional[BaseController] = None):
         super().__init__()
-        self.resize(800,800)
+        self.set_style(self)
+        self.resize(200,200)
         self._controller = controller
         ...