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

codex/views/browser/choices.py

@@ -1,5 +1,6 @@
 """View for marking comics read and unread."""
 
+from itertools import chain
 from types import MappingProxyType
 from typing import Any
 
@@ -7,79 +8,79 @@ from caseconverter import snakecase
 from django.db.models import QuerySet
 from drf_spectacular.utils import extend_schema
 from rest_framework.response import Response
+from rest_framework.serializers import BaseSerializer
+from typing_extensions import override
 
 from codex.choices.browser import DUMMY_NULL_NAME, VUETIFY_NULL_CODE
-from codex.logger.logger import get_logger
 from codex.models import (
     Comic,
-    ContributorPerson,
+    CreditPerson,
     StoryArc,
 )
-from codex.models.named import IdentifierType
+from codex.models.identifier import IdentifierSource
+from codex.models.named import Universe
 from codex.serializers.browser.choices import (
     BrowserChoicesFilterSerializer,
     BrowserFilterChoicesSerializer,
 )
-from codex.serializers.browser.settings import BrowserFilterChoicesInputSerilalizer
+from codex.serializers.browser.settings import BrowserFilterChoicesInputSerializer
 from codex.views.browser.filters.filter import BrowserFilterView
 from codex.views.session import (
-    CONTRIBUTOR_PERSON_UI_FIELD,
+    CREDIT_PERSON_UI_FIELD,
     IDENTIFIER_TYPE_UI_FIELD,
     STORY_ARC_UI_FIELD,
 )
 
-LOG = get_logger(__name__)
-
 _FIELD_TO_REL_MODEL_MAP = MappingProxyType(
     {
-        CONTRIBUTOR_PERSON_UI_FIELD: (
-            "contributors__person",
-            ContributorPerson,
+        CREDIT_PERSON_UI_FIELD: (
+            "credits__person",
+            CreditPerson,
+        ),
+        IDENTIFIER_TYPE_UI_FIELD: (
+            "identifiers__source",
+            IdentifierSource,
         ),
         STORY_ARC_UI_FIELD: (
             "story_arc_numbers__story_arc",
             StoryArc,
         ),
-        IDENTIFIER_TYPE_UI_FIELD: (
-            "identifiers__identifier_type",
-            IdentifierType,
-        ),
     }
 )
 _BACK_REL_MAP = MappingProxyType(
     {
-        ContributorPerson: "contributor__",
+        CreditPerson: "credit__",
         StoryArc: "storyarcnumber__",
-        IdentifierType: "identifier__",
+        IdentifierSource: "identifier__",
     }
 )
 _NULL_NAMED_ROW = MappingProxyType({"pk": VUETIFY_NULL_CODE, "name": DUMMY_NULL_NAME})
+_NULL_NAMED_ROW_ITERABLE = (_NULL_NAMED_ROW,)
 
 
 class BrowserChoicesViewBase(BrowserFilterView):
     """Get choices for filter dialog."""
 
-    input_serializer_class = BrowserFilterChoicesInputSerilalizer
-    TARGET = "choices"
+    input_serializer_class: type[BrowserFilterChoicesInputSerializer] = (  # pyright: ignore[reportIncompatibleVariableOverride]
+        BrowserFilterChoicesInputSerializer
+    )
+    TARGET: str = "choices"
 
     @staticmethod
     def get_field_choices_query(comic_qs, field_name):
         """Get distinct values for the field."""
-        return (
-            comic_qs.exclude(**{field_name: None})
-            .values_list(field_name, flat=True)
-            .distinct()
-        )
+        return comic_qs.exclude(**{f"{field_name}__isnull": True}).distinct()
 
     def get_m2m_field_query(self, model, comic_qs: QuerySet):
         """Get distinct m2m value objects for the relation."""
         back_rel = _BACK_REL_MAP.get(model, "")
         m2m_filter = {f"{back_rel}comic__in": comic_qs}
-        return model.objects.filter(**m2m_filter).values("pk", "name").distinct()
+        return model.objects.filter(**m2m_filter).distinct()
 
     @staticmethod
     def does_m2m_null_exist(comic_qs, rel):
         """Get if comics exist in the filter without values exists for an m2m field."""
+        # Detect if there are null choices. Regretably with another query.
         return comic_qs.filter(**{f"{rel}__isnull": True}).exists()
 
     def get_rel_and_model(self, field_name):
@@ -96,6 +97,7 @@ class BrowserChoicesViewBase(BrowserFilterView):
 
         return rel, model
 
+    @override
     def get_object(self) -> QuerySet:
         """Get the comic subquery use for the choices."""
         return self.get_filtered_queryset(Comic)
@@ -111,51 +113,56 @@ class BrowserChoicesViewBase(BrowserFilterView):
 class BrowserChoicesAvailableView(BrowserChoicesViewBase):
     """Get choices for filter dialog."""
 
-    serializer_class = BrowserFilterChoicesSerializer
+    serializer_class: type[BaseSerializer] | None = BrowserFilterChoicesSerializer
 
     @classmethod
-    def _get_field_choices_count(cls, comic_qs, field_name):
+    def _is_field_choices_exists(cls, comic_qs, field_name):
         """Create a pk:name object for fields without tables."""
         qs = cls.get_field_choices_query(comic_qs, field_name)
-        return qs.count()
+        return qs.exists()
 
-    def _get_m2m_field_choices_count(self, model, comic_qs, rel):
+    def _is_m2m_field_choices_exists(self, model, comic_qs, rel):
         """Get choices with nulls where there are nulls."""
-        m2m_qs = self.get_m2m_field_query(model, comic_qs)
-        m2m_qs = m2m_qs.values("pk")
-        count = m2m_qs.count()
-
-        # Detect if there are null choices.
-        # Regretabbly with another query, but doing a forward query
-        # on the comic above restricts all results to only the filtered
-        # rows. :(
-        if self.does_m2m_null_exist(comic_qs, rel):
-            count += 1
-
-        return count
+        qs = self.get_m2m_field_query(model, comic_qs)
+        qs = qs[:2]
+        count = qs.count()
+        if count > 1:
+            # There are choices
+            return True
+        if count == 1:
+            # There are only choices if a null exists
+            return self.does_m2m_null_exist(comic_qs, rel)
+        # There is only one or no choices.
+        return False
+
+    def _is_filter_field_choices_exists(self, qs: QuerySet, field_name: str):
+        rel, m2m_model = self.get_rel_and_model(field_name)
 
-    def get_object(self) -> dict[str, Any]:  # type: ignore[reportIncompatibleMethodOverride]
+        if m2m_model:
+            exists = self._is_m2m_field_choices_exists(m2m_model, qs, rel)
+        else:
+            exists = self._is_field_choices_exists(qs, field_name)
+        try:
+            flag = exists
+        except TypeError:
+            flag = False
+        return flag
+
+    @override
+    def get_object(self) -> dict[str, Any]:  # pyright: ignore[reportIncompatibleMethodOverride]
         """Get choice counts."""
-        qs = super().get_object()
+        qs: QuerySet = super().get_object()
         filters = self.params.get("filters", {})
         data = {}
-        serializer: BrowserFilterChoicesSerializer = self.serializer_class()  # type: ignore[reportOptionalCall, reportAssignmentType]
+        serializer: BrowserFilterChoicesSerializer = self.serializer_class()  # pyright: ignore[reportOptionalCall, reportAssignmentType]
         for field_name in serializer.get_fields():
             if field_name == "story_arcs" and qs.model is StoryArc:
                 # don't allow filtering on story arc in story arc view.
                 continue
-            rel, m2m_model = self.get_rel_and_model(field_name)
-
-            if m2m_model:
-                count = self._get_m2m_field_choices_count(m2m_model, qs, rel)
+            if bool(filters.get(field_name)):
+                flag = True
             else:
-                count = self._get_field_choices_count(qs, rel)
-
-            try:
-                is_filter_set = bool(filters.get(field_name))
-                flag = is_filter_set or count > 1
-            except TypeError:
-                flag = False
+                flag = self._is_filter_field_choices_exists(qs, field_name)
             data[field_name] = flag
         return data
 
@@ -163,28 +170,33 @@ class BrowserChoicesAvailableView(BrowserChoicesViewBase):
 class BrowserChoicesView(BrowserChoicesViewBase):
     """Get choices for filter dialog."""
 
-    serializer_class = BrowserChoicesFilterSerializer
+    serializer_class: type[BaseSerializer] | None = BrowserChoicesFilterSerializer
 
     def _get_m2m_field_choices(self, model, comic_qs, rel):
         """Get choices with nulls where there are nulls."""
+        iterables = []
+
+        # Choices
         qs = self.get_m2m_field_query(model, comic_qs)
+        values = ["pk", "name"]
+        if qs.model == Universe:
+            values.append("designation")
+        qs = qs.values(*values)
 
-        # Detect if there are null choices.
-        # Regretabbly with another query, but doing a forward query
-        # on the comic above restrcts all results to only the filtered
-        # rows. :(
+        # Add null if it exists
         if self.does_m2m_null_exist(comic_qs, rel):
-            choices = list(qs)
-            choices.append(_NULL_NAMED_ROW)
-        else:
-            choices = qs
-        return choices
+            iterables.append(_NULL_NAMED_ROW_ITERABLE)
+
+        iterables.append(qs)
+
+        return chain.from_iterable(iterables)
 
     def _get_field_name(self):
         field_name = self.kwargs.get("field_name", "")
         return snakecase(field_name)
 
-    def get_object(self) -> dict[str, Any]:  # type: ignore[reportIncompatibleMethodOverride]
+    @override
+    def get_object(self) -> dict[str, Any]:  # pyright: ignore[reportIncompatibleMethodOverride]··
         """Return choices with more than one choice."""
         qs = super().get_object()
         field_name = self._get_field_name()
@@ -194,6 +206,10 @@ class BrowserChoicesView(BrowserChoicesViewBase):
             choices = self._get_m2m_field_choices(m2m_model, qs, rel)
         else:
             choices = self.get_field_choices_query(qs, field_name)
+            choices = choices.values_list(field_name, flat=True)
+
+        if field_name in ("critical_rating", "file_type"):
+            choices = tuple({"pk": choice, "name": choice} for choice in choices)
 
         return {
             "field_name": field_name,

codex/views/browser/cover.py

@@ -1,16 +1,19 @@
 """Comic cover thumbnail view."""
 
+from collections.abc import Sequence
+
 from django.db import OperationalError
 from django.db.models.query import Q
 from django.http.response import StreamingHttpResponse
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import extend_schema
+from loguru import logger
 from rest_framework.renderers import BaseRenderer
+from typing_extensions import override
 
 from codex.librarian.covers.create import CoverCreateThread
 from codex.librarian.covers.path import CoverPathMixin
 from codex.librarian.mp_queue import LIBRARIAN_QUEUE
-from codex.logger.logger import get_logger
 from codex.models import Comic, Volume
 from codex.models.groups import Folder
 from codex.models.paths import CustomCover
@@ -25,17 +28,16 @@ from codex.views.const import (
 )
 from codex.views.util import chunker
 
-LOG = get_logger(__name__)
-
 
 class WEBPRenderer(BaseRenderer):
     """Render WEBP images."""
 
     media_type = "image/webp"
     format = "webp"
-    charset = None
+    charset: str | None = None
     render_style = "binary"
 
+    @override
     def render(self, data, *_args, **_kwargs):
         """Return raw data."""
         return data
@@ -44,15 +46,15 @@ class WEBPRenderer(BaseRenderer):
 class CoverView(BrowserAnnotateOrderView):
     """ComicCover View."""
 
-    input_serializer_class = BrowserCoverInputSerializer
-    renderer_classes = (WEBPRenderer,)
-    content_type = "image/webp"
-    TARGET = "cover"
-    REPARSE_JSON_FIELDS = frozenset(
-        BrowserAnnotateOrderView.REPARSE_JSON_FIELDS | {"parent"}
+    input_serializer_class: type[BrowserCoverInputSerializer] = (  # pyright: ignore[reportIncompatibleVariableOverride]
+        BrowserCoverInputSerializer
     )
+    renderer_classes: Sequence[type[BaseRenderer]] = (WEBPRenderer,)
+    content_type = "image/webp"
+    TARGET: str = "cover"
 
-    def get_group_filter(self, group=None, pks=None, page_mtime=False):  # noqa: FBT002
+    @override
+    def get_group_filter(self, group=None, pks=None, *, page_mtime=False):
         """Get group filter for First Cover View."""
         if self.params.get("dynamic_covers") or self.model in (Volume, Folder):
             return super().get_group_filter(group=group, pks=pks, page_mtime=page_mtime)
@@ -68,9 +70,9 @@ class CoverView(BrowserAnnotateOrderView):
         model_rel = GROUP_RELATION[self.model_group]
         group_filter = {f"{model_rel}__sort_name__in": sort_names}
 
-        parent = self.params.get("parent", {})
-        if parent_pks := parent.get("pks"):
-            parent_rel = GROUP_RELATION[parent["group"]]
+        parent_route = self.params.get("parent_route", {})
+        if parent_pks := parent_route.get("pks"):
+            parent_rel = GROUP_RELATION[parent_route["group"]]
             group_filter[f"{parent_rel}__pk__in"] = parent_pks
         return Q(**group_filter)
 
@@ -124,14 +126,14 @@ class CoverView(BrowserAnnotateOrderView):
         cover_path = STATIC_IMG_PATH / cover_fn
         return cover_path, content_type
 
-    def _get_cover_data(self, pk, custom):
+    def _get_cover_data(self, pk, *, custom: bool):
         thumb_buffer = None
         content_type = "image/webp"
 
-        cover_path = CoverPathMixin.get_cover_path(pk, custom)
+        cover_path = CoverPathMixin.get_cover_path(pk, custom=custom)
         if not cover_path.exists():
             thumb_buffer = CoverCreateThread.create_cover_from_path(
-                pk, cover_path, LOG, LIBRARIAN_QUEUE, custom
+                pk, str(cover_path), logger, LIBRARIAN_QUEUE, custom=custom
             )
             if not thumb_buffer:
                 cover_path, content_type = self._get_missing_cover_path()
@@ -154,7 +156,7 @@ class CoverView(BrowserAnnotateOrderView):
                 self._handle_operational_error(exc)
                 pk = 0
                 custom = False
-            cover_file, content_type = self._get_cover_data(pk, custom)
+            cover_file, content_type = self._get_cover_data(pk, custom=custom)
             return StreamingHttpResponse(chunker(cover_file), content_type=content_type)
         except Exception:
-            LOG.exception("Get cover")
+            logger.exception("Get cover")

codex/views/browser/download.py

@@ -4,21 +4,21 @@ from django.http import HttpResponseBadRequest
 from django.http.response import FileResponse, Http404
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import extend_schema
+from loguru import logger
+from typing_extensions import override
 from zipstream import ZipStream
 
-from codex.logger.logger import get_logger
 from codex.views.browser.filters.filter import BrowserFilterView
 
-LOG = get_logger()
-
 
 class GroupDownloadView(BrowserFilterView):
     """Return a group of comic archives as a streaming zipfile."""
 
     content_type = "application/zip"
     AS_ATTACHMENT = True
-    TARGET = "download"
+    TARGET: str = "download"
 
+    @override
     def get_object(self):
         """Get comic paths for a browse group."""
         group = self.kwargs.get("group")
@@ -32,7 +32,7 @@ class GroupDownloadView(BrowserFilterView):
             path_rel = self.rel_prefix + "path"
             paths = qs.values_list(path_rel, flat=True)
         except Exception as exc:
-            LOG.warning(f"Error with download query for {group}:{pks} {exc}")
+            logger.warning(f"Error with download query for {group}:{pks} {exc}")
             raise
 
         if not paths:

codex/views/browser/filters/bookmark.py

@@ -9,6 +9,11 @@ from codex.views.browser.validate import BrowserValidateView
 class BrowserFilterBookmarkView(BookmarkFilterMixin, BrowserValidateView):
     """BookmarkFilter view methods."""
 
+    def __init__(self, *args, **kwargs):
+        """Initialize Bookmark Filter."""
+        self.init_bookmark_filter()
+        super().__init__(*args, **kwargs)
+
     def get_bookmark_filter(self, model):
         """Build bookmark query."""
         choice: str = self.params.get("filters", {}).get("bookmark", "")

codex/views/browser/filters/field.py

@@ -6,16 +6,16 @@ from django.db.models import Q
 
 from codex.views.browser.filters.group import GroupFilterView
 from codex.views.session import (
-    CONTRIBUTOR_PERSON_UI_FIELD,
+    CREDIT_PERSON_UI_FIELD,
     IDENTIFIER_TYPE_UI_FIELD,
     STORY_ARC_UI_FIELD,
 )
 
 _FILTER_REL_MAP = MappingProxyType(
     {
-        CONTRIBUTOR_PERSON_UI_FIELD: "contributors__person",
+        CREDIT_PERSON_UI_FIELD: "credits__person",
         STORY_ARC_UI_FIELD: "story_arc_numbers__story_arc",
-        IDENTIFIER_TYPE_UI_FIELD: "identifiers__identifier_type",
+        IDENTIFIER_TYPE_UI_FIELD: "identifiers__source",
     }
 )
 

codex/views/browser/filters/filter.py

@@ -3,12 +3,9 @@
 from django.db.models.query import QuerySet
 from django.db.models.query_utils import Q
 
-from codex.logger.logger import get_logger
 from codex.models.comic import Comic
 from codex.views.browser.filters.bookmark import BrowserFilterBookmarkView
 
-LOG = get_logger(__name__)
-
 
 class BrowserFilterView(BrowserFilterBookmarkView):
     """Browser Filters."""
@@ -52,8 +49,9 @@ class BrowserFilterView(BrowserFilterBookmarkView):
         model,
         group=None,
         pks=None,
-        page_mtime=False,  # noqa: FBT002
-        bookmark_filter=True,  # noqa: FBT002
+        *,
+        page_mtime=False,
+        bookmark_filter=True,
     ) -> QuerySet:
         """Get a filtered queryset for the model."""
         query_filters = self._get_query_filters(

codex/views/browser/filters/group.py

@@ -16,11 +16,11 @@ _PK_REL_TARGETS = frozenset({"metadata", "mtime"})
 class GroupFilterView(BrowserParamsView):
     """Group Filters."""
 
-    SESSION_KEY = BrowserParamsView.BROWSER_SESSION_KEY
+    SESSION_KEY: str = BrowserParamsView.BROWSER_SESSION_KEY
 
-    TARGET = ""
+    TARGET: str = ""
 
-    def _get_rel_for_pks(self, group, page_mtime: bool):
+    def _get_rel_for_pks(self, group, *, page_mtime: bool):
         """Get the relation from the model to the pks."""
         if self.TARGET in _GROUP_REL_TARGETS:
             rel = FILTER_ONLY_GROUP_RELATION[group]
@@ -36,7 +36,7 @@ class GroupFilterView(BrowserParamsView):
         rel += "__in"
         return rel
 
-    def get_group_filter(self, group=None, pks=None, page_mtime=False):  # noqa: FBT002
+    def get_group_filter(self, group=None, pks=None, *, page_mtime=False):
         """Get filter for the displayed group."""
         if group is None:
             group = self.kwargs["group"]
@@ -44,7 +44,7 @@ class GroupFilterView(BrowserParamsView):
             pks = self.kwargs["pks"]
 
         if pks and 0 not in pks:
-            rel = self._get_rel_for_pks(group, page_mtime)
+            rel = self._get_rel_for_pks(group, page_mtime=page_mtime)
             group_filter_dict = {rel: pks}
         elif group == FOLDER_GROUP and self.TARGET != "choices":
             # Top folder search

codex/views/browser/filters/search/field/column.py

@@ -7,20 +7,24 @@ from django.db.models import (
 )
 from django.db.models.fields.related import ForeignKey, ManyToManyField
 
-from codex.logger.logger import get_logger
-from codex.views.browser.filters.search.aliases import FIELD_TYPE_MAP
+from codex.models.comic import Comic
 
 _FIELD_TO_REL_SPAN_MAP = MappingProxyType(
     {
-        "role": "contributors__role__name",
-        "contributors": "contributors__person__name",
-        "identifier": "identifier__nss",
-        "identirier_type": "identifier__identifier_type__name",
+        "role": "credits__role__name",
+        "credits": "credits__person__name",
+        "identifier": "identifier__key",
+        "identifier_source": "identifier__source__name",
         "story_arcs": "story_arc_number__story_arc__name",
     }
 )
-
-LOG = get_logger(__name__)
+_FIELD_TYPE_MAP = MappingProxyType(
+    {
+        **{field.name: field.__class__ for field in Comic._meta.get_fields()},
+        "role": ManyToManyField,
+        "issue": CharField,
+    }
+)
 
 
 def _parse_field_rel(field_name, rel_class):
@@ -42,7 +46,7 @@ def _parse_field_rel(field_name, rel_class):
 
 def parse_field(field_name: str):
     """Parse the field size of the query in to database relations."""
-    rel_class = FIELD_TYPE_MAP.get(field_name)
+    rel_class = _FIELD_TYPE_MAP.get(field_name)
     if not rel_class:
         reason = f"Unknown field specified in search query {field_name}"
         raise ValueError(reason)

codex/views/browser/filters/search/field/expression.py

@@ -16,15 +16,13 @@ from django.db.models import (
 from django.db.models.fields import DecimalField, PositiveSmallIntegerField
 from humanfriendly import parse_size
 
-from codex.logger.logger import get_logger
-from codex.settings.settings import FALSY
+from codex.settings import FALSY
 
 _QUOTES_RE = re.compile(r"[\"']")
 _OP_MAP = MappingProxyType({">": "gt", ">=": "gte", "<": "lt", "<=": "lte"})
 _RANGE_RE = re.compile(r"\.{2,}")
 _PARSE_ISSUE_MATCHER = re.compile(r"(?P<issue_number>\d*\.?\d*)(?P<issue_suffix>.*)")
 _LIKE_RE = re.compile(f"([{re.escape('%_')}])")
-LOG = get_logger(__name__)
 
 
 def _parse_issue_value(value):

codex/views/browser/filters/search/field/filter.py

@@ -1,14 +1,12 @@
 """Parse the browser query by removing field queries and doing them with the ORM."""
 
 from django.db.models import Q
+from loguru import logger
 
-from codex.logger.logger import get_logger
 from codex.views.browser.filters.field import ComicFieldFilterView
 from codex.views.browser.filters.search.field.column import parse_field
 from codex.views.browser.filters.search.field.parse import get_field_query
 
-LOG = get_logger(__name__)
-
 
 class BrowserFieldQueryFilter(ComicFieldFilterView):
     """Parse the browser query by removing field queries and doing them with the ORM."""
@@ -52,7 +50,7 @@ class BrowserFieldQueryFilter(ComicFieldFilterView):
         except Exception as exc:
             token = f"{col}:{exp}"
             msg = f"Parsing field query {token} - {exc}"
-            LOG.warning(msg)
+            logger.warning(msg)
             self.search_error = msg
 
     def get_search_field_filters(self, model, field_token_pairs):

codex/views/browser/filters/search/field/optimize.py

@@ -46,7 +46,7 @@ def _regex_like(regex, lookahead):
     return regex
 
 
-def like_qs_to_regex_q(q: Q, regex_op: str, many_to_many: bool):
+def like_qs_to_regex_q(q: Q, regex_op: str, *, many_to_many: bool):
     """Optimize a tree of like lookup qs to one regex q."""
     regexes = []
     # Optimize like equations into regexes