codex 1.6.0__py3-none-any.whl → 1.6.0a1__py3-none-any.whl

codex/librarian/watchdog/events.py

@@ -2,93 +2,30 @@
 
 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 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."""
+class CodexLibraryEventHandler(FileSystemEventHandler, LoggerBaseMixin):
+    """Handle watchdog events for comics in a library."""
 
     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 = []
@@ -108,8 +45,12 @@ class CodexLibraryEventHandler(CodexEventHandlerBase):
             un_str = ", ".join(unsupported)
             LOG.warning(f"Cannot detect or read from {un_str} archives")
 
-    def __init__(self, *args, **kwargs):
+    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)
         self._set_comic_matcher()
         super().__init__(*args, **kwargs)
 
@@ -122,129 +63,48 @@ class CodexLibraryEventHandler(CodexEventHandlerBase):
         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."""
-        events = []
-        source_match_comic = self._match_comic_suffix(event.src_path)
+        source_match = self._match_comic_suffix(event.src_path)
         if event.event_type == EVENT_TYPE_MOVED:
-            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)
+            # 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
         else:
-            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
+            event = self._transform_file_event(event)
+        return event
 
     def dispatch(self, event):
         """Send only valid codex events to the EventBatcher."""
         try:
-            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
+            event = self._transform_event(event)
+            if not event:
                 return
 
-            events = self._transform_file_event(event)
-
             # Send it to the EventBatcher
-            for event in events:
-                task = WatchdogEventTask(self.library_pk, event)
-                self.librarian_queue.put(task)
+            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,10 +8,7 @@ from watchdog.observers.api import (
 )
 
 from codex.librarian.watchdog.emitter import DatabasePollingEmitter
-from codex.librarian.watchdog.events import (
-    CodexCustomCoverEventHandler,
-    CodexLibraryEventHandler,
-)
+from codex.librarian.watchdog.events import CodexLibraryEventHandler
 from codex.models import Library
 from codex.worker_base import WorkerBaseMixin
 
@@ -53,12 +50,7 @@ class UatuMixin(BaseObserver, WorkerBaseMixin):
             return
 
         # Set up the watch
-        handler_class = (
-            CodexCustomCoverEventHandler
-            if library.covers_only
-            else CodexLibraryEventHandler
-        )
-        handler = handler_class(
+        handler = CodexLibraryEventHandler(
             library,
             librarian_queue=self.librarian_queue,
             log_queue=self.log_queue,
@@ -117,14 +109,12 @@ 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():
@@ -159,7 +149,7 @@ class LibraryPollingObserver(UatuMixin):
     def poll(self, library_pks, force=False):
         """Poll each requested emitter."""
         try:
-            qs = Library.objects.all()
+            qs = Library.objects
             if library_pks:
                 qs = qs.filter(pk__in=library_pks)
             paths = frozenset(qs.values_list("path", flat=True))

codex/middleware.py

@@ -22,7 +22,8 @@ class TimezoneMiddleware:
 
     def __call__(self, request):
         """Fix timeszone from the django session."""
-        if tzname := request.session.get("django_timezone"):
+        tzname = request.session.get("django_timezone")
+        if tzname:
             timezone.activate(tzname)
         else:
             timezone.deactivate()

codex/migrations/0027_sort_name.py

@@ -0,0 +1,149 @@
+"""Generated by Django 5.0.4 on 2024-05-05 23:11."""
+
+import os
+from contextlib import suppress
+from pathlib import Path
+
+from django.db import migrations, models
+
+from codex.models.const import ARTICLES
+
+CONFIG_PATH = Path(os.environ.get("CODEX_CONFIG_DIR", Path.cwd() / "config"))
+COVER_ROOT = CONFIG_PATH / "cache" / "covers"
+_GROUP_MODEL_NAMES = (
+    "publisher",
+    "imprint",
+    "series",
+    "storyarc",
+    "folder",
+    "comic",
+    "failedimport",
+)
+
+
+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
+
+
+def _generate_sort_name(apps, _schema_editor):
+    """Update new sort_name field."""
+    for model_name in _GROUP_MODEL_NAMES:
+        model = apps.get_model("codex", model_name)
+        update_fields = ("sort_name",)
+        only_fields = ("name", *update_fields)
+        update_groups = []
+        objs = model.objects.only(*only_fields)
+        for obj in objs:
+            _set_sort_name(obj)
+            update_groups.append(obj)
+        if update_groups:
+            model.objects.bulk_update(update_groups, update_fields)
+            print(f"\tUpdated sort_name for {len(update_groups)} {model_name}s")
+
+
+def _remove_cover_symlinks(_apps, _schema_editor):
+    """Remove old missing cover symlinks."""
+    # Handled programmatically now.
+    count = 0
+    for dirpath_str, _, filenames in os.walk(COVER_ROOT):
+        dirpath = Path(dirpath_str)
+        for filename in filenames:
+            full_path = dirpath / filename
+            if full_path.is_symlink():
+                with suppress(OSError):
+                    full_path.unlink(missing_ok=True)
+                    count += 1
+    if count:
+        print(f"Removed {count} missing-cover symlinks from cover cache.")
+
+
+class Migration(migrations.Migration):
+    """Migrate."""
+
+    dependencies = [
+        ("codex", "0026_comicbox_1"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="comic",
+            name="sort_name",
+            field=models.CharField(db_index=True, default="", max_length=128),
+        ),
+        migrations.AddField(
+            model_name="failedimport",
+            name="sort_name",
+            field=models.CharField(db_index=True, default="", max_length=128),
+        ),
+        migrations.AddField(
+            model_name="folder",
+            name="sort_name",
+            field=models.CharField(db_index=True, default="", max_length=128),
+        ),
+        migrations.AddField(
+            model_name="imprint",
+            name="sort_name",
+            field=models.CharField(db_index=True, default="", max_length=128),
+        ),
+        migrations.AddField(
+            model_name="publisher",
+            name="sort_name",
+            field=models.CharField(db_index=True, default="", max_length=128),
+        ),
+        migrations.AddField(
+            model_name="series",
+            name="sort_name",
+            field=models.CharField(db_index=True, default="", max_length=128),
+        ),
+        migrations.AddField(
+            model_name="storyarc",
+            name="sort_name",
+            field=models.CharField(db_index=True, default="", max_length=128),
+        ),
+        migrations.AlterField(
+            model_name="adminflag",
+            name="key",
+            field=models.CharField(
+                choices=[
+                    ("FV", "Folder View"),
+                    ("RG", "Registration"),
+                    ("NU", "Non Users"),
+                    ("AU", "Auto Update"),
+                    ("SO", "Search Index Optimize"),
+                    ("IM", "Import Metadata"),
+                ],
+                db_index=True,
+                max_length=2,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="adminflag",
+            name="key",
+            field=models.CharField(
+                choices=[
+                    ("FV", "Folder View"),
+                    ("RG", "Registration"),
+                    ("NU", "Non Users"),
+                    ("AU", "Auto Update"),
+                    ("SO", "Search Index Optimize"),
+                    ("IM", "Import Metadata"),
+                    ("DC", "Dynamic Group Covers"),
+                ],
+                db_index=True,
+                max_length=2,
+            ),
+        ),
+        migrations.RunPython(_generate_sort_name),
+        migrations.RunPython(_remove_cover_symlinks),
+    ]

codex/models/admin.py

@@ -39,6 +39,7 @@ class AdminFlag(BaseModel):
         AUTO_UPDATE = "AU"
         SEARCH_INDEX_OPTIMIZE = "SO"
         IMPORT_METADATA = "IM"
+        DYNAMIC_GROUP_COVERS = "DC"
 
     FALSE_DEFAULTS = frozenset({FlagChoices.AUTO_UPDATE})
 
@@ -82,6 +83,7 @@ class Timestamp(BaseModel):
     class TimestampChoices(TextChoices):
         """Choices for Timestamps."""
 
+        COVERS = "CV", _("Covers")
         JANITOR = "JA", _("Janitor")
         CODEX_VERSION = "VR", _("Codex Version")
         SEARCH_INDEX_UUID = "SI", _("Search Index UUID")

codex/models/base.py

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

codex/models/comic.py

@@ -22,14 +22,7 @@ from django.db.models import (
     TextField,
 )
 
-from codex.models.groups import (
-    Folder,
-    Imprint,
-    Publisher,
-    Series,
-    Volume,
-    WatchedPathBrowserGroup,
-)
+from codex.models.groups import Imprint, Publisher, Series, Volume
 from codex.models.named import (
     AgeRating,
     Character,
@@ -48,6 +41,7 @@ from codex.models.named import (
     Tagger,
     Team,
 )
+from codex.models.paths import Folder, WatchedPath
 
 __all__ = ("Comic",)
 
@@ -61,7 +55,7 @@ class ReadingDirection(Choices):
     BTT = ReadingDirectionEnum.BTT.value
 
 
-class Comic(WatchedPathBrowserGroup):
+class Comic(WatchedPath):
     """Comic metadata."""
 
     class FileType(Choices):
@@ -174,12 +168,10 @@ class Comic(WatchedPathBrowserGroup):
         default="",
     )
 
-    # Not useful
-    custom_cover = None
-
-    class Meta(WatchedPathBrowserGroup.Meta):
+    class Meta(WatchedPath.Meta):
         """Constraints."""
 
+        unique_together = ("library", "path")
         verbose_name = "Issue"
 
     def _set_date(self):
@@ -287,3 +279,7 @@ class Comic(WatchedPathBrowserGroup):
         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/{util.py → const.py}

@@ -1,6 +1,6 @@
-"""Utilities for models."""
+"""Constants for models."""
 
-_ARTICLES = frozenset(
+ARTICLES = frozenset(
     ("a", "an", "the")  # en    # noqa RUF005
     + ("un", "unos", "unas", "el", "los", "la", "las")  # es
     + ("un", "une", "le", "les", "la", "les", "l'")  # fr
@@ -16,16 +16,3 @@ _ARTICLES = frozenset(
     + ("en", "et")  # da
     + ("el", "la", "els", "les", "un", "una", "uns", "unes", "na")  # ct
 )
-
-
-def get_sort_name(name: str) -> str:
-    """Create sort_name from name."""
-    lower_name = 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
-    return sort_name

codex/models/groups.py

@@ -1,17 +1,17 @@
 """Browser Group models."""
 
-from django.db.models import CASCADE, SET_DEFAULT, ForeignKey
-from django.db.models.fields import (
+from django.db.models import (
+    CASCADE,
     CharField,
+    ForeignKey,
     PositiveSmallIntegerField,
     SmallIntegerField,
 )
 
 from codex.models.base import MAX_NAME_LEN, BaseModel
-from codex.models.paths import CustomCover, WatchedPath
-from codex.models.util import get_sort_name
+from codex.models.const import ARTICLES
 
-__all__ = ("BrowserGroupModel", "Publisher", "Imprint", "Series", "Volume", "Folder")
+__all__ = ("BrowserGroupModel", "Publisher", "Imprint", "Series", "Volume")
 
 
 class BrowserGroupModel(BaseModel):
@@ -22,13 +22,18 @@ 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."""
-        self.sort_name = get_sort_name(self.name)
+        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
 
     def presave(self):
         """Set computed values."""
@@ -98,7 +103,6 @@ class Volume(BrowserGroupModel):
 
     # Harmful because name is numeric
     sort_name = None
-    custom_cover = None
 
     def set_sort_name(self):
         """Noop."""
@@ -121,21 +125,3 @@ 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."""
-        super().presave()
-        WatchedPath.presave(self)
-
-    class Meta(WatchedPath.Meta):  # type: ignore
-        """Use Mixin Meta."""
-
-        abstract = True
-
-
-class Folder(WatchedPathBrowserGroup):
-    """File system folder."""