codex 1.7.15__py3-none-any.whl → 1.8.0__py3-none-any.whl

codex/models/groups.py

@@ -1,33 +1,41 @@
 """Browser Group models."""
 
 from django.db.models import CASCADE, SET_DEFAULT, ForeignKey
-from django.db.models.fields import (
-    CharField,
-    PositiveSmallIntegerField,
-    SmallIntegerField,
-)
+from typing_extensions import override
 
 from codex.models.base import MAX_NAME_LEN, BaseModel
+from codex.models.fields import CleaningCharField, CoercingPositiveSmallIntegerField
+from codex.models.identifier import Identifier
 from codex.models.paths import CustomCover, WatchedPath
 from codex.models.util import get_sort_name
 
-__all__ = ("BrowserGroupModel", "Folder", "Imprint", "Publisher", "Series", "Volume")
+__all__ = (
+    "BrowserGroupModel",
+    "Folder",
+    "IdentifiedBrowserGroupModel",
+    "Imprint",
+    "Publisher",
+    "Series",
+    "Volume",
+)
 
 
 class BrowserGroupModel(BaseModel):
     """Browser groups."""
 
-    DEFAULT_NAME = ""
-    PARENT = ""
+    DEFAULT_NAME: str | None = ""
+    PARENT: str = ""
 
-    name = CharField(db_index=True, max_length=MAX_NAME_LEN, default=DEFAULT_NAME)
-    sort_name = CharField(
+    name = CleaningCharField(
+        db_index=True, max_length=MAX_NAME_LEN, default=DEFAULT_NAME
+    )
+    sort_name = CleaningCharField(
         db_index=True,
         max_length=MAX_NAME_LEN,
         default=DEFAULT_NAME,
         db_collation="nocase",
     )
-    custom_cover = ForeignKey(
+    custom_cover: ForeignKey | None = ForeignKey(
         CustomCover, on_delete=SET_DEFAULT, null=True, default=None
     )
 
@@ -35,10 +43,12 @@ class BrowserGroupModel(BaseModel):
         """Create sort_name for model."""
         self.sort_name = get_sort_name(self.name)
 
+    @override
     def presave(self):
         """Set computed values."""
         self.set_sort_name()
 
+    @override
     def save(self, *args, **kwargs):
         """Save computed fields."""
         self.presave()
@@ -49,88 +59,143 @@ class BrowserGroupModel(BaseModel):
 
         abstract = True
 
+    def _repr_parts(self) -> tuple[str, ...]:
+        return (self.name,)
 
-class Publisher(BrowserGroupModel):
-    """The publisher of the comic."""
+    @override
+    def __repr__(self):
+        """Represent as string."""
+        return "/".join(self._repr_parts())
+
+
+class IdentifiedBrowserGroupModel(BrowserGroupModel):
+    """
+    Identified Browser Group Model.
+
+    Comicbox objects can have multiple identifiers, but if I let BrowserGroups have them
+    then it would impossible to unlink a second level m2m relationship when comics are
+    deleted. So I choose the highest priority one in import.
+    Additionally, Browser groups will update to the highest priority identifier by
+    source instead of creating duplicate groups to keep the hierarchy consolitated.
+    """
+
+    identifier = ForeignKey(Identifier, on_delete=CASCADE, null=True)
 
     class Meta(BrowserGroupModel.Meta):
+        """Without this a real table is created and joined to."""
+
+        abstract = True
+
+
+class Publisher(IdentifiedBrowserGroupModel):
+    """The publisher of the comic."""
+
+    class Meta(IdentifiedBrowserGroupModel.Meta):
         """Constraints."""
 
         unique_together = ("name",)
 
 
-class Imprint(BrowserGroupModel):
+class Imprint(IdentifiedBrowserGroupModel):
     """A Publishing imprint."""
 
-    PARENT = "publisher"
+    PARENT: str = "publisher"
 
     publisher = ForeignKey(Publisher, on_delete=CASCADE)
 
-    class Meta(BrowserGroupModel.Meta):
+    class Meta(IdentifiedBrowserGroupModel.Meta):
         """Constraints."""
 
-        unique_together = ("name", "publisher")
+        unique_together = ("publisher", "name")
 
+    @override
+    def _repr_parts(self):
+        return (self.publisher.name, self.name)
 
-class Series(BrowserGroupModel):
+
+class Series(IdentifiedBrowserGroupModel):
     """The series the comic belongs to."""
 
-    PARENT = "imprint"
+    PARENT: str = "imprint"
 
     publisher = ForeignKey(Publisher, on_delete=CASCADE)
     imprint = ForeignKey(Imprint, on_delete=CASCADE)
-    volume_count = PositiveSmallIntegerField(null=True)
+    volume_count = CoercingPositiveSmallIntegerField(null=True)
 
-    class Meta(BrowserGroupModel.Meta):
+    class Meta(IdentifiedBrowserGroupModel.Meta):
         """Constraints."""
 
-        unique_together = ("name", "imprint")
+        unique_together = ("imprint", "name")
         verbose_name_plural = "Series"
 
+    @override
+    def _repr_parts(self):
+        return (
+            self.publisher.name,
+            self.imprint.name,
+            self.name,
+        )
+
 
 class Volume(BrowserGroupModel):
     """The volume of the series the comic belongs to."""
 
-    DEFAULT_NAME = None
-    PARENT = "series"
+    DEFAULT_NAME: str | None = None
+    PARENT: str = "series"
     YEAR_LEN = 4
 
     publisher = ForeignKey(Publisher, on_delete=CASCADE)
     imprint = ForeignKey(Imprint, on_delete=CASCADE)
     series = ForeignKey(Series, on_delete=CASCADE)
-    issue_count = PositiveSmallIntegerField(null=True)
-    name = SmallIntegerField(db_index=True, null=True, default=DEFAULT_NAME)
+    issue_count = CoercingPositiveSmallIntegerField(null=True)
+    name = CoercingPositiveSmallIntegerField(  # pyright: ignore[reportIncompatibleUnannotatedOverride]
+        db_index=True, null=True, default=DEFAULT_NAME
+    )
+    number_to = CoercingPositiveSmallIntegerField(
+        db_index=True, null=True, default=DEFAULT_NAME
+    )
 
     # Harmful because name is numeric
-    sort_name = None
+    sort_name = None  # pyright: ignore[reportIncompatibleUnannotatedOverride]
     custom_cover = None
 
+    @override
     def set_sort_name(self):
         """Noop."""
 
     class Meta(BrowserGroupModel.Meta):
         """Constraints."""
 
-        unique_together = ("name", "series")
+        unique_together = ("series", "name", "number_to")
 
     @classmethod
-    def to_str(cls, name):
+    def to_str(cls, number: int | None, number_to: int | None):
         """Represent volume as a string."""
-        if name is None:
+        if number is None:
             rep = ""
         else:
-            name = str(name)
-            rep = f"({name})" if len(name) == cls.YEAR_LEN else "v" + name
+            number_str = str(number)
+            is_year = len(number_str) == cls.YEAR_LEN
+            numbers_strs = (number_str, str(number_to))
+            numbers_str = "-".join(numbers_strs)
+            rep = f"({numbers_str})" if is_year else f"v{numbers_str}"
         return rep
 
-    def __str__(self):
+    @override
+    def _repr_parts(self):
         """Represent volume as a string."""
-        return self.to_str(self.name)
+        return (
+            self.publisher.name,
+            self.imprint.name,
+            self.series.name,
+            self.to_str(self.name, self.number_to),
+        )
 
 
 class WatchedPathBrowserGroup(BrowserGroupModel, WatchedPath):
     """Watched Path Browser Group."""
 
+    @override
     def presave(self):
         """Fix multiple inheritance presave."""
         super().presave()

codex/models/identifier.py

@@ -0,0 +1,79 @@
+"""Identifier Models."""
+
+from django.db.models import (
+    CASCADE,
+    CharField,
+    ForeignKey,
+    TextChoices,
+    URLField,
+)
+from typing_extensions import override
+
+from codex.models.base import MAX_NAME_LEN, BaseModel, NamedModel
+from codex.models.fields import CleaningCharField
+
+__all__ = ("Identifier", "IdentifierSource", "NamedModel")
+
+_IDENTIFIER_TYPE_MAX_LENGTH = 16
+
+
+class IdentifierSource(NamedModel):
+    """A an Identifier's source."""
+
+
+class IdentifierType(TextChoices):
+    """
+    The identifier type for the source.
+
+    Values are table names.
+    """
+
+    ARC = "storyarc"
+    CHARACTER = "character"
+    GENRE = "genre"
+    IMPRINT = "imprint"
+    ISSUE = "comic"
+    LOCATION = "location"
+    PUBLISHER = "publisher"
+    # REPRINT = "reprint" not yet implemented
+    SERIES = "series"
+    STORY = "story"
+    TAG = "tag"
+    TEAM = "team"
+    UNIVERSE = "universe"
+    ROLE = "creditrole"
+    CREATOR = "creditperson"
+
+
+class Identifier(BaseModel):
+    """
+    A method of identifying the comic.
+
+    The only class with a url.
+    """
+
+    source = ForeignKey(IdentifierSource, db_index=True, on_delete=CASCADE, null=True)
+    id_type = CharField(
+        choices=IdentifierType.choices,
+        db_index=True,
+        max_length=_IDENTIFIER_TYPE_MAX_LENGTH,
+    )
+    key = CleaningCharField(max_length=MAX_NAME_LEN)
+    url = URLField(default="")
+
+    class Meta(BaseModel.Meta):
+        """Declare constraints and indexes."""
+
+        unique_together: tuple[str, ...] = ("source", "id_type", "key")
+
+    @property
+    def name(self):
+        """Provide a urn like name to imitate a NamedModel."""
+        source_name = f"{self.source.name}:" if self.source else ""
+        parts = (source_name, self.id_type, self.key)
+        return ":".join(parts)
+
+    @override
+    def __repr__(self):
+        """Represent as a string."""
+        return self.name + ":" + self.url

codex/models/library.py

@@ -8,14 +8,15 @@ from django.contrib.auth.models import Group
 from django.core.exceptions import ValidationError
 from django.db.models import (
     BooleanField,
-    CharField,
     DateTimeField,
     DurationField,
     ManyToManyField,
 )
 from django.utils.translation import gettext_lazy as _
+from typing_extensions import override
 
 from codex.models.base import MAX_PATH_LEN, BaseModel
+from codex.models.fields import CleaningCharField
 
 __all__ = ("Library", "validate_dir_exists")
 
@@ -39,7 +40,7 @@ class Library(BaseModel):
         }
     )
     covers_only = BooleanField(db_index=True, default=False)
-    path = CharField(
+    path = CleaningCharField(
         unique=True,
         db_index=True,
         max_length=MAX_PATH_LEN,
@@ -52,7 +53,8 @@ class Library(BaseModel):
     update_in_progress = BooleanField(default=False)
     groups = ManyToManyField(Group, blank=True)
 
-    def __str__(self) -> str:
+    @override
+    def __repr__(self) -> str:
         """Return the path."""
         return str(self.path)
 
@@ -60,3 +62,15 @@ class Library(BaseModel):
         """Pluralize."""
 
         verbose_name_plural = "Libraries"
+
+    def _save_update_in_progress(self, *, value: bool):
+        self.update_in_progress = value
+        self.save(update_fields=["update_in_progress"])
+
+    def start_update(self):
+        """Start a library update."""
+        self._save_update_in_progress(value=True)
+
+    def end_update(self):
+        """Finish a library update."""
+        self._save_update_in_progress(value=False)

codex/models/named.py

@@ -2,25 +2,23 @@
 
 from django.db.models import (
     CASCADE,
-    CharField,
     ForeignKey,
-    PositiveIntegerField,
-    URLField,
 )
+from typing_extensions import override
 
-from codex.models.base import MAX_NAME_LEN, BaseModel
+from codex.models.base import MAX_NAME_LEN, BaseModel, NamedModel
+from codex.models.fields import CleaningCharField, CoercingPositiveSmallIntegerField
 from codex.models.groups import BrowserGroupModel
+from codex.models.identifier import Identifier
 
 __all__ = (
     "AgeRating",
     "Character",
-    "Contributor",
-    "ContributorPerson",
-    "ContributorRole",
     "Country",
+    "Credit",
+    "CreditPerson",
+    "CreditRole",
     "Genre",
-    "Identifier",
-    "IdentifierType",
     "Language",
     "Location",
     "OriginalFormat",
@@ -32,52 +30,65 @@ __all__ = (
     "Tag",
     "Tagger",
     "Team",
+    "Universe",
 )
 
 
-class NamedModel(BaseModel):
-    """A for simple named tables."""
+class IdentifiedNamedModel(NamedModel):
+    """
+    For NamedModels with Identifiers.
 
-    name = CharField(db_index=True, max_length=MAX_NAME_LEN)
+    Comicbox objects can have multiple identifiers, but if I let NamedModels have them
+    then it would impossible to unlink a second level m2m relationship when comics are
+    deleted. So I choose the highest priority one in import.
+    """
 
-    class Meta(BaseModel.Meta):
+    identifier = ForeignKey(Identifier, on_delete=CASCADE, null=True)
+
+    class Meta(NamedModel.Meta):
         """Defaults to uniquely named, must be overridden."""
 
         abstract = True
-        unique_together = ("name",)
 
-    def __str__(self):
+    @override
+    def __repr__(self):
         """Return the name."""
-        return self.name
+        suffix = ":" + str(self.identifier) if self.identifier else ""
+        return self.name + suffix
 
 
 class AgeRating(NamedModel):
     """The Age Rating the comic was intended for."""
 
 
-class Character(NamedModel):
+class Character(IdentifiedNamedModel):
     """A character that appears in the comic."""
 
 
-class ContributorPerson(NamedModel):
+class CreditPerson(IdentifiedNamedModel):
     """Credited persons."""
 
 
-class ContributorRole(NamedModel):
+class CreditRole(IdentifiedNamedModel):
     """A role for the credited person. Writer, Inker, etc."""
 
 
-class Contributor(BaseModel):
-    """A contributor credit."""
+class Credit(BaseModel):
+    """A credit."""
 
-    person = ForeignKey(ContributorPerson, on_delete=CASCADE)
-    role = ForeignKey(ContributorRole, on_delete=CASCADE, null=True)
+    person = ForeignKey(CreditPerson, on_delete=CASCADE)
+    role = ForeignKey(CreditRole, on_delete=CASCADE, null=True)
 
     class Meta(BaseModel.Meta):
         """Constraints."""
 
         unique_together = ("person", "role")
 
+    @override
+    def __repr__(self):
+        """Return the strings of parts."""
+        return str(self.person) + ":" + str(self.role)
+
 
 class Country(NamedModel):
     """The two letter country code."""
@@ -88,7 +99,7 @@ class Country(NamedModel):
         verbose_name_plural = "Countries"
 
 
-class Genre(NamedModel):
+class Genre(IdentifiedNamedModel):
     """The genre the comic belongs to."""
 
 
@@ -96,7 +107,7 @@ class Language(NamedModel):
     """The two letter language code."""
 
 
-class Location(NamedModel):
+class Location(IdentifiedNamedModel):
     """A location that appears in the comic."""
 
 
@@ -112,19 +123,19 @@ class SeriesGroup(NamedModel):
     """A series group the series is part of."""
 
 
-class Story(NamedModel):
+class Story(IdentifiedNamedModel):
     """A story in a commic."""
 
-    class Meta(NamedModel.Meta):
+    class Meta(IdentifiedNamedModel.Meta):
         """Constraints."""
 
         verbose_name_plural = "Stories"
 
 
-class StoryArc(NamedModel, BrowserGroupModel):
+class StoryArc(IdentifiedNamedModel, BrowserGroupModel):
     """A story arc the comic is part of."""
 
-    class Meta(NamedModel.Meta, BrowserGroupModel.Meta):
+    class Meta(IdentifiedNamedModel.Meta, BrowserGroupModel.Meta):
         """Fix Meta inheritance."""
 
 
@@ -132,7 +143,7 @@ class StoryArcNumber(BaseModel):
     """A story arc number the comic represents."""
 
     story_arc = ForeignKey(StoryArc, db_index=True, on_delete=CASCADE)
-    number = PositiveIntegerField(null=True, default=None)
+    number = CoercingPositiveSmallIntegerField(null=True, default=None)
 
     class Meta(BaseModel.Meta):
         """Declare constraints and indexes."""
@@ -146,7 +157,7 @@ class StoryArcNumber(BaseModel):
         return self.story_arc.name + suffix
 
 
-class Tag(NamedModel):
+class Tag(IdentifiedNamedModel):
     """Arbitrary Metadata Tag."""
 
 
@@ -154,34 +165,20 @@ class Tagger(NamedModel):
     """Tagger program."""
 
 
-class Team(NamedModel):
+class Team(IdentifiedNamedModel):
     """A team that appears in the comic."""
 
 
-class IdentifierType(NamedModel):
-    """A type of identifier."""
-
-
-class Identifier(BaseModel):
-    """A method of identifying the comic."""
+class Universe(IdentifiedNamedModel):
+    """Universe the comic appears in."""
 
-    identifier_type = ForeignKey(
-        IdentifierType, db_index=True, on_delete=CASCADE, null=True
-    )
-    nss = CharField(max_length=MAX_NAME_LEN)
-    url = URLField(default="")
+    designation = CleaningCharField(max_length=MAX_NAME_LEN)
 
-    class Meta(BaseModel.Meta):
-        """Declare constraints and indexes."""
-
-        unique_together = ("identifier_type", "nss")
-
-    @property
-    def name(self):
+    @override
+    def __repr__(self):
         """Provide a name to imitate a NamedModel."""
-        prefix = f"{self.identifier_type.name}:" if self.identifier_type else ""
-        return prefix + self.nss
+        name = self.name + ":" + str(self.designation)
+        if self.identifier:
+            name += ":" + str(self.identifier)
 
-    def __str__(self):
-        """Represent as a string."""
-        return self.name + " " + self.url
+        return name

codex/models/paths.py

@@ -4,9 +4,11 @@ from pathlib import Path
 from types import MappingProxyType
 
 from django.db.models import CASCADE, CharField, ForeignKey, JSONField, TextChoices
+from typing_extensions import override
 
-from codex.models.base import MAX_NAME_LEN, BaseModel, max_choices_len
-from codex.models.library import MAX_PATH_LEN, Library
+from codex.models.base import MAX_NAME_LEN, MAX_PATH_LEN, BaseModel, max_choices_len
+from codex.models.fields import CleaningCharField
+from codex.models.library import Library
 from codex.models.util import get_sort_name
 
 __all__ = ("CustomCover", "FailedImport")
@@ -16,12 +18,12 @@ class WatchedPath(BaseModel):
     """A filesystem path with data for Watchdog."""
 
     library = ForeignKey(Library, on_delete=CASCADE, db_index=True)
-    parent_folder = ForeignKey(
+    parent_folder: ForeignKey | None = ForeignKey(
         "Folder",
         on_delete=CASCADE,
         null=True,
     )
-    path = CharField(max_length=MAX_PATH_LEN, db_index=True)
+    path = CleaningCharField(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)
 
@@ -43,11 +45,13 @@ class WatchedPath(BaseModel):
         st[8] = st_record.st_mtime
         self.stat = st
 
+    @override
     def presave(self):
         """Save stat."""
         self.set_stat()
 
-    def __str__(self):
+    @override
+    def __repr__(self):
         """Return the full path."""
         return str(self.path)
 
@@ -92,14 +96,14 @@ class CustomCover(WatchedPath):
     FOLDER_COVER_STEM = ".codex-cover"
     DIR_GROUP_CHOICE_MAP = MappingProxyType(
         {
-            "publishers": GroupChoice.P,
-            "imprints": GroupChoice.I,
-            "series": GroupChoice.S,
-            "story-arcs": GroupChoice.A,
+            "publishers": GroupChoice.P.value,
+            "imprints": GroupChoice.I.value,
+            "series": GroupChoice.S.value,
+            "story-arcs": GroupChoice.A.value,
         }
     )
 
-    parent_folder = None
+    parent_folder: ForeignKey | None = None
     group = CharField(
         max_length=max_choices_len(GroupChoice),
         db_index=True,
@@ -116,10 +120,10 @@ class CustomCover(WatchedPath):
         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.group = self.DIR_GROUP_CHOICE_MAP[path.parent.name]
             self.sort_name = get_sort_name(stem)
 
+    @override
     def presave(self):
         """Presave group and sort_name."""
         super().presave()