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

codex/models/library.py

@@ -2,7 +2,6 @@
 
 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
@@ -33,14 +32,7 @@ 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,
@@ -54,9 +46,9 @@ class Library(BaseModel):
     update_in_progress = BooleanField(default=False)
     groups = ManyToManyField(Group, blank=True)
 
-    def __str__(self) -> str:
+    def __str__(self):
         """Return the path."""
-        return str(self.path)
+        return self.path
 
     class Meta(BaseModel.Meta):
         """Pluralize."""

codex/models/paths.py

@@ -1,35 +1,32 @@
 """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, BaseModel
+from codex.models.base import MAX_NAME_LEN
+from codex.models.groups import BrowserGroupModel
 from codex.models.library import MAX_PATH_LEN, Library
-from codex.models.util import get_sort_name
 
-__all__ = ("CustomCover", "FailedImport")
+__all__ = ("WatchedPath", "Folder", "FailedImport")
 
 
-class WatchedPath(BaseModel):
+class WatchedPath(BrowserGroupModel):
     """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."""
-        path = Path(str(self.path))
-        st_record = path.stat()
+        st_record = Path(self.path).stat()
         # Converting os.stat directly to a list or tuple saves
         # mtime as an int and causes problems.
         st = list(self.ZERO_STAT)
@@ -46,28 +43,27 @@ class WatchedPath(BaseModel):
 
     def presave(self):
         """Save stat."""
+        super().presave()
         self.set_stat()
 
     def __str__(self):
         """Return the full path."""
-        return str(self.path)
+        return self.path
 
-    class Meta(BaseModel.Meta):
-        """Use Mixin Meta."""
+    class Meta(BrowserGroupModel.Meta):
+        """Constraints."""
 
         unique_together = ("library", "path")
         abstract = True
 
-    def search_path(self) -> str:
-        """Relative path for search index."""
-        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)
@@ -76,46 +72,3 @@ 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/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):  # type: ignore
+    def has_permission(self, request, view):
         """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_search.py

@@ -3,6 +3,14 @@
 import warnings
 from datetime import date, datetime
 
+from _vendor.haystack.backends import (
+    log_query,
+)
+from _vendor.haystack.constants import (
+    DJANGO_CT,
+)
+from _vendor.haystack.exceptions import SearchBackendError
+from _vendor.haystack.utils import get_model_ct
 from django.conf import settings
 from django.utils.encoding import force_str
 
@@ -10,11 +18,6 @@ from django.utils.encoding import force_str
 from whoosh.sorting import Count, DateRangeFacet, FieldFacet
 from whoosh.support.relativedelta import relativedelta as RelativeDelta
 
-from codex._vendor.haystack.backends import log_query
-from codex._vendor.haystack.constants import DJANGO_CT
-from codex._vendor.haystack.exceptions import SearchBackendError
-from codex._vendor.haystack.utils import get_model_ct
-
 
 class CodexBackendSearchMixin:
     @log_query

codex/search/query.py

@@ -3,7 +3,6 @@
 from codex._vendor.haystack.backends.whoosh_backend import (
     WhooshSearchQuery,
 )
-from codex._vendor.haystack.constants import DJANGO_ID
 from codex._vendor.haystack.query import SearchQuerySet
 
 
@@ -13,8 +12,7 @@ class CodexSearchQuery(WhooshSearchQuery):
     def __init__(self, *args, **kwargs):
         """Give CodexSearchQuery a reverse attribute."""
         super().__init__(*args, **kwargs)
-        self._reverse: bool = False
-        self._filter_comic_ids: frozenset | None = None
+        self._reverse = False
 
     def clean(self, query_fragment):
         """Optimize to noop because RESERVED_ consts are empty in the backend."""
@@ -24,23 +22,9 @@ class CodexSearchQuery(WhooshSearchQuery):
         """Invert the reverse attribute."""
         self._reverse = not self._reverse
 
-    def filter_comic_ids(self, ids):
-        """Set a filter for the query."""
-        self._filter_comic_ids = frozenset(ids)
-
     def get_results(self, **kwargs):
         """Send custom get results the reverse flag."""
-        custom_params = {}
-        if self._reverse:
-            custom_params["reverse"] = self._reverse
-
-        if self._filter_comic_ids:
-            filter_query = " OR ".join(
-                [f"{DJANGO_ID}:{pk}" for pk in self._filter_comic_ids]
-            )
-            custom_params["narrow_queries"] = {filter_query}
-
-        return super().get_results(**custom_params, **kwargs)
+        return super().get_results(reverse=self._reverse, **kwargs)
 
 
 class CodexSearchQuerySet(SearchQuerySet):
@@ -52,16 +36,9 @@ class CodexSearchQuerySet(SearchQuerySet):
         clone.query.order_reverse()  # type: ignore
         return clone
 
-    def filter_comic_ids(self, ids):
-        """Filter search by comic ids."""
-        clone = self._clone()
-        clone.query.filter_comic_ids(ids)  # type: ignore
-        return clone
-
     def values_list(self, *args, **kwargs):
         """Copy reverse setting into CodexSearchQuery."""
         clone = super().values_list(*args, **kwargs)
         if clone.query and self.query:
             clone.query._reverse = self.query._reverse  # noqa: SLF001
-            clone.query._filter_comic_ids = self.query._filter_comic_ids  # noqa: SLF001
         return clone

codex/search/writing.py

@@ -16,7 +16,7 @@ class CodexWriter(BufferedWriter):
     """MP safe Buffered Writer that locks the index writer much more granularly.
 
     XXX The period and limit args are ignored and this writer behaves more like the
-    AsycWriter. The AsyncWriter could possibly be extended to not lock until commit
+    AsycnWriter. The AsyncWriter could possibly be extended to not lock until commit
     time like this one and use less code.
     """
 

codex/serializers/admin.py

@@ -101,17 +101,8 @@ class LibrarySerializer(BaseModelSerializer):
         """Specify Model."""
 
         model = Library
-        fields = (
-            "pk",
-            "path",
-            "events",
-            "last_poll",
-            "poll",
-            "poll_every",
-            "groups",
-            "covers_only",
-        )
-        read_only_fields = ("last_poll", "pk", "covers_only")
+        fields = ("pk", "events", "groups", "last_poll", "path", "poll", "poll_every")
+        read_only_fields = ("last_poll", "pk")
 
     def validate_path(self, path):
         """Validate new library paths."""
@@ -173,7 +164,8 @@ class AdminFolderSerializer(Serializer):
     def validate_show_hidden(self, show_hidden):
         """Snakecase the showHidden field."""
         return (
-            show_hidden == "true" or self.initial_data.get("showHidden") == "true"  # type: ignore
+            show_hidden == "true"
+            or self.initial_data.get("showHidden", False) == "true"
         )
 
 
@@ -181,68 +173,67 @@ class AdminGroupSerializer(Serializer):
     """Group Counts."""
 
     publishers_count = IntegerField(required=False, read_only=True)
-    imprints_count = IntegerField(required=False, read_only=True)
-    series_count = IntegerField(required=False, read_only=True)
-    volumes_count = IntegerField(required=False, read_only=True)
-    issues_count = IntegerField(required=False, read_only=True)
-    folders_count = IntegerField(required=False, read_only=True)
-    story_arcs_count = IntegerField(required=False, read_only=True)
+    imprints_count = IntegerField(required=False)
+    series_count = IntegerField(required=False)
+    volumes_count = IntegerField(required=False)
+    issues_count = IntegerField(required=False)
+    folders_count = IntegerField(required=False)
 
 
 class AdminFileTypeSerializer(Serializer):
     """File Type Counts."""
 
-    pdf_count = IntegerField(required=False, read_only=True)
-    cbz_count = IntegerField(required=False, read_only=True)
-    cbr_count = IntegerField(required=False, read_only=True)
-    cbt_count = IntegerField(required=False, read_only=True)
-    unknown_count = IntegerField(required=False, read_only=True)
+    pdf_count = IntegerField(required=False)
+    cbz_count = IntegerField(required=False)
+    cbr_count = IntegerField(required=False)
+    cbt_count = IntegerField(required=False)
+    unknown_count = IntegerField(required=False)
 
 
 class AdminComicMetadataSerializer(Serializer):
     """Metadata Counts."""
 
-    age_ratings_count = IntegerField(required=False, read_only=True)
-    characters_count = IntegerField(required=False, read_only=True)
-    contributors_count = IntegerField(required=False, read_only=True)
-    contributor_persons_count = IntegerField(required=False, read_only=True)
-    contributor_roles_count = IntegerField(required=False, read_only=True)
-    countries_count = IntegerField(required=False, read_only=True)
-    genres_count = IntegerField(required=False, read_only=True)
-    identifiers_count = IntegerField(required=False, read_only=True)
-    identifier_types_count = IntegerField(required=False, read_only=True)
-    languages_count = IntegerField(required=False, read_only=True)
-    locations_count = IntegerField(required=False, read_only=True)
-    original_formats_count = IntegerField(required=False, read_only=True)
-    series_groups_count = IntegerField(required=False, read_only=True)
-    scan_infos_count = IntegerField(required=False, read_only=True)
+    age_ratings_count = IntegerField(required=False)
+    characters_count = IntegerField(required=False)
+    contributors_count = IntegerField(required=False)
+    contributor_persons_count = IntegerField(required=False)
+    contributor_roles_count = IntegerField(required=False)
+    countries_count = IntegerField(required=False)
+    genres_count = IntegerField(required=False)
+    identifiers_count = IntegerField(required=False)
+    identifier_types_count = IntegerField(required=False)
+    languages_count = IntegerField(required=False)
+    locations_count = IntegerField(required=False)
+    original_formats_count = IntegerField(required=False)
+    series_groups_count = IntegerField(required=False)
+    scan_infos_count = IntegerField(required=False)
     story_arcs_count = IntegerField(required=False)
-    story_arc_numbers_count = IntegerField(required=False, read_only=True)
-    tags_count = IntegerField(required=False, read_only=True)
-    taggers_count = IntegerField(required=False, read_only=True)
-    teams_count = IntegerField(required=False, read_only=True)
+    story_arc_numbers_count = IntegerField(required=False)
+    tags_count = IntegerField(required=False)
+    taggers_count = IntegerField(required=False)
+    teams_count = IntegerField(required=False)
 
 
 class AdminConfigSerializer(Serializer):
     """Config Information."""
 
-    api_key = CharField(required=False, read_only=True)
-    groups_count = IntegerField(required=False, read_only=True)
-    libraries_count = IntegerField(required=False, read_only=True)
-    sessions_anon_count = IntegerField(required=False, read_only=True)
-    sessions_count = IntegerField(required=False, read_only=True)
-    users_count = IntegerField(required=False, read_only=True)
+    api_key = CharField(required=False)
+    groups_count = IntegerField(required=False)
+    libraries_count = IntegerField(required=False)
+    sessions_anon_count = IntegerField(required=False)
+    sessions_count = IntegerField(required=False)
+    users_count = IntegerField(required=False)
 
 
 class AdminPlatformSerializer(Serializer):
     """Platform Information."""
 
-    docker = BooleanField(read_only=True)
-    machine = CharField(read_only=True)
-    system = CharField(read_only=True)
-    system_release = CharField(read_only=True)
-    python = CharField(read_only=True)
-    codex = CharField(read_only=True)
+    docker = BooleanField()
+    machine = CharField()
+    system = CharField()
+    system_release = CharField()
+    python = CharField()
+    codex = CharField()
 
 
 class AdminStatsSerializer(Serializer):

codex/serializers/browser/choices.py

@@ -2,60 +2,65 @@
 
 from types import MappingProxyType
 
-from rest_framework.fields import SerializerMethodField
 from rest_framework.serializers import (
+    BooleanField,
     CharField,
+    ChoiceField,
+    FloatField,
+    IntegerField,
     Serializer,
 )
-from rest_framework.utils.serializer_helpers import ReturnList
 
-from codex.serializers.browser.filters import BrowserSettingsFilterSerializer
-from codex.serializers.fields import (
-    VuetifyCharField,
-    VuetifyIntegerField,
+from codex.serializers.browser.filters import (
+    BooleanListField,
+    BrowserSettingsFilterSerializer,
+    CharListField,
+    DecadeListField,
+    FloatListField,
+    IntListField,
 )
-from codex.serializers.models.pycountry import CountrySerializer, LanguageSerializer
 
 
 class BrowserChoicesCharPkSerializer(Serializer):
-    """Named Model Serializer."""
+    """Named Model Serailizer with pk = char hack for languages & countries."""
 
-    pk = VuetifyCharField(read_only=True)
+    pk = CharField(read_only=True)
     name = CharField(read_only=True)
 
 
-class BrowserChoicesIntegerPkSerializer(BrowserChoicesCharPkSerializer):
+class BrowserChoicesBoolPkSerializer(BrowserChoicesCharPkSerializer):
     """Named Model Serailizer with pk = char hack for languages & countries."""
 
-    pk = VuetifyIntegerField(read_only=True)
+    pk = BooleanField(read_only=True)
+
+
+class BrowserChoicesIntPkSerializer(BrowserChoicesCharPkSerializer):
+    """Named Model Serailizer with pk = char hack for languages & countries."""
 
+    pk = IntegerField(read_only=True)
+
+
+class BrowserChoicesFloatPkSerializer(BrowserChoicesCharPkSerializer):
+    """Named Model Serailizer with pk = char hack for languages & countries."""
+
+    pk = FloatField(read_only=True)
+
+
+_CHOICES_TYPE_SERIALIZER_MAP = MappingProxyType(
+    {
+        BooleanListField: BrowserChoicesBoolPkSerializer,
+        CharListField: BrowserChoicesCharPkSerializer,
+        ChoiceField: BrowserChoicesCharPkSerializer,
+        DecadeListField: BrowserChoicesIntPkSerializer,
+        FloatListField: BrowserChoicesFloatPkSerializer,
+        IntListField: BrowserChoicesIntPkSerializer,
+    }
+)
 
-_CHOICES_NAME_SERIALIZER_MAP = MappingProxyType(
+_BSFS = BrowserSettingsFilterSerializer
+CHOICES_SERIALIZER_CLASS_MAP = MappingProxyType(
     {
-        "bookmark": BrowserChoicesCharPkSerializer,
-        "country": CountrySerializer,
-        "language": LanguageSerializer,
+        name: _CHOICES_TYPE_SERIALIZER_MAP[field.__class__]
+        for name, field in _BSFS().fields.items()  # type: ignore
     }
 )
-_LIST_FIELDS = frozenset({"decade", "monochrome", "reading_direction", "year"})
-
-
-class BrowserChoicesFilterSerializer(Serializer):
-    """Dynamic Serializer response by field type."""
-
-    choices = SerializerMethodField(read_only=True)
-
-    def get_choices(self, obj) -> ReturnList:
-        """Dynamic Serializer response by field type."""
-        field_name = obj.get("field_name", "")
-        choices = obj.get("choices", [])
-        serializer_class = _CHOICES_NAME_SERIALIZER_MAP.get(field_name)
-        value: ReturnList
-        if serializer_class:
-            value = serializer_class(choices, many=True).data  # type: ignore
-        elif not serializer_class and field_name in _LIST_FIELDS:
-            field = BrowserSettingsFilterSerializer().get_fields().get(field_name)  # type: ignore
-            value = field.to_representation(choices)
-        else:
-            value = BrowserChoicesIntegerPkSerializer(choices, many=True).data  # type: ignore
-        return value