codex 1.6.0a4__py3-none-any.whl → 1.6.0a5__py3-none-any.whl

codex/librarian/watchdog/events.py

@@ -2,30 +2,93 @@
 
 import re
 from os import fsdecode
+from pathlib import Path
+from types import MappingProxyType
 
 from comicbox.box import Comicbox
 from watchdog.events import (
     EVENT_TYPE_CLOSED,
     EVENT_TYPE_CREATED,
+    EVENT_TYPE_DELETED,
+    EVENT_TYPE_MODIFIED,
     EVENT_TYPE_MOVED,
     EVENT_TYPE_OPENED,
     FileCreatedEvent,
     FileDeletedEvent,
+    FileModifiedEvent,
+    FileMovedEvent,
     FileSystemEventHandler,
 )
 
 from codex.librarian.watchdog.tasks import WatchdogEventTask
 from codex.logger.logging import get_logger
 from codex.logger_base import LoggerBaseMixin
+from codex.models import CustomCover
+from codex.settings.settings import CUSTOM_COVERS_DIR, CUSTOM_COVERS_GROUP_DIRS
 
 LOG = get_logger(__name__)
+_IMAGE_EXTS = frozenset({"jpg", "jpeg", "webp", "png", "gif", "bmp"})
+_GROUP_COVERS_DIRS = frozenset(CUSTOM_COVERS_GROUP_DIRS)
 
 
-class CodexLibraryEventHandler(FileSystemEventHandler, LoggerBaseMixin):
-    """Handle watchdog events for comics in a library."""
+class CoverMovedEvent(FileMovedEvent):
+    """Cover Modified."""
+
+    is_cover = True
+    is_synthetic = True
+
+
+class CoverModifiedEvent(FileModifiedEvent):
+    """Cover Modified."""
+
+    is_cover = True
+    is_synthetic = True
+
+
+class CoverCreatedEvent(FileCreatedEvent):
+    """Cover Created."""
+
+    is_cover = True
+    is_synthetic = True
+
+
+class CoverDeletedEvent(FileDeletedEvent):
+    """Cover Deleted."""
+
+    is_cover = True
+    is_synthetic = True
+
+
+COVERS_EVENT_TYPE_MAP = MappingProxyType(
+    {
+        EVENT_TYPE_MODIFIED: CoverModifiedEvent,
+        EVENT_TYPE_CREATED: CoverCreatedEvent,
+        EVENT_TYPE_DELETED: CoverDeletedEvent,
+    }
+)
+
+
+class CodexEventHandlerBase(FileSystemEventHandler, LoggerBaseMixin):
+    """Base class for Codex Event Handlers."""
 
     IGNORED_EVENTS = frozenset({EVENT_TYPE_CLOSED, EVENT_TYPE_OPENED})
 
+    def __init__(self, library, *args, **kwargs):
+        """Let us send along he library id."""
+        self.library_pk = library.pk
+        self.librarian_queue = kwargs.pop("librarian_queue")
+        log_queue = kwargs.pop("log_queue")
+        self.init_logger(log_queue)
+        super().__init__(*args, **kwargs)
+
+    @staticmethod
+    def _match_image_suffix(path: Path) -> bool:
+        return path and len(path.suffix) > 1 and path.suffix[1:] in _IMAGE_EXTS
+
+
+class CodexLibraryEventHandler(CodexEventHandlerBase):
+    """Handle watchdog events for comics in a library."""
+
     def _set_comic_matcher(self):
         comic_regex = r"\.(cb[zt"
         unsupported = []
@@ -45,12 +108,8 @@ class CodexLibraryEventHandler(FileSystemEventHandler, LoggerBaseMixin):
             un_str = ", ".join(unsupported)
             LOG.warning(f"Cannot detect or read from {un_str} archives")
 
-    def __init__(self, library, *args, **kwargs):
+    def __init__(self, *args, **kwargs):
         """Let us send along he library id."""
-        self.library_pk = library.pk
-        self.librarian_queue = kwargs.pop("librarian_queue")
-        log_queue = kwargs.pop("log_queue")
-        self.init_logger(log_queue)
         self._set_comic_matcher()
         super().__init__(*args, **kwargs)
 
@@ -63,48 +122,129 @@ class CodexLibraryEventHandler(FileSystemEventHandler, LoggerBaseMixin):
         suffix = fsdecode(suffix)
         return self._comic_matcher.match(suffix) is not None
 
+    @classmethod
+    def _match_folder_cover(cls, path_str: str) -> bool:
+        if not path_str:
+            return False
+        path = Path(path_str)
+        return path.stem == CustomCover.FOLDER_COVER_STEM and cls._match_image_suffix(
+            path
+        )
+
+    def _transform_file_move_event(
+        self,
+        event,
+        events,
+        source_match_comic,
+    ):
+        """Create file events for file moves."""
+        dest_match_comic = self._match_comic_suffix(event.dest_path)
+        if not source_match_comic and dest_match_comic:
+            # Moved from an ignored file extension into a comic type,
+            # so create a new comic.
+            events.append(FileCreatedEvent(event.dest_path))
+        elif source_match_comic and not dest_match_comic:
+            # moved into something that's not a comic name so delete
+            events.append(FileDeletedEvent(event.src_path))
+        elif source_match_comic and dest_match_comic:
+            events.append(event)
+
+    def _transform_file_move_event_to_cover_event(self, event, events):
+        """Create cover events for file moves."""
+        source_match_cover = self._match_folder_cover(event.src_path)
+        dest_match_cover = self._match_folder_cover(event.dest_path)
+        if source_match_cover and not dest_match_cover:
+            events.append(CoverDeletedEvent(event.src_path))
+        elif not source_match_cover and dest_match_cover:
+            events.append(CoverCreatedEvent(event.dest_path))
+        elif source_match_cover and dest_match_cover:
+            events.append(CoverMovedEvent(event.src_path, event.dest_path))
+
     def _transform_file_event(self, event):
         """Transform file events into other events."""
-        source_match = self._match_comic_suffix(event.src_path)
+        events = []
+        source_match_comic = 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 = 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.
-                event = FileCreatedEvent(event.dest_path)
-            elif source_match and not dest_match:
-                # moved into something that's not a comic name so delete
-                event = FileDeletedEvent(event.src_path)
-        elif not source_match:
-            # Don't process non-moved, non-comic files at all
-            event = None
-        return event
-
-    def _transform_event(self, event):
-        """Transform events into other 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
+            self._transform_file_move_event(event, events, source_match_comic)
+            self._transform_file_move_event_to_cover_event(event, events)
+        elif source_match_comic:
+            events.append(event)
         else:
-            event = self._transform_file_event(event)
-        return event
+            source_match_cover = self._match_folder_cover(event.src_path)
+            if source_match_cover and (
+                event_class := COVERS_EVENT_TYPE_MAP.get(event.event_type)
+            ):
+                # Convert to cover type
+                event = event_class(event.src_path)
+                events.append(event)
+        return events
 
     def dispatch(self, event):
         """Send only valid codex events to the EventBatcher."""
         try:
-            event = self._transform_event(event)
-            if not event:
+            if event.event_type in self.IGNORED_EVENTS or (
+                event.is_directory and event.event_type == EVENT_TYPE_CREATED
+            ):
+                # Directories are only created by comics
                 return
 
+            events = self._transform_file_event(event)
+
             # Send it to the EventBatcher
-            task = WatchdogEventTask(self.library_pk, event)
-            self.librarian_queue.put(task)
+            for event in events:
+                task = WatchdogEventTask(self.library_pk, event)
+                self.librarian_queue.put(task)
 
             # Calls stub event dispatchers
             # super().dispatch(event)
         except Exception:
             self.log.exception(f"{self.__class__.__name__} dispatch")
+
+
+class CodexCustomCoverEventHandler(CodexEventHandlerBase):
+    """Special event handler for the custom cover dir."""
+
+    @classmethod
+    def _match_group_cover_image(cls, path_str: str) -> bool:
+        path = Path(path_str)
+        parent = path.parent
+        if (
+            parent.parent != CUSTOM_COVERS_DIR
+            or str(parent.name) not in _GROUP_COVERS_DIRS
+        ):
+            return False
+        return cls._match_image_suffix(path)
+
+    @classmethod
+    def _transform_event_moved(cls, event, src_cover_match):
+        """Get a cover event for a file moved event."""
+        send_event = None
+        dest_cover_match = cls._match_group_cover_image(event.dest_path)
+        if src_cover_match and dest_cover_match:
+            send_event = CoverMovedEvent(event.src_path, event.dest_path)
+        elif not src_cover_match and dest_cover_match:
+            send_event = CoverCreatedEvent(event.dest_path)
+        elif src_cover_match and not dest_cover_match:
+            send_event = CoverDeletedEvent(event.src_path)
+        return send_event
+
+    def dispatch(self, event):
+        """Send only valid cover events to the EventBatcher."""
+        send_event = None
+        try:
+            if event.is_directory or event.event_type in self.IGNORED_EVENTS:
+                return
+            src_cover_match = self._match_group_cover_image(event.src_path)
+            if event.event_type == EVENT_TYPE_MOVED:
+                send_event = self._transform_event_moved(event, src_cover_match)
+            elif src_cover_match:
+                event_class = COVERS_EVENT_TYPE_MAP.get(event.event_type)
+                if not event_class:
+                    return
+                send_event = event_class(event.src_path)
+
+            if send_event:
+                task = WatchdogEventTask(self.library_pk, send_event)
+                self.librarian_queue.put(task)
+        except Exception:
+            self.log.exception(f"{self.__class__.__name__} dispatch")

codex/librarian/watchdog/observers.py

@@ -8,7 +8,10 @@ from watchdog.observers.api import (
 )
 
 from codex.librarian.watchdog.emitter import DatabasePollingEmitter
-from codex.librarian.watchdog.events import CodexLibraryEventHandler
+from codex.librarian.watchdog.events import (
+    CodexCustomCoverEventHandler,
+    CodexLibraryEventHandler,
+)
 from codex.models import Library
 from codex.worker_base import WorkerBaseMixin
 
@@ -50,7 +53,12 @@ class UatuMixin(BaseObserver, WorkerBaseMixin):
             return
 
         # Set up the watch
-        handler = CodexLibraryEventHandler(
+        handler_class = (
+            CodexCustomCoverEventHandler
+            if library.covers_only
+            else CodexLibraryEventHandler
+        )
+        handler = handler_class(
             library,
             librarian_queue=self.librarian_queue,
             log_queue=self.log_queue,
@@ -109,12 +117,14 @@ class UatuMixin(BaseObserver, WorkerBaseMixin):
 
             # If we don't have an emitter for this watch already, create it.
             if self._emitter_for_watch.get(watch) is None:
+                covers_only = isinstance(event_handler, CodexCustomCoverEventHandler)
                 emitter = self._emitter_class(
                     event_queue=self.event_queue,
                     watch=watch,
                     timeout=self.timeout,
                     log_queue=self.log_queue,
                     librarian_queue=self.librarian_queue,
+                    covers_only=covers_only,
                 )
                 self._add_emitter(emitter)
                 if self.is_alive():
@@ -149,7 +159,7 @@ class LibraryPollingObserver(UatuMixin):
     def poll(self, library_pks, force=False):
         """Poll each requested emitter."""
         try:
-            qs = Library.objects
+            qs = Library.objects.all()
             if library_pks:
                 qs = qs.filter(pk__in=library_pks)
             paths = frozenset(qs.values_list("path", flat=True))

codex/migrations/0027_sort_name.py

@@ -6,7 +6,7 @@ from pathlib import Path
 
 from django.db import migrations, models
 
-from codex.models.const import ARTICLES
+from codex.models.util import get_sort_name
 
 CONFIG_PATH = Path(os.environ.get("CODEX_CONFIG_DIR", Path.cwd() / "config"))
 COVER_ROOT = CONFIG_PATH / "cache" / "covers"
@@ -23,17 +23,7 @@ _GROUP_MODEL_NAMES = (
 
 def _set_sort_name(obj):
     """Create sort_name for model."""
-    # Duplicate code from BaseGroupModel
-    sort_name = ""
-    lower_name = obj.name.lower()
-    sort_name = lower_name
-    name_parts = lower_name.split()
-    if len(name_parts) > 1:
-        first_word = name_parts[0]
-        if first_word in ARTICLES:
-            sort_name = " ".join(name_parts[1:])
-            sort_name += ", " + first_word
-    obj.sort_name = sort_name
+    obj.sort_name = get_sort_name(obj.name)
 
 
 def _generate_sort_name(apps, _schema_editor):

codex/migrations/0028_custom_covers.py

@@ -0,0 +1,166 @@
+"""Generated by Django 5.0.6 on 2024-05-23 03:50."""
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    """Migrate db."""
+
+    dependencies = [
+        ("codex", "0027_sort_name"),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name="failedimport",
+            name="sort_name",
+        ),
+        migrations.AddField(
+            model_name="library",
+            name="covers_only",
+            field=models.BooleanField(db_index=True, default=False),
+        ),
+        migrations.AlterField(
+            model_name="librarianstatus",
+            name="status_type",
+            field=models.CharField(
+                choices=[
+                    ("CCC", "Create Covers"),
+                    ("CCD", "Purge Covers"),
+                    ("CFO", "Find Orphan"),
+                    ("IDM", "Dirs Moved"),
+                    ("IFM", "Files Moved"),
+                    ("ITR", "Aggregate Tags"),
+                    ("ITQ", "Query Missing Fks"),
+                    ("ITC", "Create Fks"),
+                    ("IDU", "Dirs Modified"),
+                    ("IFU", "Files Modified"),
+                    ("IFC", "Files Created"),
+                    ("IMQ", "Query M2M Fields"),
+                    ("IMC", "Link M2M Fields"),
+                    ("IDD", "Dirs Deleted"),
+                    ("IFD", "Files Deleted"),
+                    ("IFI", "Failed Imports"),
+                    ("ICQ", "Query Missing Covers"),
+                    ("ICM", "Covers Moved"),
+                    ("ICU", "Covers Modified"),
+                    ("ICC", "Covers Created"),
+                    ("ICD", "Covers Deleted"),
+                    ("ICL", "Covers Link"),
+                    ("JTD", "Cleanup Fk"),
+                    ("JCU", "Codex Update"),
+                    ("JCR", "Codex Restart"),
+                    ("JCS", "Codex Stop"),
+                    ("JDO", "Db Optimize"),
+                    ("JDB", "Db Backup"),
+                    ("JSD", "Cleanup Sessions"),
+                    ("JCD", "Cleanup Covers"),
+                    ("SIX", "Search Index Clear"),
+                    ("SIU", "Search Index Update"),
+                    ("SID", "Search Index Remove"),
+                    ("SIM", "Search Index Merge"),
+                    ("WPO", "Poll"),
+                ],
+                db_index=True,
+                max_length=3,
+            ),
+        ),
+        migrations.CreateModel(
+            name="CustomCover",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                ("path", models.CharField(db_index=True, max_length=4095)),
+                ("stat", models.JSONField(null=True)),
+                (
+                    "group",
+                    models.CharField(
+                        choices=[
+                            ("p", "P"),
+                            ("i", "I"),
+                            ("s", "S"),
+                            ("a", "A"),
+                            ("f", "F"),
+                        ],
+                        db_index=True,
+                        max_length=1,
+                    ),
+                ),
+                (
+                    "sort_name",
+                    models.CharField(db_index=True, default="", max_length=128),
+                ),
+                (
+                    "library",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE, to="codex.library"
+                    ),
+                ),
+            ],
+            options={
+                "get_latest_by": "updated_at",
+                "abstract": False,
+                "unique_together": {("library", "path")},
+            },
+        ),
+        migrations.AddField(
+            model_name="folder",
+            name="custom_cover",
+            field=models.ForeignKey(
+                default=None,
+                null=True,
+                on_delete=django.db.models.deletion.SET_DEFAULT,
+                to="codex.customcover",
+            ),
+        ),
+        migrations.AddField(
+            model_name="imprint",
+            name="custom_cover",
+            field=models.ForeignKey(
+                default=None,
+                null=True,
+                on_delete=django.db.models.deletion.SET_DEFAULT,
+                to="codex.customcover",
+            ),
+        ),
+        migrations.AddField(
+            model_name="publisher",
+            name="custom_cover",
+            field=models.ForeignKey(
+                default=None,
+                null=True,
+                on_delete=django.db.models.deletion.SET_DEFAULT,
+                to="codex.customcover",
+            ),
+        ),
+        migrations.AddField(
+            model_name="series",
+            name="custom_cover",
+            field=models.ForeignKey(
+                default=None,
+                null=True,
+                on_delete=django.db.models.deletion.SET_DEFAULT,
+                to="codex.customcover",
+            ),
+        ),
+        migrations.AddField(
+            model_name="storyarc",
+            name="custom_cover",
+            field=models.ForeignKey(
+                default=None,
+                null=True,
+                on_delete=django.db.models.deletion.SET_DEFAULT,
+                to="codex.customcover",
+            ),
+        ),
+    ]

codex/models/admin.py

@@ -39,7 +39,6 @@ class AdminFlag(BaseModel):
         AUTO_UPDATE = "AU"
         SEARCH_INDEX_OPTIMIZE = "SO"
         IMPORT_METADATA = "IM"
-        DYNAMIC_GROUP_COVERS = "DC"
 
     FALSE_DEFAULTS = frozenset({FlagChoices.AUTO_UPDATE})
 

codex/models/base.py

@@ -23,3 +23,6 @@ class BaseModel(Model):
 
         abstract = True
         get_latest_by = "updated_at"
+
+    def presave(self):
+        """Create values before save."""

codex/models/comic.py

@@ -22,7 +22,14 @@ from django.db.models import (
     TextField,
 )
 
-from codex.models.groups import Imprint, Publisher, Series, Volume
+from codex.models.groups import (
+    Folder,
+    Imprint,
+    Publisher,
+    Series,
+    Volume,
+    WatchedPathBrowserGroup,
+)
 from codex.models.named import (
     AgeRating,
     Character,
@@ -41,7 +48,6 @@ from codex.models.named import (
     Tagger,
     Team,
 )
-from codex.models.paths import Folder, WatchedPath
 
 __all__ = ("Comic",)
 
@@ -55,7 +61,7 @@ class ReadingDirection(Choices):
     BTT = ReadingDirectionEnum.BTT.value
 
 
-class Comic(WatchedPath):
+class Comic(WatchedPathBrowserGroup):
     """Comic metadata."""
 
     class FileType(Choices):
@@ -168,10 +174,14 @@ class Comic(WatchedPath):
         default="",
     )
 
-    class Meta(WatchedPath.Meta):
+    # Not useful
+    custom_cover = None
+
+    class Meta(WatchedPathBrowserGroup.Meta):
         """Constraints."""
 
-        unique_together = ("library", "path")
+        # TODO see if this inherits properly
+        # unique_together = ("library", "path")
         verbose_name = "Issue"
 
     def _set_date(self):
@@ -279,7 +289,3 @@ class Comic(WatchedPath):
         if self.issue_suffix:
             res += self.issue_suffix
         return res
-
-    def search_path(self) -> str:
-        """Relative path for search index."""
-        return self.path.removeprefix(self.library.path)

codex/models/groups.py

@@ -1,17 +1,17 @@
 """Browser Group models."""
 
-from django.db.models import (
-    CASCADE,
+from django.db.models import CASCADE, SET_DEFAULT, ForeignKey
+from django.db.models.fields import (
     CharField,
-    ForeignKey,
     PositiveSmallIntegerField,
     SmallIntegerField,
 )
 
 from codex.models.base import MAX_NAME_LEN, BaseModel
-from codex.models.const import ARTICLES
+from codex.models.paths import CustomCover, WatchedPath
+from codex.models.util import get_sort_name
 
-__all__ = ("BrowserGroupModel", "Publisher", "Imprint", "Series", "Volume")
+__all__ = ("BrowserGroupModel", "Publisher", "Imprint", "Series", "Volume", "Folder")
 
 
 class BrowserGroupModel(BaseModel):
@@ -22,18 +22,13 @@ class BrowserGroupModel(BaseModel):
 
     name = CharField(db_index=True, max_length=MAX_NAME_LEN, default=DEFAULT_NAME)
     sort_name = CharField(db_index=True, max_length=MAX_NAME_LEN, default=DEFAULT_NAME)
+    custom_cover = ForeignKey(
+        CustomCover, on_delete=SET_DEFAULT, null=True, default=None
+    )
 
     def set_sort_name(self):
         """Create sort_name for model."""
-        lower_name = self.name.lower()
-        sort_name = lower_name
-        name_parts = lower_name.split()
-        if len(name_parts) > 1:
-            first_word = name_parts[0]
-            if first_word in ARTICLES:
-                sort_name = " ".join(name_parts[1:])
-                sort_name += ", " + first_word
-        self.sort_name = sort_name
+        self.sort_name = get_sort_name(self.name)
 
     def presave(self):
         """Set computed values."""
@@ -103,6 +98,7 @@ class Volume(BrowserGroupModel):
 
     # Harmful because name is numeric
     sort_name = None
+    custom_cover = None
 
     def set_sort_name(self):
         """Noop."""
@@ -125,3 +121,23 @@ class Volume(BrowserGroupModel):
     def __str__(self):
         """Represent volume as a string."""
         return self.to_str(self.name)
+
+
+class WatchedPathBrowserGroup(BrowserGroupModel, WatchedPath):
+    """Watched Path Browser Group."""
+
+    def presave(self):
+        """Fix multiple inheritance presave."""
+        # TODO test presave calling bgm & stat
+        super().presave()
+        WatchedPath.presave(self)
+
+    class Meta(WatchedPath.Meta):  # type: ignore
+        """Use Mixin Meta."""
+
+        # TODO see if this does unique properly.
+        abstract = True
+
+
+class Folder(WatchedPathBrowserGroup):
+    """File system folder."""