App: implement managing multiple projects (#107)

ultratrace2/app.py

@@ -15,10 +15,10 @@ def __init__(self, args):  # FIXME: be more granular here
         else:
             path = args.path
 
-        self.project = Project(path)
+        self.project: Project = Project.get_by_path(path)
         self.gui = GUI(theme=args.theme)
 
-    def main(self):
+    def main(self) -> None:
         pass
 
 

ultratrace2/model/files/bundle.py

@@ -1,7 +1,7 @@
 import logging
 import os
 
-from typing import Dict, List, Set
+from typing import Dict, Sequence, Set
 
 from .impls import Sound, Alignment, ImageSet
 
@@ -41,30 +41,43 @@ class FileBundleList:
             ".git",
             "node_modules",
             "__pycache__",
+            ".ultratrace",
             # FIXME: add more ignoreable dirs
         ]
     )
 
-    def __init__(self, path: str, extra_exclude_dirs: List[str] = []):
+    def __init__(self, bundles: Dict[str, FileBundle]):
 
-        # FIXME: implement `extra_exclude_dirs` as a command-line arg
-        for extra_exclude_dir in extra_exclude_dirs:
-            self.exclude_dirs.add(extra_exclude_dir)
+        self.current_bundle = None
+        self.bundles: Dict[str, FileBundle] = bundles
 
-        self.path = path
-        self.has_alignment_impl = False
-        self.has_image_impl = False
-        self.has_sound_impl = False
+        self.has_alignment_impl: bool = False
+        self.has_image_impl: bool = False
+        self.has_sound_impl: bool = False
 
-        self.current_bundle = None
+        for filename, bundle in bundles.items():
+            if not self.has_alignment_impl and bundle.alignment_file.has_impl():
+                self.has_alignment_impl = True
+            if not self.has_image_impl and bundle.image_file.has_impl():
+                self.has_image_impl = True
+            if not self.has_sound_impl and bundle.sound_file.has_impl():
+                self.has_sound_impl = True
+
+    @classmethod
+    def build_from_dir(
+        cls, root_path: str, extra_exclude_dirs: Sequence[str] = []
+    ) -> "FileBundleList":
+
+        # FIXME: implement `extra_exclude_dirs` as a command-line arg
+        exclude_dirs = cls.exclude_dirs.copy().union(extra_exclude_dirs)
 
         bundles: Dict[str, FileBundle] = {}
 
         # NB: `topdown=True` increases runtime cost from O(n) -> O(n^2), but it allows us to
         #     modify `dirs` in-place so that we can skip certain directories.  For more info,
         #     see https://stackoverflow.com/questions/19859840/excluding-directories-in-os-walk
-        for path, dirs, filenames in os.walk(path, topdown=True):
-            dirs[:] = [d for d in dirs if d not in self.exclude_dirs]
+        for path, dirs, filenames in os.walk(root_path, topdown=True):
+            dirs[:] = [d for d in dirs if d not in exclude_dirs]
 
             for filename in filenames:
 
@@ -83,12 +96,4 @@ def __init__(self, path: str, extra_exclude_dirs: List[str] = []):
                 if not bundles[name].interpret(filepath):
                     logger.warning(f"unrecognized filetype: {filepath}")
 
-        # FIXME: do this when we add to our data structure
-        for filename, bundle in bundles.items():
-            # build up self.bundles here
-            if not self.has_alignment_impl and bundle.alignment_file.has_impl():
-                self.has_alignment_impl = True
-            if not self.has_image_impl and bundle.image_file.has_impl():
-                self.has_image_impl = True
-            if not self.has_sound_impl and bundle.sound_file.has_impl():
-                self.has_sound_impl = True
+        return FileBundleList(bundles)

ultratrace2/model/files/impls/image.py

@@ -54,7 +54,7 @@ def load(self) -> None:
                     "Invalid DICOM ({self.path}), unknown shape {pixels.shape}"
                 )
 
-            os.mkdir(self.png_path)
+            os.mkdir(self.png_path, mode=0o755)
             for i in tqdm(range(frames), desc="converting to PNG"):
                 filename = os.path.join(self.png_path, f"{i:06}.png")
                 arr = pixels[i, :, :] if is_greyscale else pixels[i, :, :, :]

ultratrace2/model/project.py

@@ -1,23 +1,68 @@
+import logging
 import os
+import pickle
 
 from .trace import TraceList
 from .files.bundle import FileBundleList
 
+logger = logging.getLogger(__name__)
+
 
 class Project:
-    def __init__(self, path: str):
-        if not os.path.exists(path):
-            raise ValueError(f"cannot initialize project at {path}")
-        self.root_path = os.path.realpath(os.path.abspath(path))  # absolute path
-        self.traces = TraceList()
-        self.files = FileBundleList(self.root_path)
+    def __init__(self, traces: TraceList, files: FileBundleList):
+        """
+        Internal function: to construct a Project, either call ::get_by_path()
+        """
+        self.traces = traces
+        self.files = files
 
     def save(self):
         raise NotImplementedError()
 
     @classmethod
-    def load(cls):
-        raise NotImplementedError()
+    def load(cls, save_file) -> "Project":
+        try:
+            with open(save_file, "rb") as fp:
+                project = pickle.load(fp)
+                assert isinstance(project, Project)
+                return project
+        except Exception as e:
+            logger.error(e)
+            raise RuntimeError(str(e))
+
+    @classmethod
+    def get_by_path(cls, root_path) -> "Project":
+
+        root_path = os.path.realpath(os.path.abspath(root_path))  # absolute path
+        if not os.path.exists(root_path) or not os.path.isdir(root_path):
+            raise ValueError(
+                f"cannot initialize project at {root_path}: not a directory"
+            )
+
+        save_dir = Project.get_save_dir(root_path)
+        if not os.path.exists(save_dir):
+            os.mkdir(save_dir, mode=0o755)
+
+        save_file = Project.get_save_file(root_path)
+        try:
+            return Project.load(save_file)
+        except RuntimeError:
+            logger.info(
+                f"Unable to find existing project at {root_path}, creating new one..."
+            )
+
+        traces = TraceList()
+        file_bundles = FileBundleList.build_from_dir(root_path)
+        return Project(traces, file_bundles)
+
+    @staticmethod
+    def get_save_dir(path: str) -> str:
+        return os.path.join(path, ".ultratrace")
+
+    @staticmethod
+    def get_save_file(path: str) -> str:
+        save_dir = Project.get_save_dir(path)
+        return os.path.join(save_dir, "project.pkl")
 
     def filepath(self):
         raise NotImplementedError()