refactor: improve logic and logging

Author: add-n2x

src/ndtoolbox/app.py

@@ -448,6 +448,7 @@ def is_keepable(self, this: MediaFile, that: MediaFile) -> MediaFile:
 
         """
         PU.note(f"Compare {SU.gray(this.path)} <=> {SU.gray(that.path)}", 0)
+        PU.note(f"This folder: {SU.gray(this.folder)}, That folder: {SU.gray(that.folder)}")
 
         # Real album folder files are keepable over files in root, artist or dump folders
         left: Folder = this.folder
@@ -456,23 +457,31 @@ def is_keepable(self, this: MediaFile, that: MediaFile) -> MediaFile:
             PU.log(f"Compare if file is in album folder: {left.type} || {right.type}", 1)
             if left.type != right.type:
                 if left.type == Folder.Type.ALBUM:
-                    PU.log(f"This is an album folder: {SU.gray(this.folder.beets_path)}", 2)
+                    msg = f"Other is an album folder: {SU.gray(this.folder.beets_path)}"
+                    PU.log(msg, 2)
+                    that.delete_reason = msg
                     return this
                 elif right.type == Folder.Type.ALBUM:
-                    PU.log(f"That is an album folder: {SU.gray(that.folder.beets_path)}", 2)
+                    msg = f"Other is an album folder: {SU.gray(that.folder.beets_path)}"
+                    PU.log(msg, 2)
+                    this.delete_reason = msg
                     return that
         # Skip if both are of the same path and type
 
         # Check for dirty folders
         left = this.folder.is_dirty
         right = that.folder.is_dirty
         PU.log(f"Compare dirty folders: {left} || {right}", 1)
-        if left and (left > 0) or right and (right > 0):
-            if left < right:
-                PU.log(f"This folder is dirty: {SU.gray(this.folder.beets_path)}", 2)
+        if left != right:
+            if left:
+                msg = f"This folder is dirty: {SU.gray(this.folder.beets_path)}"
+                PU.log(msg, 2)
+                this.delete_reason = msg
                 return that
-            elif left > right:
-                PU.log(f"That folder is dirty: {SU.gray(that.folder.beets_path)}", 2)
+            elif right:
+                msg = f"That folder is dirty: {SU.gray(that.folder.beets_path)}"
+                PU.log(msg, 2)
+                that.delete_reason = msg
                 return this
         # Skip if both are incomplete
 
@@ -482,23 +491,29 @@ def is_keepable(self, this: MediaFile, that: MediaFile) -> MediaFile:
         if left.missing is not None and right.missing is not None:
             PU.log(f"Compare missing tracks: {left.missing}/{left.total} || {right.missing}/{right.total}", 1)
             if (left.missing != right.missing) and (left.missing > 0 or right.missing > 0):
-                if left.missing < right.missing:
-                    PU.log(f"This folder is more complete ({left.missing}/{left.total}): {SU.gray(this.path)}", 2)
+                if (left.missing < right.missing) and not left.is_dirty:
+                    msg = f"Other folder is more complete ({left.missing}/{left.total}): {SU.gray(this.path)}"
+                    PU.log(msg, 2)
+                    that.delete_reason = msg
                     return this
-                elif left.missing > right.missing:
-                    PU.log(f"That folder is more complete ({right.missing}/{right.total}): {SU.gray(that.path)}", 2)
+                elif (left.missing > right.missing) and not right.is_dirty:
+                    msg = f"Other folder is more complete ({right.missing}/{right.total}): {SU.gray(that.path)}"
+                    PU.log(msg, 2)
+                    this.delete_reason = msg
                     return that
         # Skip if both are incomplete, none has missing tracks or have no information on missing tracks
 
-        # If the album folder already contains a keepable, we wanna keep all the items
+        # If the album folder already contains a keepable, we wanna keep all the items, except for dirty folders
         left = this.folder and this.folder.has_keepable
+        l_dirty = this.folder and this.folder.is_dirty
         right = that.folder and that.folder.has_keepable
-        PU.log(f"Compare if album folder contain a keepable: {left} || {right}", 1)
+        r_dirty = that.folder and that.folder.is_dirty
+        PU.log(f"Compare if album folder contain a keepable: {left} +dirty: {l_dirty}  || {right} +dirty: {r_dirty}", 1)
         if left != right:
-            if left:
+            if left and not l_dirty:
                 that.delete_reason = f"Other album folder already contains a keepable | {SU.gray(this.path)}"
                 return this
-            elif right:
+            elif right and not r_dirty:
                 this.delete_reason = f"Other album folder already contains a keepable | {SU.gray(that.path)}"
                 return that
         # Skip, if they are the same
@@ -652,6 +667,8 @@ def is_keepable(self, this: MediaFile, that: MediaFile) -> MediaFile:
         sys.exit(1)
 
     processor = DuplicateProcessor(config)
+    # client = BeetsClient(config)
+    # print("BEETS CLIENT: " + client._query1())
 
     if action == "remove-unsupported":
         FileTools.move_by_extension(config.music_dir, config.data_dir, config.remove_extensions, ToolboxConfig.dry_run)

src/ndtoolbox/model.py

@@ -260,12 +260,7 @@ def __init__(self, media: MediaFile):
             PU.warning(f"Found unknown folder type for {self.beets_path}")
 
         # For performance reasons, we don't load album info for all folders
-        if (
-            not self.is_dirty
-            and not self.beets_album
-            and not self.type == Folder.Type.ROOT
-            and not self.type == Folder.Type.ARTIST
-        ):
+        if not self.is_dirty and not self.beets_album and not self.type == Folder.Type.ROOT:
             self._load_album_info()
 
         # Check if folder is dirty
@@ -288,22 +283,25 @@ def _load_album_info(self) -> None:
 
         if not infos:
             # TODO Clarify how to handle this case
+            # self.is_dirty = True
+            self.type = Folder.Type.UNKNOWN
             PU.warning(f"Got no album info for {self.beets_path} > clarify handling")
-            self.is_dirty = True
-        if len(infos) > 1:
+        elif len(infos) > 1:
             # Folder contains files form multiples albums. So this is either a dump folder
             # or amanually made compilation/mixtape.
             self.is_dirty = True
+            self.type = Folder.Type.UNKNOWN
             PU.warning(f"Found self-made compilation, mixtape or dump folder: '{self.beets_path}'")
         elif len(infos) == 1:
             self.beets_album = infos[0].album
             self.total = infos[0].total
             self.missing = infos[0].missing
             self.is_compilation = infos[0].compilation
+            self.type = Folder.Type.ALBUM
 
-    def map_media_to_file(self, media: MediaFile):
-        """Map a media file to an existing file in the album folder."""
-        self.files[FileUtil.get_file(media.path)] = media
+    # def map_media_to_file(self, media: MediaFile):
+    #     """Map a media file to an existing file in the album folder."""
+    #     self.files[FileUtil.get_file(media.path)] = media
 
     def __repr__(self) -> str:
         """String representation of the Folder object."""