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

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):
@@ -66,13 +72,10 @@ class Comic(WatchedPath):
         CBT = "CBT"
         PDF = "PDF"
 
-    ORDERING = (
-        "series__name",
-        "volume__name",
+    _ORDERING = (
         "issue_number",
         "issue_suffix",
-        "name",
-        "pk",
+        "sort_name",
     )
     _RE_COMBINE_WHITESPACE = re.compile(r"\s+")
 
@@ -171,10 +174,12 @@ class Comic(WatchedPath):
         default="",
     )
 
-    class Meta(WatchedPath.Meta):
+    # Not useful
+    custom_cover = None
+
+    class Meta(WatchedPathBrowserGroup.Meta):
         """Constraints."""
 
-        unique_together = ("library", "path")
         verbose_name = "Issue"
 
     def _set_date(self):
@@ -199,6 +204,7 @@ class Comic(WatchedPath):
 
     def presave(self):
         """Set computed values."""
+        super().presave()
         self._set_date()
         self._set_decade()
         self.size = Path(self.path).stat().st_size
@@ -208,11 +214,6 @@ class Comic(WatchedPath):
         """Calculate max page from page_count."""
         return max(self.page_count - 1, 0)
 
-    def save(self, *args, **kwargs):
-        """Save computed fields."""
-        self.presave()
-        super().save(*args, **kwargs)
-
     @staticmethod
     def _compute_zero_pad(issue_number_max):
         """Compute zero padding for issues."""
@@ -222,9 +223,31 @@ class Comic(WatchedPath):
             return 1
         return math.floor(math.log10(issue_number_max)) + 1
 
+    def get_filename(self):
+        """Return filename from path as a property."""
+        return Path(self.path).name
+
+    @classmethod
+    def _get_title_issue_str(cls, obj, zero_pad):
+        """Get the issue parts of the title."""
+        issue_str = ""
+        if obj.issue_number is not None:
+            issue_number = obj.issue_number.normalize()
+            if not zero_pad:
+                zero_pad = 3
+            if issue_number % 1 == 0:
+                precision = 0
+            else:
+                precision = 1
+                zero_pad += 2
+            issue_str = f"#{issue_number:0{zero_pad}.{precision}f}"
+        if issue_suffix := obj.issue_suffix:
+            issue_str += issue_suffix
+        return issue_str
+
     @classmethod
     def get_title(  # noqa: PLR0913
-        cls, obj, volume=True, issue_number_max=None, name=True, filename_fallback=False
+        cls, obj, volume=True, zero_pad=None, name=True, filename_fallback=False
     ):
         """Create the comic title for display."""
         names = []
@@ -239,19 +262,7 @@ class Comic(WatchedPath):
             names.append(vn)
 
         # Issue
-        issue_str = ""
-        if obj.issue_number is not None:
-            issue_number = obj.issue_number.normalize()
-            zero_pad = cls._compute_zero_pad(issue_number_max)
-            if issue_number % 1 == 0:
-                precision = 0
-            else:
-                precision = 1
-                zero_pad += 2
-            issue_str = f"#{issue_number:0{zero_pad}.{precision}f}"
-        if issue_suffix := obj.issue_suffix:
-            issue_str += issue_suffix
-        if issue_str:
+        if issue_str := cls._get_title_issue_str(obj, zero_pad):
             names.append(issue_str)
 
         # Title
@@ -261,19 +272,9 @@ class Comic(WatchedPath):
         title = " ".join(filter(None, names)).strip(" .")
         title = cls._RE_COMBINE_WHITESPACE.sub(" ", title).strip()
         if filename_fallback and not title:
-            title = cls.get_filename(obj)
+            title = obj.get_filename()
         return title
 
-    @classmethod
-    def get_filename(cls, obj):
-        """Get the fileaname from dict."""
-        path = Path(obj.path)
-        return path.stem + path.suffix
-
-    def filename(self):
-        """Create a filename for download."""
-        return self.get_filename(self)
-
     def __str__(self):
         """Most common text representation for logging."""
         return self.get_title(self, filename_fallback=True)

codex/models/functions.py

@@ -0,0 +1,12 @@
+"""Custom Django DB functions."""
+
+from django.db.models import Aggregate, JSONField
+
+
+class JsonGroupArray(Aggregate):
+    """Sqlite3 json_group_array() function."""
+
+    allow_distinct = True
+    function = "JSON_GROUP_ARRAY"
+    name = "JsonGroupArray"
+    output_field = JSONField()  # type: ignore

codex/models/groups.py

@@ -1,25 +1,43 @@
 """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.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):
     """Browser groups."""
 
     DEFAULT_NAME = ""
-    ORDERING = ("name", "pk")
+    PARENT = ""
 
     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)
+
+    def presave(self):
+        """Set computed values."""
+        self.set_sort_name()
+
+    def save(self, *args, **kwargs):
+        """Save computed fields."""
+        self.presave()
+        super().save(*args, **kwargs)
 
     class Meta(BaseModel.Meta):
         """Without this a real table is created and joined to."""
@@ -39,7 +57,7 @@ class Publisher(BrowserGroupModel):
 class Imprint(BrowserGroupModel):
     """A Publishing imprint."""
 
-    ORDERING = ("publisher__name", "name", "pk")
+    PARENT = "publisher"
 
     publisher = ForeignKey(Publisher, on_delete=CASCADE)
 
@@ -52,6 +70,8 @@ class Imprint(BrowserGroupModel):
 class Series(BrowserGroupModel):
     """The series the comic belongs to."""
 
+    PARENT = "imprint"
+
     publisher = ForeignKey(Publisher, on_delete=CASCADE)
     imprint = ForeignKey(Imprint, on_delete=CASCADE)
     volume_count = PositiveSmallIntegerField(null=True)
@@ -67,7 +87,7 @@ class Volume(BrowserGroupModel):
     """The volume of the series the comic belongs to."""
 
     DEFAULT_NAME = None
-    ORDERING = ("series__name", "name", "pk")
+    PARENT = "series"
     YEAR_LEN = 4
 
     publisher = ForeignKey(Publisher, on_delete=CASCADE)
@@ -76,6 +96,13 @@ class Volume(BrowserGroupModel):
     issue_count = PositiveSmallIntegerField(null=True)
     name = SmallIntegerField(db_index=True, null=True, default=DEFAULT_NAME)
 
+    # Harmful because name is numeric
+    sort_name = None
+    custom_cover = None
+
+    def set_sort_name(self):
+        """Noop."""
+
     class Meta(BrowserGroupModel.Meta):
         """Constraints."""
 
@@ -84,12 +111,31 @@ class Volume(BrowserGroupModel):
     @classmethod
     def to_str(cls, name):
         """Represent volume as a string."""
-        if name in (None, ""):
-            return ""
-
-        name = str(name)
-        return f"({name})" if len(name) == cls.YEAR_LEN else "v" + name
+        if name is None:
+            rep = ""
+        else:
+            name = str(name)
+            rep = f"({name})" if len(name) == cls.YEAR_LEN else "v" + name
+        return rep
 
     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."""

codex/models/library.py

@@ -2,6 +2,7 @@
 
 from datetime import timedelta
 from pathlib import Path
+from types import MappingProxyType
 
 from django.contrib.auth.models import Group
 from django.core.exceptions import ValidationError
@@ -32,7 +33,14 @@ class Library(BaseModel):
 
     DEFAULT_POLL_EVERY_SECONDS = 60 * 60
     DEFAULT_POLL_EVERY = timedelta(seconds=DEFAULT_POLL_EVERY_SECONDS)
-
+    CUSTOM_COVERS_DIR_DEFAULTS = MappingProxyType(
+        {
+            "covers_only": True,
+            "events": False,
+            "poll": False,
+        }
+    )
+    covers_only = BooleanField(db_index=True, default=False)
     path = CharField(
         unique=True,
         db_index=True,
@@ -46,9 +54,9 @@ class Library(BaseModel):
     update_in_progress = BooleanField(default=False)
     groups = ManyToManyField(Group, blank=True)
 
-    def __str__(self):
+    def __str__(self) -> str:
         """Return the path."""
-        return self.path
+        return str(self.path)
 
     class Meta(BaseModel.Meta):
         """Pluralize."""

codex/models/paths.py

@@ -1,32 +1,35 @@
 """Watched Path models."""
 
 from pathlib import Path
+from types import MappingProxyType
 
 from django.db.models import CASCADE, CharField, ForeignKey, JSONField
+from django.db.models.enums import Choices
 
-from codex.models.base import MAX_NAME_LEN
-from codex.models.groups import BrowserGroupModel
+from codex.models.base import MAX_NAME_LEN, BaseModel
 from codex.models.library import MAX_PATH_LEN, Library
+from codex.models.util import get_sort_name
 
-__all__ = ("WatchedPath", "Folder", "FailedImport")
+__all__ = ("CustomCover", "FailedImport")
 
 
-class WatchedPath(BrowserGroupModel):
+class WatchedPath(BaseModel):
     """A filesystem path with data for Watchdog."""
 
     library = ForeignKey(Library, on_delete=CASCADE, db_index=True)
-    path = CharField(max_length=MAX_PATH_LEN, db_index=True)
-    stat = JSONField(null=True)
     parent_folder = ForeignKey(
         "Folder",
         on_delete=CASCADE,
         null=True,
     )
+    path = CharField(max_length=MAX_PATH_LEN, db_index=True)
+    stat = JSONField(null=True)
     ZERO_STAT = (0, 0, 0, 0, 0, 0, 0, 0, 0.0, 0)
 
     def set_stat(self):
         """Set select stat params from the filesystem."""
-        st_record = Path(self.path).stat()
+        path = Path(str(self.path))
+        st_record = path.stat()
         # Converting os.stat directly to a list or tuple saves
         # mtime as an int and causes problems.
         st = list(self.ZERO_STAT)
@@ -41,12 +44,16 @@ class WatchedPath(BrowserGroupModel):
         st[8] = st_record.st_mtime
         self.stat = st
 
+    def presave(self):
+        """Save stat."""
+        self.set_stat()
+
     def __str__(self):
         """Return the full path."""
-        return self.path
+        return str(self.path)
 
-    class Meta(BrowserGroupModel.Meta):
-        """Constraints."""
+    class Meta(BaseModel.Meta):
+        """Use Mixin Meta."""
 
         unique_together = ("library", "path")
         abstract = True
@@ -56,13 +63,11 @@ class WatchedPath(BrowserGroupModel):
         return self.path.removeprefix(self.library.path)
 
 
-class Folder(WatchedPath):
-    """File system folder."""
-
-
 class FailedImport(WatchedPath):
     """Failed Comic Imports. Displayed in Admin Panel."""
 
+    name = CharField(db_index=True, max_length=MAX_NAME_LEN, default="")
+
     def set_reason(self, exc):
         """Can't do this in save() because it breaks update_or_create."""
         reason = str(exc)
@@ -71,3 +76,46 @@ class FailedImport(WatchedPath):
             reason = reason.removesuffix(suffix)
         reason = reason[:MAX_NAME_LEN]
         self.name = reason.strip()
+
+
+class CustomCover(WatchedPath):
+    """Custom Cover Image."""
+
+    class GroupChoice(Choices):
+        """Reading direction choices."""
+
+        P = "p"
+        I = "i"  # noqa: E741
+        S = "s"
+        A = "a"
+        F = "f"
+
+    FOLDER_COVER_STEM = ".codex-cover"
+    DIR_GROUP_CHOICE_MAP = MappingProxyType(
+        {
+            "publishers": GroupChoice.P,
+            "imprints": GroupChoice.I,
+            "series": GroupChoice.S,
+            "story-arcs": GroupChoice.A,
+        }
+    )
+
+    parent_folder = None
+    group = CharField(max_length=1, db_index=True, choices=GroupChoice.choices)
+    sort_name = CharField(max_length=MAX_NAME_LEN, db_index=True, default="")
+
+    def _set_group_and_sort_name(self):
+        """Set group and sort_name from path."""
+        path = Path(self.path)
+        stem = path.stem
+        if stem == self.FOLDER_COVER_STEM:
+            self.group = self.GroupChoice.F.value
+        else:
+            choice = self.DIR_GROUP_CHOICE_MAP[path.parent.name]
+            self.group = choice.value
+            self.sort_name = get_sort_name(stem)
+
+    def presave(self):
+        """Presave group and sort_name."""
+        super().presave()
+        self._set_group_and_sort_name()

codex/models/query.py

@@ -0,0 +1,91 @@
+"""Custom Compiler to force group_by."""
+# If any group_by() is attached to the QuerySet, it completely overrides the compiler computed group_by
+
+from django.db import connections
+from django.db.models import Manager
+from django.db.models.query import QuerySet
+from django.db.models.sql.compiler import SQLCompiler
+from django.db.models.sql.query import Query
+
+
+class GroupBySQLCompiler(SQLCompiler):
+    """Custom Compiler to force group_by."""
+
+    def __init__(self, *args, **kwargs):
+        """Initialize force group_by fields."""
+        super().__init__(*args, **kwargs)
+        self.force_group_by_table = ""
+        self.force_group_by_fields = ()
+
+    def set_force_group_by(self, table, fields):
+        """Set the force group_by variables."""
+        self.force_group_by_table = table
+        self.force_group_by_fields = fields
+
+    def get_group_by(self, *args, **kwargs):
+        """If force group_by set, force it."""
+        if self.force_group_by_table and self.force_group_by_fields:
+            table = self.force_group_by_table
+            group_by = []
+            for field in self.force_group_by_fields:
+                field_str = f'"{table}"."{field}"'
+                entry = (field_str, ())
+                group_by.append(entry)
+        else:
+            group_by = super().get_group_by(*args, **kwargs)
+        return group_by
+
+
+class GroupByQuery(Query):
+    """Custom Query to use GroupBy Compiler."""
+
+    def __init__(self, *args, **kwargs):
+        """Init force group_by fields."""
+        super().__init__(*args, **kwargs)
+        self.force_group_by_table = ""
+        self.force_group_by_fields = ()
+
+    def get_compiler(self, using=None, connection=None, elide_empty=True):
+        """Use the custom compiler instead of SQLCompiler."""
+        if self.compiler == "SQLCompiler":
+            if using is None and connection is None:
+                reason = "Need either using or connection"
+                raise ValueError(reason)
+            if using:
+                connection = connections[using]
+            compiler = GroupBySQLCompiler(self, connection, using, elide_empty)
+            compiler.set_force_group_by(
+                self.force_group_by_table, self.force_group_by_fields
+            )
+        else:
+            # Normal super() operation.
+            compiler = super().get_compiler(using, connection, elide_empty)  # type: ignore
+
+        return compiler
+
+    def set_force_group_by(self, fields, model=None):
+        """Set the force group_by fields."""
+        if not model:
+            model = self.model
+        table = model._meta.db_table if model else ""
+        self.force_group_by_table = table
+        self.force_group_by_fields = fields
+
+
+class GroupByQuerySet(QuerySet):
+    """Custom Queryset that uses Custom compiler."""
+
+    def __init__(self, model=None, query=None, using=None, hints=None):
+        """Use the custom query with the custom compiler."""
+        query = query or GroupByQuery(model)
+        super().__init__(model=model, query=query, using=using, hints=hints)
+
+    def group_by(self, *fields, model=None):
+        """Force group_by operator."""
+        obj = self._chain()  # type: ignore
+        obj.query.set_force_group_by(fields, model=model)
+        return obj
+
+
+class GroupByManager(Manager.from_queryset(GroupByQuerySet)):
+    """Use GroupBy QuerySet."""

codex/models/util.py

@@ -0,0 +1,31 @@
+"""Utilities for models."""
+
+_ARTICLES = frozenset(
+    ("a", "an", "the")  # en    # noqa RUF005
+    + ("un", "unos", "unas", "el", "los", "la", "las")  # es
+    + ("un", "une", "le", "les", "la", "les", "l'")  # fr
+    + ("o", "a", "os")  # pt
+    # pt "as" conflicts with English
+    + ("der", "dem", "des", "das")  # de
+    # de: "den & die conflict with English
+    + ("il", "lo", "gli", "la", "le", "l'")  # it
+    # it: "i" conflicts with English
+    + ("de", "het", "een")  # nl
+    + ("en", "ett")  # sw
+    + ("en", "ei", "et")  # no
+    + ("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/permissions.py

@@ -8,7 +8,7 @@ from codex.models import Timestamp
 class HasAPIKeyOrIsAdminUser(BasePermission):
     """Does the request have the current api key."""
 
-    def has_permission(self, request, view):
+    def has_permission(self, request, view):  # type: ignore
         """Test the request api key against the database."""
         data = request.GET if request.method == "GET" else request.POST
         api_key = data.get("apiKey")

codex/search/backend.py

@@ -36,6 +36,7 @@ from codex.librarian.search.status import SearchIndexStatusTypes
 from codex.logger.logging import get_logger
 from codex.memory import get_mem_limit
 from codex.models import AdminFlag, Comic
+from codex.search.backend_search import CodexBackendSearchMixin
 from codex.search.indexes import ComicIndex
 from codex.search.writing import CodexWriter
 from codex.settings.settings import (
@@ -103,7 +104,7 @@ TEXT_ANALYZER = (
 )
 
 
-class CodexSearchBackend(WhooshSearchBackend, WorkerBaseMixin):
+class CodexSearchBackend(CodexBackendSearchMixin, WhooshSearchBackend, WorkerBaseMixin):
     """Custom Whoosh Backend."""
 
     FIELDMAP = MappingProxyType(
@@ -266,7 +267,6 @@ class CodexSearchBackend(WhooshSearchBackend, WorkerBaseMixin):
                     stored=True,
                     analyzer=TEXT_ANALYZER,
                     field_boost=field_class.boost,
-                    spelling=field_class.document is True,
                 )
                 if field_class.document:
                     content_field_name = index_fieldname