codex 1.4.0a0__py3-none-any.whl → 1.4.1__py3-none-any.whl

codex/librarian/importer/moved.py

@@ -4,20 +4,23 @@ from pathlib import Path
 from django.db.models.functions import Now
 
 from codex.librarian.importer.create_comics import CreateComicsMixin
-from codex.librarian.importer.create_fks import CreateForeignKeysMixin
+from codex.librarian.importer.create_fks import (
+    BULK_UPDATE_FOLDER_MODIFIED_FIELDS,
+    CreateForeignKeysMixin,
+)
 from codex.librarian.importer.query_fks import QueryForeignKeysMixin
 from codex.librarian.importer.status import ImportStatusTypes, status_notify
 from codex.models import Comic, Folder, Library
 
-MOVED_BULK_COMIC_UPDATE_FIELDS = ("path", "parent_folder")
-MOVED_BULK_FOLDER_UPDATE_FIELDS = ("path", "parent_folder", "name")
+_MOVED_BULK_COMIC_UPDATE_FIELDS = ("path", "parent_folder")
+_MOVED_BULK_FOLDER_UPDATE_FIELDS = ("path", "parent_folder", "name")
 
 
 class MovedMixin(CreateComicsMixin, CreateForeignKeysMixin, QueryForeignKeysMixin):
     """Methods for moving comics and folders."""
 
     @status_notify(status_type=ImportStatusTypes.FILES_MOVED, updates=False)
-    def bulk_comics_moved(self, moved_paths, library, status=None):
+    def _bulk_comics_moved(self, moved_paths, library, status=None):
         """Move comcis."""
         count = 0
         if not moved_paths:
@@ -57,7 +60,7 @@ class MovedMixin(CreateComicsMixin, CreateForeignKeysMixin, QueryForeignKeysMixi
             except Exception:
                 self.log.exception(f"moving {comic.path}")
 
-        Comic.objects.bulk_update(comics, MOVED_BULK_COMIC_UPDATE_FIELDS)
+        Comic.objects.bulk_update(comics, _MOVED_BULK_COMIC_UPDATE_FIELDS)
 
         # Update m2m field
         count = len(comics)
@@ -67,7 +70,7 @@ class MovedMixin(CreateComicsMixin, CreateForeignKeysMixin, QueryForeignKeysMixi
 
         return count
 
-    def _get_parent_folders(self, library, dest_folder_paths):
+    def _get_parent_folders(self, library, dest_folder_paths, status):
         """Get destination parent folders."""
         # Determine parent folder paths.
         dest_parent_folder_paths = set()
@@ -82,7 +85,7 @@ class MovedMixin(CreateComicsMixin, CreateForeignKeysMixin, QueryForeignKeysMixi
         create_folder_paths = frozenset(
             dest_parent_folder_paths - frozenset(existing_folder_paths)
         )
-        self.bulk_folders_create(create_folder_paths, library)
+        self.bulk_folders_create(create_folder_paths, library, status=status)
 
         # get parent folders path to model obj dict
         dest_parent_folders_objs = Folder.objects.filter(
@@ -94,13 +97,16 @@ class MovedMixin(CreateComicsMixin, CreateForeignKeysMixin, QueryForeignKeysMixi
         return dest_parent_folders
 
     @status_notify(status_type=ImportStatusTypes.DIRS_MOVED, updates=False)
-    def bulk_folders_moved(self, folders_moved, library, **kwargs):
+    def _bulk_folders_moved(self, folders_moved, library, **kwargs):
         """Move folders in the database instead of recreating them."""
         if not folders_moved:
             return 0
 
         dest_folder_paths = frozenset(folders_moved.values())
-        dest_parent_folders = self._get_parent_folders(library, dest_folder_paths)
+        status = kwargs.get("status")
+        dest_parent_folders = self._get_parent_folders(
+            library, dest_folder_paths, status
+        )
 
         src_folder_paths = frozenset(folders_moved.keys())
         folders = Folder.objects.filter(library=library, path__in=src_folder_paths)
@@ -119,11 +125,34 @@ class MovedMixin(CreateComicsMixin, CreateForeignKeysMixin, QueryForeignKeysMixi
 
         update_folders = sorted(update_folders, key=lambda x: len(Path(x.path).parts))
 
-        Folder.objects.bulk_update(update_folders, MOVED_BULK_FOLDER_UPDATE_FIELDS)
+        Folder.objects.bulk_update(update_folders, _MOVED_BULK_FOLDER_UPDATE_FIELDS)
         count = len(update_folders)
         self.log.info(f"Moved {count} folders.")
         return count
 
+    @status_notify(status_type=ImportStatusTypes.DIRS_MODIFIED, updates=False)
+    def bulk_folders_modified(self, paths, library, **kwargs):
+        """Update folders stat and nothing else."""
+        count = 0
+        if not paths:
+            return count
+        folders = Folder.objects.filter(library=library, path__in=paths).only(
+            "stat", "updated_at"
+        )
+        update_folders = []
+        now = Now()
+        for folder in folders.iterator():
+            if Path(folder.path).exists():
+                folder.set_stat()
+                folder.updated_at = now
+                update_folders.append(folder)
+        Folder.objects.bulk_update(
+            update_folders, fields=BULK_UPDATE_FOLDER_MODIFIED_FIELDS
+        )
+        count += len(update_folders)
+        self.log.info(f"Modified {count} folders")
+        return count
+
     def adopt_orphan_folders(self):
         """Find orphan folders and move them into their correct place."""
         libraries = Library.objects.only("pk", "path")
@@ -138,4 +167,19 @@ class MovedMixin(CreateComicsMixin, CreateForeignKeysMixin, QueryForeignKeysMixi
             for path in orphan_folder_paths:
                 folders_moved[path] = path
 
-            self.bulk_folders_moved(folders_moved, library)
+            self._bulk_folders_moved(folders_moved, library)
+
+    def move_and_modify_dirs(self, library, task):
+        """Move files and dirs and modify dirs."""
+        # TODO add status?
+        changed = 0
+        changed += self._bulk_folders_moved(task.dirs_moved, library)
+        task.dirs_moved = None
+
+        changed += self._bulk_comics_moved(task.files_moved, library)
+        task.files_moved = None
+
+        changed += self.bulk_folders_modified(task.dirs_modified, library)
+        task.dirs_modified = None
+
+        return changed

codex/librarian/importer/query_fks.py

@@ -1,9 +1,10 @@
 """Query the missing foreign keys for comics and creators."""
+from collections.abc import Iterable
 from pathlib import Path
 
 from django.db.models import Q
 
-from codex.librarian.importer.status import status_notify
+from codex.librarian.importer.status import ImportStatusTypes, status_notify
 from codex.models import (
     Comic,
     Creator,
@@ -11,12 +12,15 @@ from codex.models import (
     Imprint,
     Publisher,
     Series,
+    StoryArcNumber,
     Volume,
 )
+from codex.status import Status
 from codex.threads import QueuedThread
 
 _CLASS_QUERY_FIELDS_MAP = {
     Creator: ("role__name", "person__name"),
+    StoryArcNumber: ("story_arc__name", "number"),
     Folder: ("path",),
     Imprint: ("publisher__name", "name"),
     Series: ("publisher__name", "imprint__name", "name"),
@@ -27,6 +31,7 @@ _DEFAULT_QUERY_FIELDS = ("name",)
 # fixes this in the bulk_create & bulk_update functions. So for complicated
 # queries I gotta batch them myself. Filter arg count is a proxy, but it works.
 _SQLITE_FILTER_ARG_MAX = 990
+_CREATOR_FK_NAMES = ("role", "person")
 
 
 class QueryForeignKeysMixin(QueuedThread):
@@ -44,7 +49,13 @@ class QueryForeignKeysMixin(QueuedThread):
             .values_list(*fields, flat=flat)
         )
 
-    def _query_create_metadata(self, fk_cls, create_mds, all_filter_args, status):
+    def _query_create_metadata(
+        self,
+        fk_cls,
+        create_mds,
+        all_filter_args: Iterable[tuple[tuple[str, str], ...]],
+        status,
+    ):
         """Get create metadata by comparing proposed meatada to existing rows."""
         # Do this in batches so as not to exceed the 1k line sqlite limit
         fk_filter = Q()
@@ -78,7 +89,9 @@ class QueryForeignKeysMixin(QueuedThread):
         return count
 
     @staticmethod
-    def _add_parent_group_filter(filter_args, group_name, field_name):
+    def _add_parent_group_filter(
+        filter_args: dict[str, str], group_name: str, field_name: str
+    ):
         """Get the parent group filter by name."""
         key = f"{field_name}__" if field_name else ""
 
@@ -88,9 +101,9 @@ class QueryForeignKeysMixin(QueuedThread):
 
     def _get_create_group_set(self, groups, group_cls, create_group_set, status):
         """Create the create group set."""
-        all_filter_args = set()
+        all_filter_args: set[tuple[tuple[str, str], ...]] = set()
         for group_tree in groups:
-            filter_args = {}
+            filter_args: dict[str, str] = {}
             self._add_parent_group_filter(filter_args, group_tree[-1], "")
             if group_cls in (Imprint, Series, Volume):
                 self._add_parent_group_filter(filter_args, group_tree[0], "publisher")
@@ -99,7 +112,10 @@ class QueryForeignKeysMixin(QueuedThread):
             if group_cls == Volume:
                 self._add_parent_group_filter(filter_args, group_tree[2], "series")
 
-            all_filter_args.add(tuple(sorted(filter_args.items())))
+            serialized_filter_args: tuple[tuple[str, str], ...] = tuple(
+                sorted(filter_args.items())
+            )
+            all_filter_args.add(serialized_filter_args)
 
         candidate_groups = set(groups.keys())
         count = self._query_create_metadata(
@@ -126,8 +142,36 @@ class QueryForeignKeysMixin(QueuedThread):
             update_groups[group_cls][group_tree] = {}
         update_groups[group_cls][group_tree].update(count_dict)
 
+    def _query_group_tree(self, data, group_tree, count_dict):
+        """Query missing groups for one group tree depth."""
+        (
+            create_group_set,
+            group_cls,
+            create_and_update_groups,
+            status,
+        ) = data
+        apply_count_dict = count_dict if count_dict else {}
+        if group_tree in create_group_set:
+            self._update_create_group(
+                group_cls,
+                create_and_update_groups["create_groups"],
+                group_tree,
+                apply_count_dict,
+            )
+        elif group_cls in (Series, Volume):
+            self._update_update_group(
+                group_cls,
+                create_and_update_groups["update_groups"],
+                group_tree,
+                apply_count_dict,
+            )
+        if status:
+            status.complete = status.complete or 0
+            status.complete += 1
+            self.status_controller.update(status)
+
     @status_notify()
-    def query_missing_group(
+    def _query_missing_group(
         self,
         groups,
         group_cls,
@@ -144,68 +188,97 @@ class QueryForeignKeysMixin(QueuedThread):
 
         if status:
             status.subtitle = group_cls.__name__
+
+        data = (create_group_set, group_cls, create_and_update_groups, status)
         for group_tree, count_dict in groups.items():
-            apply_count_dict = count_dict if count_dict else {}
-            if group_tree in create_group_set:
-                self._update_create_group(
-                    group_cls,
-                    create_and_update_groups["create_groups"],
-                    group_tree,
-                    apply_count_dict,
-                )
-            elif group_cls in (Series, Volume):
-                self._update_update_group(
-                    group_cls,
-                    create_and_update_groups["update_groups"],
-                    group_tree,
-                    apply_count_dict,
-                )
-            count += 1
-            if status:
-                status.complete += 1
-                self.status_controller.update(status)
+            self._query_group_tree(data, group_tree, count_dict)
 
         if status:
             status.subtitle = ""
+        count = len(groups)
         if count:
             self.log.info(f"Prepared {count} new {group_cls.__name__}s.")
         return count
 
-    @status_notify()
-    def query_missing_creators(self, creators, create_creators, status=None):
-        """Find missing creator objects."""
+    @staticmethod
+    def _get_query_filter_creators(creator_tuple):
+        """Get serialized comparison object data for Creators."""
+        creator_dict = dict(creator_tuple)
+        role = creator_dict.get("role")
+        person = creator_dict["person"]
+        filter_args = {
+            "person__name": person,
+            "role__name": role,
+        }
+        comparison_tuple = (role, person)
+        return filter_args, comparison_tuple
+
+    @staticmethod
+    def _get_query_filter_story_arc_numbers(story_arc_number_tuple):
+        """Get serialized comparison object data for StoryArcNumbers."""
+        story_arc, number = story_arc_number_tuple
+        filter_args = {
+            "story_arc__name": story_arc,
+            "number": number,
+        }
+        comparison_tuple = (story_arc, number)
+        return filter_args, comparison_tuple
+
+    def _query_missing_dict_model(self, possible_objs, model_data, create_objs, status):
+        """Find missing dict type m2m models with a supplied filter method."""
         count = 0
-        if not creators:
+        if not possible_objs:
             return count
         # create the filter
-        comparison_creators = set()
+        (get_query_filter_method, model) = model_data
+        comparison_objs = set()
         all_filter_args = set()
-        for creator_tuple in creators:
-            creator_dict = dict(creator_tuple)
-            role = creator_dict.get("role")
-            person = creator_dict["person"]
-            filter_args = {
-                "person__name": person,
-                "role__name": role,
-            }
+        for obj_tuple in possible_objs:
+            filter_args, comparison_tuple = get_query_filter_method(obj_tuple)
             all_filter_args.add(tuple(sorted(filter_args.items())))
+            comparison_objs.add(comparison_tuple)
 
-            comparison_tuple = (role, person)
-            comparison_creators.add(comparison_tuple)
-
-        # get the create metadata
+        # get the obj metadata
         count = self._query_create_metadata(
-            Creator, comparison_creators, all_filter_args, status
+            model, comparison_objs, all_filter_args, status
         )
-        create_creators.update(comparison_creators)
+        create_objs.update(comparison_objs)
         if count:
-            self.log.info(f"Prepared {count} new creators.")
+            self.log.info(f"Prepared {count} new {model.__class__.__name__}s.")
         if status:
+            status.complete = status.complete or 0
             status.complete += count
         return count
 
     @status_notify()
-    def query_missing_simple_models(self, names, fk_data, status=None):
+    def _query_missing_creators(self, creators, create_creators, status=None):
+        """Find missing creator objects."""
+        model_data = (self._get_query_filter_creators, Creator)
+        return self._query_missing_dict_model(
+            creators,
+            model_data,
+            create_creators,
+            status,
+        )
+
+    @status_notify()
+    def _query_missing_story_arc_numbers(
+        self, story_arc_numbers, create_story_arc_numbers, status=None
+    ):
+        """Find missing story arc number objects."""
+        model_data = (
+            self._get_query_filter_story_arc_numbers,
+            StoryArcNumber,
+        )
+        return self._query_missing_dict_model(
+            story_arc_numbers,
+            model_data,
+            create_story_arc_numbers,
+            status,
+        )
+
+    @status_notify()
+    def _query_missing_simple_models(self, names, fk_data, status=None):
         """Find missing named models and folders."""
         count = 0
         if not names:
@@ -231,6 +304,7 @@ class QueryForeignKeysMixin(QueuedThread):
             num_in_batch = len(batch_proposed_names)
             count += num_in_batch
             if status:
+                status.complete = status.complete or 0
                 status.complete += num_in_batch
                 self.status_controller.update(status)
             start += _SQLITE_FILTER_ARG_MAX
@@ -260,7 +334,7 @@ class QueryForeignKeysMixin(QueuedThread):
         # get the create metadata
         create_folder_paths_dict = {}
         fk_data = (create_folder_paths_dict, Comic, "parent_folder", "path")
-        self.query_missing_simple_models(
+        self._query_missing_simple_models(
             proposed_folder_paths,
             fk_data,
             status=status,
@@ -269,3 +343,91 @@ class QueryForeignKeysMixin(QueuedThread):
         count = len(comic_paths)
         self.log.info(f"Prepared {count} new Folders.")
         return count
+
+    @staticmethod
+    def _get_query_fks_totals(fks):
+        """Get the query foreign keys totals."""
+        fks_total = 0
+        for key, objs in fks.items():
+            if key == "group_trees":
+                for groups in objs.values():
+                    fks_total += len(groups)
+            else:
+                fks_total += len(objs)
+        return fks_total
+
+    def _query_one_simple_model(self, fk_field, names, create_fks, status):
+        """Batch query one simple model name."""
+        if fk_field in _CREATOR_FK_NAMES:
+            base_cls = Creator
+        elif fk_field == "story_arc":
+            base_cls = StoryArcNumber
+        else:
+            base_cls = Comic
+        fk_data = create_fks, base_cls, fk_field, "name"
+        status.complete += self._query_missing_simple_models(
+            names,
+            fk_data,
+            status=status,
+        )
+
+    def query_all_missing_fks(self, library_path, fks):
+        """Get objects to create by querying existing objects for the proposed fks."""
+        create_creators = set()
+        create_story_arc_numbers = set()
+        create_groups = {}
+        update_groups = {}
+        create_folder_paths = set()
+        create_fks = {}
+        self.log.debug(f"Querying existing foreign keys for comics in {library_path}")
+        fks_total = self._get_query_fks_totals(fks)
+        status = Status(ImportStatusTypes.QUERY_MISSING_FKS, 0, fks_total)
+        try:
+            self.status_controller.start(status)
+
+            self._query_missing_creators(
+                fks.pop("creators", {}),
+                create_creators,
+                status=status,
+            )
+
+            self._query_missing_story_arc_numbers(
+                fks.pop("story_arc_numbers", {}),
+                create_story_arc_numbers,
+                status=status,
+            )
+
+            create_and_update_groups = {
+                "create_groups": create_groups,
+                "update_groups": update_groups,
+            }
+            for group_class, groups in fks.pop("group_trees", {}).items():
+                self._query_missing_group(
+                    groups,
+                    group_class,
+                    create_and_update_groups,
+                    status=status,
+                )
+
+            self.query_missing_folder_paths(
+                fks.pop("comic_paths", ()),
+                library_path,
+                create_folder_paths,
+                status=status,
+            )
+
+            for fk_field in sorted(fks.keys()):
+                self._query_one_simple_model(
+                    fk_field, fks.pop(fk_field), create_fks, status
+                )
+        finally:
+            self.status_controller.finish(status)
+
+        return (
+            create_groups,
+            update_groups,
+            create_folder_paths,
+            create_fks,
+            create_creators,
+            create_story_arc_numbers,
+        )

codex/librarian/importer/tasks.py

@@ -12,14 +12,14 @@ class UpdaterDBDiffTask(UpdaterTask):
     """For sending to the updater."""
 
     library_id: int
-    dirs_moved: dict
-    files_moved: dict
-    dirs_modified: frozenset
-    files_modified: frozenset
+    dirs_moved: dict[str, str]
+    files_moved: dict[str, str]
+    dirs_modified: frozenset[str]
+    files_modified: frozenset[str]
     # dirs_created
-    files_created: frozenset
-    dirs_deleted: frozenset
-    files_deleted: frozenset
+    files_created: frozenset[str]
+    dirs_deleted: frozenset[str]
+    files_deleted: frozenset[str]
 
 
 @dataclass

codex/librarian/janitor/cleanup.py

@@ -19,6 +19,7 @@ from codex.models import (
     Series,
     SeriesGroup,
     StoryArc,
+    StoryArcNumber,
     Tag,
     Team,
     Volume,
@@ -38,11 +39,22 @@ _COMIC_FK_CLASSES = (
     Character,
     Location,
     SeriesGroup,
-    StoryArc,
+    StoryArcNumber,
     Genre,
 )
 _CREATOR_FK_CLASSES = (CreatorRole, CreatorPerson)
-TOTAL_NUM_FK_CLASSES = len(_COMIC_FK_CLASSES) + len(_CREATOR_FK_CLASSES)
+_STORY_ARC_NUMBER_FK_CLASSES = (StoryArc,)
+TOTAL_NUM_FK_CLASSES = (
+    len(_COMIC_FK_CLASSES)
+    + len(_CREATOR_FK_CLASSES)
+    + len(_STORY_ARC_NUMBER_FK_CLASSES)
+)
+
+CLEANUP_MAP = [
+    (_COMIC_FK_CLASSES, "comic"),
+    (_CREATOR_FK_CLASSES, "creator"),
+    (_STORY_ARC_NUMBER_FK_CLASSES, "storyarcnumber"),
+]
 
 
 class CleanupMixin(WorkerBaseMixin):
@@ -57,7 +69,7 @@ class CleanupMixin(WorkerBaseMixin):
             query.delete()
             if count:
                 self.log.info(f"Deleted {count} orphan {cls.__name__}s")
-            status.complete += 1
+            status.complete += count
             self.status_controller.update(status)
 
     def cleanup_fks(self):
@@ -66,8 +78,8 @@ class CleanupMixin(WorkerBaseMixin):
         try:
             self.status_controller.start(status)
             self.log.debug("Cleaning up unused foreign keys...")
-            self._bulk_cleanup_fks(_COMIC_FK_CLASSES, "comic", status)
-            self._bulk_cleanup_fks(_CREATOR_FK_CLASSES, "creator", status)
+            for classes, field_name in CLEANUP_MAP:
+                self._bulk_cleanup_fks(classes, field_name, status)
             level = logging.INFO if status.complete else logging.DEBUG
             self.log.log(level, f"Cleaned up {status.complete} unused foreign keys.")
         finally:

codex/librarian/librariand.py

@@ -4,6 +4,8 @@ from multiprocessing import Manager, Process
 from threading import active_count
 
 from caseconverter import snakecase
+from comicbox.comic_archive import ComicArchive
+from comicbox.exceptions import UnsupportedArchiveTypeError
 
 from codex.librarian.covers.coverd import CoverCreatorThread
 from codex.librarian.covers.tasks import CoverTask
@@ -113,11 +115,19 @@ class LibrarianDaemon(Process, LoggerBaseMixin):
         self.log.debug(f"Active threads before thread creation: {active_count()}")
         threads = {}
         kwargs = {"librarian_queue": self.queue, "log_queue": self.log_queue}
+        try:
+            ComicArchive.check_unrar_executable()
+            unrar = True
+        except UnsupportedArchiveTypeError as exc:
+            self.log.warn(f"{exc}. Not detecting .cbr archives.")
+            unrar = False
         for name, thread_class in self._THREAD_CLASS_MAP.items():
             if thread_class == NotifierThread:
                 thread = thread_class(self.broadcast_queue, **kwargs)
             elif thread_class == SearchIndexerThread:
                 thread = thread_class(self.search_indexer_abort_event, **kwargs)
+            elif thread_class in (LibraryEventObserver, LibraryPollingObserver):
+                thread = thread_class(unrar=unrar, **kwargs)
             else:
                 thread = thread_class(**kwargs)
             threads[name] = thread

codex/librarian/watchdog/events.py

@@ -15,9 +15,6 @@ from watchdog.events import (
 from codex.librarian.watchdog.tasks import WatchdogEventTask
 from codex.logger_base import LoggerBaseMixin
 
-_COMIC_REGEX = r"\.(cb[zrt]|pdf)$"
-_COMIC_MATCHER = re.compile(_COMIC_REGEX, re.IGNORECASE)
-
 
 class CodexLibraryEventHandler(FileSystemEventHandler, LoggerBaseMixin):
     """Handle watchdog events for comics in a library."""
@@ -30,25 +27,26 @@ class CodexLibraryEventHandler(FileSystemEventHandler, LoggerBaseMixin):
         self.librarian_queue = kwargs.pop("librarian_queue")
         log_queue = kwargs.pop("log_queue")
         self.init_logger(log_queue)
+        unrar = kwargs.pop("unrar", False)
+        comic_regex = r"\.(cb[zrt]|pdf)$" if unrar else r"\.(cb[zt]|pdf)$"
+        self._comic_matcher = re.compile(comic_regex, re.IGNORECASE)
         super().__init__(*args, **kwargs)
 
-    @staticmethod
-    def _match_comic_suffix(path):
+    def _match_comic_suffix(self, path):
         """Match a supported comic suffix."""
         if not path:
             return False
         # We don't care about general suffixes. Only length four.
         suffix = path[-4:]
         suffix = fsdecode(suffix)
-        return _COMIC_MATCHER.match(suffix) is not None
+        return self._comic_matcher.match(suffix) is not None
 
-    @classmethod
-    def _transform_file_event(cls, event):
+    def _transform_file_event(self, event):
         """Transform file events into other events."""
-        source_match = cls._match_comic_suffix(event.src_path)
+        source_match = self._match_comic_suffix(event.src_path)
         if event.event_type == EVENT_TYPE_MOVED:
             # Some types of file moves need to be cast as other events.
-            dest_match = cls._match_comic_suffix(event.dest_path)
+            dest_match = self._match_comic_suffix(event.dest_path)
             if not source_match and dest_match:
                 # Moved from an ignored file extension into a comic type,
                 # so create a new comic.
@@ -61,17 +59,16 @@ class CodexLibraryEventHandler(FileSystemEventHandler, LoggerBaseMixin):
             event = None
         return event
 
-    @classmethod
-    def _transform_event(cls, event):
+    def _transform_event(self, event):
         """Transform events into other events."""
-        if event.event_type in cls.IGNORED_EVENTS:
+        if event.event_type in self.IGNORED_EVENTS:
             event = None
         elif event.is_directory:
             if event.event_type == EVENT_TYPE_CREATED:
                 # Directories are only created by comics
                 event = None
         else:
-            event = cls._transform_file_event(event)
+            event = self._transform_file_event(event)
         return event
 
     def dispatch(self, event):

codex/librarian/watchdog/observers.py

@@ -23,6 +23,7 @@ class UatuMixin(BaseObserver, WorkerBaseMixin):
         log_queue = kwargs.pop("log_queue")
         librarian_queue = kwargs.pop("librarian_queue")
         self.init_worker(log_queue, librarian_queue)
+        self._unrar = kwargs.pop("unrar", False)
         super().__init__(*args, **kwargs)
 
     def _get_watch(self, path):
@@ -50,7 +51,10 @@ class UatuMixin(BaseObserver, WorkerBaseMixin):
 
         # Set up the watch
         handler = CodexLibraryEventHandler(
-            library, librarian_queue=self.librarian_queue, log_queue=self.log_queue
+            library,
+            librarian_queue=self.librarian_queue,
+            log_queue=self.log_queue,
+            unrar=self._unrar,
         )
         self.schedule(handler, library.path, recursive=True)
         self.log.info(f"Started {watching_log}")