#187 - PleaseWait is working & tested in Open File initialization sequence

dmh23 · dmh23 · commit c638381e7504 · 2023-03-06T22:56:05.000Z
diff --git a/src/log/log_meta.py b/src/log/log_meta.py
@@ -13,7 +13,8 @@
 from src.action_space.action import Action
 from src.action_space.action_space import ActionSpace
 from src.log.meta_field import MetaField, MetaFields, Optionality
-from src.main.version import VERSION
+
+LOG_META_VERSION = "4.0.0.DRAFT"
 
 MANDATORY = Optionality.MANDATORY
 OPTIONAL = Optionality.OPTIONAL
@@ -222,7 +223,7 @@ def matches_os_stats(self, stat_result: os.stat_result) -> bool:
         )
 
     def get_as_json(self) -> dict:
-        self.guru_version.set(VERSION)
+        self.guru_version.set(LOG_META_VERSION)
         self._set_meta_fields_based_on_action_space()
         result = MetaFields.create_json(self._fields)
         if not self.action_space.is_continuous():
diff --git a/src/main/version.py b/src/main/version.py
@@ -6,4 +6,4 @@
 # Copyright (c) 2021 dmh23
 #
 
-VERSION = "3.2.16"
+VERSION = "4.0.0.BETA"
diff --git a/src/prototype_ui/log_utils.py b/src/prototype_ui/log_utils.py
@@ -0,0 +1,185 @@
+#
+# DeepRacer Guru
+#
+# Version 3.0 onwards
+#
+# Copyright (c) 2021 dmh23
+#
+
+import os
+
+from log.log_meta import LogMeta, LOG_META_VERSION
+from prototype_ui.please_wait import PleaseWait
+from src.log.log import LOG_FILE_SUFFIX, Log, META_FILE_SUFFIX, CONSOLE_LOG_SUFFIX, make_new_log_meta
+from tracks.track import Track
+
+
+#
+# Public Interface
+#
+
+class OpenFileInfo:
+    def __init__(self, display_name: str, log_meta: LogMeta, source_meta_files: list[str]):
+        self.display_name = display_name
+        self.log_meta = log_meta
+        self.source_files = source_meta_files
+
+
+def get_model_info_for_open_model_dialog(track: Track, log_directory: str, please_wait: PleaseWait) -> (list[OpenFileInfo], int):
+    _refresh_meta(log_directory, please_wait)
+    log_info, excluded_log_count = _get_open_file_model_info(track, log_directory)
+    _add_multi_worker_log_info(log_info)
+    _fix_worker_log_info_duplicates(log_info)
+    _fix_remaining_log_info_duplicates(log_info)
+    return _sorted_log_info(log_info), excluded_log_count
+
+
+def get_world_names_of_existing_logs(log_directory: str, please_wait: PleaseWait):
+    _refresh_meta(log_directory, please_wait)
+    world_names = set()
+    for f in os.listdir(log_directory):
+        if f.endswith(META_FILE_SUFFIX):
+            log = Log(log_directory)
+            log.load_meta(f)
+            world_names.add(log.get_log_meta().track_name.get())
+    return world_names
+
+
+#
+# PRIVATE Implementation Helpers
+#
+
+def _refresh_meta(log_directory: str, please_wait: PleaseWait):
+    _remove_invalid_meta_files(log_directory)
+    logs_without_meta = _get_log_files_without_meta(log_directory)
+    _import_logs_without_meta(logs_without_meta, please_wait, log_directory)
+
+
+def _remove_invalid_meta_files(log_directory: str) -> None:
+    all_files = os.listdir(log_directory)
+    for f in all_files:
+        if f.endswith(META_FILE_SUFFIX):
+            if not _is_log_valid(f, all_files, log_directory):
+                os.remove(os.path.join(log_directory, f))
+
+
+def _is_log_valid(meta_file: str, all_files: list, log_directory: str):
+    log_file = meta_file[:-len(META_FILE_SUFFIX)]
+    if log_file not in all_files:
+        return False
+    try:
+        log = Log(log_directory)
+        log.load_meta(meta_file)
+        return log.get_log_meta().guru_version.get() == LOG_META_VERSION and log.get_log_meta().matches_os_stats(
+            os.stat(os.path.join(log_directory, log_file)))
+    except Exception:  # TODO proper exception class for Guru
+        return False
+
+
+def _get_log_files_without_meta(log_directory: str):
+    log_files = []
+
+    all_files = os.listdir(log_directory)
+    for f in all_files:
+        if f.endswith(LOG_FILE_SUFFIX) or f.endswith(CONSOLE_LOG_SUFFIX):
+            expected_meta = f + META_FILE_SUFFIX
+            if expected_meta not in all_files:
+                log_files.append(f)
+
+    return log_files
+
+
+def _import_logs_without_meta(log_files: list, please_wait: PleaseWait, log_directory: str):
+    please_wait.start("Importing")
+    total_count = len(log_files)
+    for i, f in enumerate(log_files):
+        log = Log(log_directory)
+        try:
+            log.parse(f, please_wait, i / total_count * 100, (i + 1) / total_count * 100)
+            log.save()
+        except Exception as ex:  # TODO - Trapping specific exceptions not working (Python issue?)
+            print("Skipping file <{}> due to processing error <{}>".format(f, ex))
+    please_wait.stop()
+
+
+def _get_open_file_model_info(track: Track, log_directory: str) -> (list[OpenFileInfo], int):
+    excluded_log_count = 0
+    log_info = []
+
+    for f in os.listdir(log_directory):
+        if f.endswith(META_FILE_SUFFIX):
+            log = Log(log_directory)
+            log.load_meta(f)
+            if track.has_world_name(log.get_log_meta().track_name.get()):
+                log_meta = log.get_log_meta()
+                display_name = log_meta.model_name.get()
+                meta_filenames = [f]
+                log_info.append(OpenFileInfo(display_name, log_meta, meta_filenames))
+            else:
+                excluded_log_count += 1
+
+    return log_info, excluded_log_count
+
+
+def _add_multi_worker_log_info(log_info: list[OpenFileInfo]):
+    model_workers = {}
+    for log in log_info:
+        log_meta = log.log_meta
+        if log_meta.workers.get() >= 2:
+            model_name = log_meta.model_name.get()
+            if model_name in model_workers:
+                model_workers[model_name][log_meta.worker_id.get()] = log
+            else:
+                model_workers[model_name] = {log_meta.worker_id.get(): log}
+    for model_name, workers in model_workers.items():
+        keys = list(workers.keys())
+        if len(keys) > 1:
+            source_files = []
+            log_metas = []
+            for i in sorted(keys):
+                source_files.append(workers[i].source_files[0])
+                log_metas.append(workers[i].log_meta)
+            meta_data = make_new_log_meta()
+            meta_data.merge_from_multi_logs(log_metas)
+            log_info.append(OpenFileInfo(model_name + " (multi-worker)", meta_data, source_files))
+
+
+def _fix_worker_log_info_duplicates(log_info: list[OpenFileInfo]):
+    used_names = []
+    duplicate_names = []
+    for log in log_info:
+        if log.display_name in used_names:
+            duplicate_names.append(log.display_name)
+        else:
+            used_names.append(log.display_name)
+    for log in log_info:
+        if log.display_name in duplicate_names and log.log_meta.workers.get() > 1:
+            log.display_name += f" (worker {log.log_meta.worker_id.get() + 1} / {log.log_meta.workers.get()})"
+
+
+def _fix_remaining_log_info_duplicates(log_info: list[OpenFileInfo]):
+    used_names = []
+    for log in log_info:
+        old_name = log.display_name
+        new_name = old_name
+        i = 1
+        while new_name in used_names:
+            new_name = f"{old_name} ({i})"
+            i += 1
+        log.display_name = new_name
+        used_names.append(new_name)
+
+
+def _sorted_log_info(log_info: list[OpenFileInfo]):
+    all_names = []
+    indexed_logs = {}
+
+    for log in log_info:
+        all_names.append(log.display_name)
+        indexed_logs[log.display_name] = log
+
+    result = []
+    for name in sorted(all_names):
+        result.append(indexed_logs[name])
+
+    return result
diff --git a/src/prototype_ui/main.py b/src/prototype_ui/main.py
@@ -6,6 +6,8 @@
 from configuration.config_manager import ConfigManager
 from prototype_ui.actions import Actions
 from prototype_ui.menubar import MenuBarManager
+from prototype_ui.open_file_dialog import OpenFileDialog
+from prototype_ui.please_wait import PleaseWait
 from prototype_ui.toolbar import ToolBarManager
 from prototype_ui.track_analysis_canvas import TrackAnalysisCanvas, FilledCircle, TrackArea, Line
 from prototype_ui.tracks_v4 import get_all_tracks
@@ -26,12 +28,7 @@ def __init__(self):
         self.setWindowTitle("Example")
 
         # Status Bar
-        self._status_bar_label = QLabel("Hello Status Bar")
-        self._status_bar_progress = QProgressBar()
-        self._status_bar_progress.setRange(0, 10)
-        self._status_bar_progress.setValue(7)
-        self.statusBar().addPermanentWidget(self._status_bar_label)
-        self.statusBar().addPermanentWidget(self._status_bar_progress)
+        self._please_wait = PleaseWait(self.statusBar(), self.set_busy_cursor, self.set_normal_cursor)
 
         # Define UI actions
         self._actions = Actions(self.style())
@@ -47,24 +44,45 @@ def __init__(self):
 
         self.canvas = TrackAnalysisCanvas()
         self.setCentralWidget(self.canvas)
+        self.make_status_bar_tall_enough_to_contain_progress_bar()
 
         self.show()
 
         # Initialise tracks & draw here temporarily to prove everything works or not
 
         self._tracks = get_all_tracks()
-        track = self._tracks["reinvent_base"]
-        track.configure_track_canvas(self.canvas)
+        self._current_track = self._tracks["reinvent_base"]
+        self._current_track.configure_track_canvas(self.canvas)
         # self.canvas.set_track_area(TrackArea(0, 0, 10, 10))
-        track.draw_track_edges(self.canvas, Qt.GlobalColor.red)
-        track.draw_waypoints(self.canvas, Qt.GlobalColor.blue, 2, 5)
+        self._current_track.draw_track_edges(self.canvas, Qt.GlobalColor.red)
+        self._current_track.draw_waypoints(self.canvas, Qt.GlobalColor.blue, 2, 5)
+
+    def set_busy_cursor(self):
+        self.setCursor(Qt.CursorShape.WaitCursor)
+        self.repaint()
+
+    def set_normal_cursor(self):
+        self.setCursor(Qt.CursorShape.ArrowCursor)
+        self.repaint()
+
+    def make_status_bar_tall_enough_to_contain_progress_bar(self):
+        dummy_sizing_progress_bar = QProgressBar()
+        self.statusBar().addPermanentWidget(dummy_sizing_progress_bar)
+        h = self.statusBar().geometry().height()
+        self.statusBar().removeWidget(dummy_sizing_progress_bar)
+        self.statusBar().setMinimumHeight(h)
 
     def _new_file(self):
         print("New File")
         self.statusBar().showMessage("Hello Briefly", 5000)    # 5 secs
 
     def _open_file(self):
-        self.canvas.setCursor(Qt.CursorShape.CrossCursor)
+        # self.canvas.setCursor(Qt.CursorShape.CrossCursor)
+        dlg = OpenFileDialog(self, self._please_wait, self._current_track, self._config_manager.get_log_directory())
+        if dlg.exec():
+            print("Success!")
+        else:
+            print("Cancel!")
 
     def _change_directory(self):
         new_directory = QFileDialog.getExistingDirectory(self, self._actions.change_directory.statusTip(), self._config_manager.get_log_directory())
diff --git a/src/prototype_ui/open_file_dialog.py b/src/prototype_ui/open_file_dialog.py
@@ -0,0 +1,40 @@
+from PyQt6.QtWidgets import QDialog, QDialogButtonBox, QVBoxLayout, QLabel, QMainWindow, QTableWidget, QGridLayout
+
+from prototype_ui.log_utils import get_model_info_for_open_model_dialog
+from prototype_ui.please_wait import PleaseWait
+from prototype_ui.track_v4 import Track
+
+
+
+class OpenFileDialog(QDialog):
+    def __init__(self, parent: QMainWindow, please_wait: PleaseWait, current_track: Track, log_directory: str):
+        super().__init__(parent)
+
+        log_info, hidden_log_count = get_model_info_for_open_model_dialog(current_track, log_directory, please_wait)
+
+        self.layout = QGridLayout()
+
+        for i, title in enumerate(["One", "Two", "Three", "Four"]):
+            self.layout.addWidget(QLabel(title), 0, i)
+        for i in range(1, 3):
+            self.layout.addWidget(QLabel("Hello" + str(i)), i, 2)
+
+
+
+
+
+
+        self.setWindowTitle("HELLO!")
+
+        QBtn = QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel
+
+        self.buttonBox = QDialogButtonBox(QBtn)
+        self.buttonBox.accepted.connect(self.accept)
+        self.buttonBox.rejected.connect(self.reject)
+
+
+        message = QLabel("Something happened, is that OK?")
+        #self.layout.addLayout(grid)
+        self.layout.addWidget(message)
+        self.layout.addWidget(self.buttonBox)
+        self.setLayout(self.layout)
diff --git a/src/prototype_ui/please_wait.py b/src/prototype_ui/please_wait.py
@@ -0,0 +1,60 @@
+#
+# DeepRacer Guru
+#
+# Version 3.0 onwards
+#
+# Copyright (c) 2021 dmh23
+#
+
+import time
+
+from PyQt6.QtCore import Qt
+from PyQt6.QtWidgets import QStatusBar, QLabel, QProgressBar
+
+NEARLY_COMPLETE = 99.99
+REDRAW_INTERVAL = 0.15
+SMALL_JUMP = 2
+BIG_JUMP = 25
+
+
+class PleaseWait:
+    def __init__(self, status_bar: QStatusBar, set_busy_cursor_method: callable, set_normal_cursor_method: callable):
+        self._percent_done = 0
+        self._status_bar = status_bar
+        self._set_busy_cursor_method = set_busy_cursor_method
+        self._set_normal_cursor_method = set_normal_cursor_method
+        self._progress_bar = QProgressBar()
+        self._progress_bar.setRange(0, 100)
+        self._label_widget = QLabel()
+
+    def start(self, title):
+        self._set_busy_cursor_method()
+
+        self._percent_done = 0
+
+        self._label_widget = QLabel(title)
+        self._progress_bar.setValue(0)
+
+        self._status_bar.addWidget(self._label_widget)
+        self._status_bar.addWidget(self._progress_bar)
+        self._progress_bar.show()
+        self._label_widget.show()
+        self._status_bar.clearMessage()
+
+        self._status_bar.repaint()
+
+    def stop(self, pause_seconds=0):
+        time.sleep(pause_seconds)
+        self._status_bar.removeWidget(self._label_widget)
+        self._status_bar.removeWidget(self._progress_bar)
+        self._status_bar.repaint()
+        self._set_normal_cursor_method()
+
+    def set_progress(self, percent_done: int | float):
+        percent_done = min(100, max(0, round(percent_done)))
+
+        if percent_done > self._percent_done:
+            self._percent_done = percent_done
+            self._progress_bar.setValue(percent_done)
+            self._status_bar.repaint()
+

Original file line number	Diff line number	Diff line change
`@@ -6,4 +6,4 @@`
`6`	`6`	`# Copyright (c) 2021 dmh23`
`7`	`7`	`#`
`8`	`8`
`9`		`-VERSION = "3.2.16"`
	`9`	`+VERSION = "4.0.0.BETA"`