fixed datamanager saving into desktop location and school folders

Author: matthaeusheer

config.py

@@ -44,7 +44,8 @@
         'draw_area_height_cm':      14
     },
     'data': {
-        'overwrite_output':         False
+        'overwrite_output':         False,
+        'output_location':          'desktop'  # can be either 'desktop' or 'repository'
     }
 }
 

planvec/common.py

@@ -2,5 +2,6 @@
 from pathlib import Path
 
 PROJECT_ROOT_PATH = os.path.dirname(os.path.dirname(__file__))
-DATA_DIR_PATH = os.path.join(PROJECT_ROOT_PATH, 'data')
+DATA_REPOSITORY_DIR_PATH = os.path.join(PROJECT_ROOT_PATH, 'data')
+DATA_DESKTOP_DIR_PATH = Path.home() / 'Desktop' / 'planvec'
 UI_GENERATED_PATH = Path(PROJECT_ROOT_PATH) / 'planvec/gui/ui_generated'

planvec/gui/datamanager.py

@@ -1,8 +1,10 @@
 import os
+from pathlib import Path
 from PyQt5.QtGui import QImage
 import matplotlib.pyplot as plt
 
-from planvec.common import DATA_DIR_PATH
+from planvec.common import DATA_REPOSITORY_DIR_PATH
+from planvec.common import DATA_DESKTOP_DIR_PATH
 from planvec.utils import date_utils
 
 from typing import List
@@ -13,75 +15,88 @@
 
 
 class DataManager:
-    def __init__(self, date_tag: str = date_utils.get_date_tag()):
+    def __init__(self, output_location: str, date_tag: str = date_utils.get_date_tag()):
         self.date_tag = date_tag
-        self.out_dir_path = os.path.join(DATA_DIR_PATH, date_tag)
+        self.out_dir_path = str(self.output_root_dir_path_from_output_location(output_location) / date_tag)
         self.try_create_date_output_folder()
 
+    @staticmethod
+    def output_root_dir_path_from_output_location(output_location: str) -> Path:
+        if output_location == 'desktop':
+            return DATA_DESKTOP_DIR_PATH
+        elif output_location == 'repository':
+            return DATA_REPOSITORY_DIR_PATH
+        else:
+            raise ValueError(f'output_location {output_location} not supported.')
+
     def try_create_date_output_folder(self) -> None:
         if not os.path.exists(self.out_dir_path):
             os.makedirs(self.out_dir_path)
 
-    def team_dir_exists(self, team_name: str) -> bool:
+    def team_dir_exists(self, school_name: str, team_name: str) -> bool:
         assert os.path.exists(self.out_dir_path), 'Output folder for this \
                                                    date does not exist.'
 
-        return os.path.exists(os.path.join(self.out_dir_path, team_name))
+        return os.path.exists(os.path.join(self.out_dir_path, school_name, team_name))
 
-    def create_team_folder(self, team_name: str) -> None:
-        if not self.team_dir_exists(team_name):
-            os.makedirs(os.path.join(self.out_dir_path, team_name))
+    def create_team_folder(self, school_name, team_name: str) -> None:
+        if not self.team_dir_exists(school_name, team_name):
+            os.makedirs(os.path.join(self.out_dir_path, school_name, team_name))
 
-    def _create_save_img_path(self, team_name: str, file_type: str, suffix: str = '', idx: int = None) -> str:
-        assert self.team_dir_exists(team_name), 'Cannot save. Team directory ' \
-                                                'does not exist.'
+    def _create_save_img_path(self, school_name: str, team_name: str, file_type: str, suffix: str = '',
+                              idx: int = None) -> str:
+        assert self.team_dir_exists(school_name, team_name), 'Cannot save. Team directory ' \
+                                                             'does not exist.'
         if idx is None:
-            idx = self.get_next_team_img_idx(team_name)
+            idx = self.get_next_team_img_idx(school_name, team_name)
         img_name = IMG_NAME_FORMAT.format(idx=idx,
                                           team=team_name,
                                           date_tag=date_utils.get_date_time_tag(),
                                           suffix=suffix,
                                           file_type=file_type)
-        team_dir = os.path.join(self.out_dir_path, team_name)
+        team_dir = os.path.join(self.out_dir_path, school_name, team_name)
         return os.path.join(team_dir, img_name)
 
-    def save_qt_image(self, team_name: str, qt_img: QImage, suffix: str = '', idx: int = None) -> None:
-        file_path = self._create_save_img_path(team_name, 'jpeg', suffix, idx)
+    def save_qt_image(self, school_name: str, team_name: str, qt_img: QImage, suffix: str = '', idx: int = None) -> None:
+        file_path = self._create_save_img_path(school_name, team_name, 'jpeg', suffix, idx)
         qt_img.save(file_path)
 
-    def save_pdf(self, team_name: str, fig: plt.Figure, suffix: str = '', idx: int = None) -> None:
-        file_path = self._create_save_img_path(team_name, 'pdf', suffix, idx)
+    def save_pdf(self, school_name: str, team_name: str, fig: plt.Figure, suffix: str = '', idx: int = None) -> None:
+        file_path = self._create_save_img_path(school_name, team_name, 'pdf', suffix, idx)
         save_output_fig(fig, file_path)
 
-    def load_team_output_file_names(self, team_name: str, endswith: str) -> List[str]:
+    def load_team_output_file_names(self, school_name, team_name: str, endswith: str) -> List[str]:
         """Load all the output file names of a team, e.g. .jpeg or .pdf files."""
-        if self.team_dir_exists(team_name):
-            all_files = os.listdir(os.path.join(self.out_dir_path, team_name))
+        if self.team_dir_exists(school_name, team_name):
+            all_files = os.listdir(os.path.join(self.out_dir_path, school_name, team_name))
             return [f for f in all_files if f.endswith(endswith)]
         else:
             return []
 
-    def get_next_team_img_idx(self, team_name: str) -> int:
-        team_img_names = self.load_team_output_file_names(team_name, endswith='jpeg')
+    def get_next_team_img_idx(self, school_name, team_name: str) -> int:
+        team_img_names = self.load_team_output_file_names(school_name, team_name, endswith='jpeg')
         img_indices = sorted([int(name.split('_')[0]) for name in team_img_names])
         if len(img_indices) == 0:
             return 0
         return img_indices[-1] + 1
 
-    def load_all_team_names(self) -> List[str]:
-        items = os.listdir(self.out_dir_path)
-        return [item for item in items
-                if os.path.isdir(os.path.join(self.out_dir_path, item))]
+    def load_all_team_names(self, school_name: str) -> List[str]:
+        if os.path.exists(os.path.join(self.out_dir_path, school_name)):
+            items = os.listdir(os.path.join(self.out_dir_path, school_name))
+            return [item for item in items
+                    if os.path.isdir(os.path.join(self.out_dir_path, school_name, item))]
+        else:
+            return []
 
-    def delete_all_team_images_and_pdfs(self, team_name: str):
+    def delete_all_team_images_and_pdfs(self, school_name, team_name: str):
         """Caution: This method deletes all output images stored for a team."""
-        team_img_names = self.load_team_output_file_names(team_name, endswith='jpeg')
-        team_pdf_names = self.load_team_output_file_names(team_name, endswith='pdf')
+        team_img_names = self.load_team_output_file_names(school_name, team_name, endswith='jpeg')
+        team_pdf_names = self.load_team_output_file_names(school_name, team_name, endswith='pdf')
         for file_name in team_img_names + team_pdf_names:
-            os.remove(os.path.join(os.path.join(self.out_dir_path, team_name, file_name)))
+            os.remove(os.path.join(os.path.join(self.out_dir_path, school_name, team_name, file_name)))
 
 
-def save_output_fig(out_fig, path=os.path.join(DATA_DIR_PATH, 'default_out_name.pdf')):
+def save_output_fig(out_fig, path=os.path.join(DATA_REPOSITORY_DIR_PATH, 'default_out_name.pdf')):
     """Stores the output figure of the GUI processing without padding such that
     the resulting size on paper equals the size of the drawing canvas."""
     out_fig.tight_layout(pad=0)

planvec/gui/invalid_school_team_msg_box.py

@@ -14,19 +14,8 @@ def __init__(self, data_manager: DataManager, school_name: str, team_name: str,
 
     def setup(self):
         self.setIcon(QMessageBox.Critical)
-        self.setText("Bitte nicht-leere Schul- und Teamnamen eingeben!")
+        self.setText("Bitte Schul- und Team-namen eingeben!")
         self.setWindowTitle("Fehler")
-        team_names = self.data_manager.load_all_team_names()
-        team_names_str = 'Folgende Gruppen existieren bereits:'
-        for team in team_names:
-            # n_images = len(self.data_manager.load_team_img_names(team))
-            team_names_str += f'\n    {team}'
-        info_label = QLabel(team_names_str)
-        team_layout = QStackedLayout()
-        team_layout.addWidget(info_label)
-
-        self.layout().addLayout(team_layout, 1, 0, QtCore.Qt.AlignCenter | QtCore.Qt.AlignTop)
-
         self.setStandardButtons(QMessageBox.Ok)
 
     def execute(self):

planvec/gui/planvec_gui.py

@@ -41,7 +41,7 @@ def __init__(self, ui: Ui_planvec, main_window: QMainWindow, gui_config: DotMap)
         self.ui.openGLWidget.setLayout(video_raw_layout)
 
         self.ui.nameSaveButton.clicked.connect(self.save_img_dialog)
-        self.data_manager = DataManager()
+        self.data_manager = DataManager(output_location=self.config.data.output_location)
         self.overwrite_output = False
         self.ui.outputWriteRadio.clicked.connect(self._toggle_overwrite_output)
 
@@ -140,16 +140,17 @@ def save_img_btn(self, button_return):
         curr_out_fig = self.proc_stream_thread.get_curr_out_fig()
         if button_return.text() == '&OK':
             team_name = self.ui.teamName.text()
-            if not self.data_manager.team_dir_exists(team_name):
-                team_dir_dialog = TeamDirDialog(team_name, self.data_manager)
+            school_name = self.ui.schoolName.text()
+            if not self.data_manager.team_dir_exists(school_name, team_name):
+                team_dir_dialog = TeamDirDialog(school_name, team_name, self.data_manager)
                 team_dir_dialog.execute()
-            if self.data_manager.team_dir_exists(team_name):  # dir created
+            if self.data_manager.team_dir_exists(school_name, team_name):  # dir created
                 if self.overwrite_output:
-                    self.data_manager.delete_all_team_images_and_pdfs(team_name)
-                img_idx = self.data_manager.get_next_team_img_idx(team_name)
-                self.data_manager.save_qt_image(team_name, curr_qt_img_in, '_original', idx=img_idx)
-                self.data_manager.save_qt_image(team_name, curr_qt_img_out, '_output', idx=img_idx)
-                self.data_manager.save_pdf(team_name, curr_out_fig, '_output', idx=img_idx)
+                    self.data_manager.delete_all_team_images_and_pdfs(school_name, team_name)
+                img_idx = self.data_manager.get_next_team_img_idx(school_name, team_name)
+                self.data_manager.save_qt_image(school_name, team_name, curr_qt_img_in, '_original', idx=img_idx)
+                self.data_manager.save_qt_image(school_name, team_name, curr_qt_img_out, '_output', idx=img_idx)
+                self.data_manager.save_pdf(school_name, team_name, curr_out_fig, '_output', idx=img_idx)
                 save_msg_box = QMessageBox()
                 save_msg_box.setText(f'Bilder gespeichert für Gruppe: {team_name}')
                 save_msg_box.exec_()

planvec/gui/save_msg_box.py

@@ -24,8 +24,8 @@ def setup(self) -> None:
 
         self.setText("Bild wirklich speichern?")
         self.setInformativeText(f"Schulname: {self.school_name} \nTeamname: {self.team_name}")
-        team_names = self.data_manager.load_all_team_names()
-        team_names_str = 'Folgende Gruppen existieren bereits:'
+        team_names = self.data_manager.load_all_team_names(self.school_name)
+        team_names_str = f'Folgende Gruppen existieren bereits für {self.school_name}:'
         if len(team_names) == 0:
             team_names_str = 'Es existieren noch keine Gruppen.'
         for team in team_names:

planvec/gui/team_dir_dialog.py

@@ -4,8 +4,9 @@
 
 
 class TeamDirDialog(QMessageBox):
-    def __init__(self, team_name: str, data_manager: DataManager, parent=None) -> None:
+    def __init__(self, school_name: str, team_name: str, data_manager: DataManager, parent=None) -> None:
         super(TeamDirDialog, self).__init__(parent)
+        self.school_name = school_name
         self.team_name = team_name
         self.data_manager = data_manager
         self.setup()
@@ -23,4 +24,4 @@ def execute(self):
 
     def ok_btn_slot(self, button_return):
         if button_return.text() == '&OK':
-            self.data_manager.create_team_folder(self.team_name)
+            self.data_manager.create_team_folder(self.school_name, self.team_name)

scripts/pdf_jammer.py

@@ -13,7 +13,7 @@
 from context import planvec
 from planvec.gui.datamanager import DataManager
 from planvec.pdf import PdfJammer
-from planvec.common import DATA_DIR_PATH
+from planvec.common import DATA_REPOSITORY_DIR_PATH
 
 
 def parse_arguments():
@@ -34,7 +34,7 @@ def main(parsed_args):
     data_manager = DataManager(parsed_args.date_tag)
     pdf_jammer = PdfJammer(data_manager=data_manager,
                            out_dir=parsed_args.out_dir if parsed_args.out_dir
-                           else os.path.join(DATA_DIR_PATH, parsed_args.date_tag))
+                           else os.path.join(DATA_REPOSITORY_DIR_PATH, parsed_args.date_tag))
     pdfs_dict = pdf_jammer.accumulate_pdf_paths()
     pdf_paths_list = pdf_jammer.teams_pdfs_paths_to_list(pdfs_dict)
     pdf_jammer.run(pdf_paths_list)