codex 1.6.19__py3-none-any.whl → 1.7.0__py3-none-any.whl

codex/views/browser/cover.py

@@ -1,12 +1,13 @@
 """Comic cover thumbnail view."""
 
+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 rest_framework.renderers import BaseRenderer
 
-from codex.librarian.covers.create import CoverCreateMixin
+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.logging import get_logger
@@ -14,7 +15,7 @@ from codex.models import Comic, Volume
 from codex.models.groups import Folder
 from codex.models.paths import CustomCover
 from codex.serializers.browser.settings import BrowserCoverInputSerializer
-from codex.views.browser.annotations import BrowserAnnotationsView
+from codex.views.browser.annotate.order import BrowserAnnotateOrderView
 from codex.views.const import (
     CUSTOM_COVER_GROUP_RELATION,
     GROUP_RELATION,
@@ -40,7 +41,7 @@ class WEBPRenderer(BaseRenderer):
         return data
 
 
-class CoverView(BrowserAnnotationsView):
+class CoverView(BrowserAnnotateOrderView):
     """ComicCover View."""
 
     input_serializer_class = BrowserCoverInputSerializer
@@ -48,7 +49,7 @@ class CoverView(BrowserAnnotationsView):
     content_type = "image/webp"
     TARGET = "cover"
     REPARSE_JSON_FIELDS = frozenset(
-        BrowserAnnotationsView.REPARSE_JSON_FIELDS | {"parent"}
+        BrowserAnnotateOrderView.REPARSE_JSON_FIELDS | {"parent"}
     )
 
     def get_group_filter(self, group=None, pks=None, page_mtime=False):
@@ -70,22 +71,13 @@ class CoverView(BrowserAnnotationsView):
             group_filter[f"{parent_rel}__pk__in"] = parent_pks
         return Q(**group_filter)
 
-    def get_model_group(self):
-        """Return the url group."""
-        return self.kwargs["group"]
-
-    def init_request(self):
-        """Initialize request."""
-        self.parse_params()
-        self.set_model()
-
     def _get_comic_cover(self):
         pks = self.kwargs["pks"]
         return pks[0], False
 
     def _get_custom_cover(self):
         """Get Custom Cover."""
-        if self.model == Volume or not self.params.get("custom_covers"):
+        if self.model is Volume or not self.params.get("custom_covers"):
             return None
         group = self.kwargs["group"]
         group_rel = CUSTOM_COVER_GROUP_RELATION[group]
@@ -97,10 +89,9 @@ class CoverView(BrowserAnnotationsView):
 
     def _get_dynamic_cover(self):
         """Get dynamic cover."""
-        self.set_order_key()
         comic_qs = self.get_filtered_queryset(Comic)
-        comic_qs = self.annotate_order_aggregates(comic_qs, Comic)
-        comic_qs = self.add_order_by(comic_qs, Comic)
+        comic_qs = self.annotate_order_aggregates(comic_qs)
+        comic_qs = self.add_order_by(comic_qs)
         comic_qs = comic_qs.only("pk")
         comic = comic_qs.first()
         cover_pk = comic.pk if comic else 0
@@ -108,7 +99,7 @@ class CoverView(BrowserAnnotationsView):
 
     def _get_cover_pk(self) -> tuple[int, bool]:
         """Get Cover Pk queryset for comic queryset."""
-        if self.model == Comic:
+        if self.model is Comic:
             cover_pk, custom = self._get_comic_cover()
         elif custom_cover := self._get_custom_cover():
             cover_pk = custom_cover.pk
@@ -136,7 +127,7 @@ class CoverView(BrowserAnnotationsView):
 
         cover_path = CoverPathMixin.get_cover_path(pk, custom)
         if not cover_path.exists():
-            thumb_buffer = CoverCreateMixin.create_cover_from_path(
+            thumb_buffer = CoverCreateThread.create_cover_from_path(
                 pk, cover_path, LOG, LIBRARIAN_QUEUE, custom
             )
             if not thumb_buffer:
@@ -148,16 +139,19 @@ class CoverView(BrowserAnnotationsView):
         return cover_file, content_type
 
     @extend_schema(
-        parameters=[BrowserAnnotationsView.input_serializer_class],
+        parameters=[BrowserAnnotateOrderView.input_serializer_class],
         responses={(200, content_type): OpenApiTypes.BINARY},
     )
     def get(self, *args, **kwargs):  # type: ignore
         """Get comic cover."""
         try:
-            self.init_request()
-            pk, custom = self._get_cover_pk()
+            try:
+                pk, custom = self._get_cover_pk()
+            except OperationalError as exc:
+                self._handle_operational_error(exc)
+                pk = 0
+                custom = False
             cover_file, content_type = self._get_cover_data(pk, custom)
-
             return StreamingHttpResponse(chunker(cover_file), content_type=content_type)
         except Exception:
-            LOG.exception("get")
+            LOG.exception("Get cover")

codex/views/browser/filters/bookmark.py

@@ -4,46 +4,45 @@ from typing import TYPE_CHECKING
 
 from django.db.models import Q
 
+from codex.views.browser.validate import BrowserValidateView
+
 if TYPE_CHECKING:
     from codex.models import BrowserGroupModel
 
 
-class BookmarkFilterMixin:
+class BrowserFilterBookmarkView(BrowserValidateView):
     """BookmarkFilter view methods."""
 
-    def init_bookmark_data(self):
+    def __init__(self, *args, **kwargs):
         """Initialize the bm_annotation_data."""
-        self._bm_annotation_data: dict[BrowserGroupModel, tuple[str, Q]] = {}
+        super().__init__(*args, **kwargs)
+        self._bm_rels: dict[BrowserGroupModel, str] = {}
+        self._bm_filters: dict[BrowserGroupModel, Q] = {}
 
     def _get_bm_rel(self, model):
         """Create bookmark relation."""
-        rel_prefix = self.get_rel_prefix(model)  # type: ignore
-        return rel_prefix + "bookmark"
+        if model not in self._bm_rels:
+            rel_prefix = self.get_rel_prefix(model)  # type: ignore
+            self._bm_rels[model] = rel_prefix + "bookmark"
+        return self._bm_rels[model]
 
     def _get_my_bookmark_filter(self, bm_rel):
         """Get a filter for my session or user defined bookmarks."""
-        if self.request.user.is_authenticated:  # type: ignore
-            my_bookmarks_kwargs = {f"{bm_rel}__user": self.request.user}  # type: ignore
+        if self.request.user and self.request.user.is_authenticated:
+            key = f"{bm_rel}__user"
+            value = self.request.user
         else:
             key = f"{bm_rel}__session__session_key"
-            my_bookmarks_kwargs = {
-                key: self.request.session.session_key  # type: ignore
-            }
+            value = self.request.session.session_key
+        my_bookmarks_kwargs = {key: value}
         return Q(**my_bookmarks_kwargs)
 
-    def get_bookmark_rel_and_filter(self, model):
-        """Get the bookmark rel and filter once."""
-        if model not in self._bm_annotation_data:
-            bm_rel = self._get_bm_rel(model)
-            bm_filter = self._get_my_bookmark_filter(bm_rel)
-            self._bm_annotation_data[model] = (bm_rel, bm_filter)
-        return self._bm_annotation_data[model]
-
     def get_bookmark_filter(self, model):
         """Build bookmark query."""
         choice: str = self.params.get("filters", {}).get("bookmark", "")  # type: ignore
         if choice:
-            bm_rel, my_bookmark_filter = self.get_bookmark_rel_and_filter(model)
+            bm_rel = self._get_bm_rel(model)
+            my_bookmark_filter = self._get_my_bookmark_filter(bm_rel)
             if choice == "READ":
                 bookmark_filter = my_bookmark_filter & Q(
                     **{f"{bm_rel}__finished": True}

codex/views/browser/filters/field.py

@@ -5,12 +5,17 @@ from types import MappingProxyType
 from django.db.models import Q
 
 from codex.views.browser.filters.group import GroupFilterView
+from codex.views.session import (
+    CONTRIBUTOR_PERSON_UI_FIELD,
+    IDENTIFIER_TYPE_UI_FIELD,
+    STORY_ARC_UI_FIELD,
+)
 
 _FILTER_REL_MAP = MappingProxyType(
     {
-        GroupFilterView.CONTRIBUTOR_PERSON_UI_FIELD: "contributors__person",
-        GroupFilterView.STORY_ARC_UI_FIELD: "story_arc_numbers__story_arc",
-        GroupFilterView.IDENTIFIER_TYPE_UI_FIELD: "identifiers__identifier_type",
+        CONTRIBUTOR_PERSON_UI_FIELD: "contributors__person",
+        STORY_ARC_UI_FIELD: "story_arc_numbers__story_arc",
+        IDENTIFIER_TYPE_UI_FIELD: "identifiers__identifier_type",
     }
 )
 

codex/views/browser/filters/filter.py

@@ -0,0 +1,69 @@
+"""Browser Filters."""
+
+from django.db.models.query import QuerySet
+from django.db.models.query_utils import Q
+
+from codex.logger.logging 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."""
+
+    TARGET = ""
+
+    def force_inner_joins(self, qs):
+        """Force INNER JOINS to filter empty groups."""
+        demote_tables = {"codex_library"}
+        if qs.model is not Comic:
+            demote_tables.add("codex_comic")
+        if self.fts_mode:
+            # Forcing INNER JOINS required to make fts5 work
+            demote_tables.add("codex_comicfts")
+        return qs.demote_joins(demote_tables)
+
+    def _get_query_filters(
+        self,
+        model,
+        group=None,
+        pks=None,
+        page_mtime=False,
+        bookmark_filter=True,
+    ) -> Q:
+        """Return all the filters except the group filter."""
+        big_include_filter = Q()
+        big_exclude_filter = Q()
+        big_include_filter &= self.get_group_acl_filter(model, self.request.user)
+        big_include_filter &= self.get_group_filter(group, pks, page_mtime=page_mtime)
+        big_include_filter &= self.get_comic_field_filter(model)
+        if bookmark_filter:
+            big_include_filter &= self.get_bookmark_filter(model)
+        include_search_filter, exclude_search_filter, fts_q = self.get_search_filters(
+            model
+        )
+        big_include_filter &= include_search_filter
+        big_exclude_filter &= exclude_search_filter
+
+        return big_include_filter & ~big_exclude_filter & fts_q
+
+    def get_filtered_queryset(
+        self,
+        model,
+        group=None,
+        pks=None,
+        page_mtime=False,
+        bookmark_filter=True,
+    ) -> QuerySet:
+        """Get a filtered queryset for the model."""
+        query_filters = self._get_query_filters(
+            model,
+            group=group,
+            pks=pks,
+            page_mtime=page_mtime,
+            bookmark_filter=bookmark_filter,
+        )
+        # Distinct necissary for folder view with search
+        return model.objects.filter(query_filters).distinct()

codex/views/browser/filters/group.py

@@ -2,26 +2,29 @@
 
 from django.db.models import Q
 
+from codex.views.browser.params import BrowserParamsView
 from codex.views.const import (
     FILTER_ONLY_GROUP_RELATION,
     FOLDER_GROUP,
     GROUP_RELATION,
 )
-from codex.views.session import SessionView
 
+_GROUP_REL_TARGETS = frozenset({"cover", "choices"})
+_PK_REL_TARGETS = frozenset({"metadata", "mtime"})
 
-class GroupFilterView(SessionView):
+
+class GroupFilterView(BrowserParamsView):
     """Group Filters."""
 
-    SESSION_KEY = SessionView.BROWSER_SESSION_KEY
+    SESSION_KEY = BrowserParamsView.BROWSER_SESSION_KEY
 
     def _get_rel_for_pks(self, group, page_mtime=False):
         """Get the relation from the model to the pks."""
         # XXX these TARGET refs might be better as subclass get rel methods.
         target: str = self.TARGET  # type: ignore
-        if target in ("cover", "choices"):
+        if target in _GROUP_REL_TARGETS:
             rel = FILTER_ONLY_GROUP_RELATION[group]
-        elif target in ("metadata", "mtime") or page_mtime:
+        elif target in _PK_REL_TARGETS or page_mtime:
             # metadata, mtime, browser.page_mtime
             rel = "pk"
         else:
@@ -42,8 +45,8 @@ class GroupFilterView(SessionView):
             rel = self._get_rel_for_pks(group, page_mtime)
             group_filter_dict = {rel: pks}
         elif group == FOLDER_GROUP:
+            # Top folder search
             group_filter_dict = {"parent_folder": None}
         else:
             group_filter_dict = {}
-
         return Q(**group_filter_dict)

codex/views/browser/filters/search/__init__.py

@@ -0,0 +1 @@
+"""Search filter."""

codex/views/browser/filters/search/aliases.py

@@ -0,0 +1,81 @@
+"""Field aliases and types maps."""
+
+from types import MappingProxyType
+
+from django.db.models.fields import CharField
+from django.db.models.fields.related import ManyToManyField
+
+from codex.models.comic import Comic
+
+
+def gen_multipart_field_aliases(field):
+    """Generate aliases for fields made of snake_case words."""
+    bits = field.split("_")
+    aliases = []
+
+    # Singular from plural
+    if field.endswith("s"):
+        aliases += [field[:-1]]
+
+    # Alternate delimiters
+    for connector in ("", "-"):
+        joined = connector.join(bits)
+        aliases += [joined, joined[:-1]]
+
+    return tuple(sorted(frozenset(aliases)))
+
+
+FIELDMAP = MappingProxyType(
+    {
+        "characters": ("category", "character"),
+        "community_rating": gen_multipart_field_aliases("community_rating"),
+        "contributors": (
+            *gen_multipart_field_aliases("authors"),
+            "contributor",
+            *gen_multipart_field_aliases("creators"),
+            *gen_multipart_field_aliases("credits"),
+            *gen_multipart_field_aliases("people"),
+            *gen_multipart_field_aliases("persons"),
+        ),
+        "created_at": ("created",),
+        "critical_rating": gen_multipart_field_aliases("critical_rating"),
+        "genres": ("genre",),
+        "file_type": (
+            "filetype",
+            "type",
+        ),
+        "identifiers": ("id", "nss", "identifier"),
+        "identifier_types": ("idtype", "id_type", "nid", "identifier_type"),
+        "issue_number": ("number",),
+        "locations": ("location",),
+        "monochrome": gen_multipart_field_aliases("black_and_white"),
+        "name": ("title",),
+        "original_format": ("format",),
+        "page_count": ("pages",),
+        "reading_direction": ("direction",),
+        "path": (
+            "filename",
+            *gen_multipart_field_aliases("folders"),
+        ),
+        "series_groups": gen_multipart_field_aliases("series_groups"),
+        "scan_info": ("scan",),
+        "stories": ("story",),
+        "story_arcs": gen_multipart_field_aliases("story_arcs"),
+        "summary": ("comments", "description"),
+        "tags": ("tag",),
+        "teams": ("team",),
+        "updated_at": ("updated",),
+    }
+)
+
+
+ALIAS_FIELD_MAP = MappingProxyType(
+    {value: key for key, values in FIELDMAP.items() for value in values}
+)
+FIELD_TYPE_MAP = MappingProxyType(
+    {
+        **{field.name: field.__class__ for field in Comic._meta.get_fields()},
+        "role": ManyToManyField,
+        "issue": CharField,
+    }
+)

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

@@ -0,0 +1 @@
+"""Column Lookup Queries from field tokens."""

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

@@ -0,0 +1,53 @@
+"""Parse the field side of a field lookup."""
+
+from types import MappingProxyType
+
+from django.db.models import (
+    CharField,
+)
+from django.db.models.fields.related import ForeignKey, ManyToManyField
+
+from codex.logger.logging import get_logger
+from codex.views.browser.filters.search.aliases import FIELD_TYPE_MAP
+
+_FIELD_TO_REL_SPAN_MAP = MappingProxyType(
+    {
+        "role": "contributors__role__name",
+        "contributors": "contributors__person__name",
+        "identifier": "identifier__nss",
+        "identirier_type": "identifier__identifier_type__name",
+        "story_arcs": "story_arc_number__story_arc__name",
+    }
+)
+
+LOG = get_logger(__name__)
+
+
+def _parse_field_rel(field_name, rel_class):
+    """Set rel to comic attribute or relation span."""
+    rel = _FIELD_TO_REL_SPAN_MAP.get(field_name, "")
+    if not rel and rel_class in (ForeignKey, ManyToManyField):
+        # This must be after the special span maps
+        rel = f"{field_name}__name"
+
+    if rel.endswith("name"):
+        rel_class = CharField
+
+    if not rel:
+        # Comic attribute
+        rel = field_name
+
+    return rel_class, rel
+
+
+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)
+    if not rel_class:
+        reason = f"Unknown field specified in search query {field_name}"
+        raise ValueError(reason)
+
+    many_to_many = rel_class == ManyToManyField
+
+    rel_class, rel = _parse_field_rel(field_name, rel_class)
+    return rel_class, rel, many_to_many

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

@@ -0,0 +1,177 @@
+"""Parse field lookup right hand side expression."""
+
+import re
+from decimal import Decimal
+from types import MappingProxyType
+
+from comicbox.fields.fields import IssueField
+from dateparser import parse
+from django.db.models import (
+    BooleanField,
+    CharField,
+    DateField,
+    DateTimeField,
+    TextField,
+)
+from django.db.models.fields import DecimalField, PositiveSmallIntegerField
+from humanfriendly import parse_size
+
+from codex.logger.logging import get_logger
+from codex.settings.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):
+    """Parse a compound issue value into number & suffix."""
+    value = IssueField.parse_issue(value)
+    if not value:
+        return None, None
+    matches = _PARSE_ISSUE_MATCHER.match(value)
+    if not matches:
+        return None, None
+    numeric_value = Decimal(matches.group("issue_number"))
+    suffix_value = matches.group("issue_suffix")
+    return numeric_value, suffix_value
+
+
+def _parse_issue_values(rel, value, to_value=None):
+    """Issue is not a column. Convert to issue_number and issue_suffix."""
+    numeric_value, suffix_value = _parse_issue_value(value)
+    if to_value is not None:
+        to_numeric_value, to_suffix_value = _parse_issue_value(to_value)
+    else:
+        to_numeric_value = to_suffix_value = None
+
+    q_dict = {}
+
+    if numeric_value is not None:
+        issue_number_field = rel.replace("issue", "issue_number")
+        if to_numeric_value is not None:
+            numeric_value = (numeric_value, to_numeric_value)
+        q_dict[issue_number_field] = numeric_value
+
+    if suffix_value is not None:
+        issue_suffix_field = rel.replace("issue", "issue_suffix")
+        if to_suffix_value is not None:
+            suffix_value = (suffix_value, to_suffix_value)
+        q_dict[issue_suffix_field] = suffix_value
+
+    return q_dict
+
+
+def _cast_value(rel, rel_class, value):
+    """Cast values by relation class."""
+    if rel.startswith("size"):
+        value = parse_size(value)
+    elif rel_class == PositiveSmallIntegerField:
+        value = int(value)
+    elif rel_class == DecimalField:
+        value = Decimal(value)
+    elif rel_class == BooleanField:
+        value = value not in FALSY
+    elif rel_class in (DateField, DateTimeField):
+        value = parse(value)
+        if rel_class == DateField and value:
+            value = value.date()
+    # elif rel_class in (CharField, TextField):
+    #    value = value
+    return value
+
+
+def _parse_operator_numeric(rel, rel_class, value):
+    value = _cast_value(rel, rel_class, value)
+    if value is None:
+        return {}
+    return {rel: value}
+
+
+def _parse_operator_text(rel, exp):
+    """Parse text value operators."""
+    if rel == "issue":
+        return _parse_issue_values(rel, exp)
+
+    value = _glob_to_like(exp)
+    rel += "__like"
+    return {rel: value}
+
+
+def _parse_operator(operator, rel, rel_class, exp):
+    """Move value operator out of value into relation operator."""
+    lookup = _OP_MAP[operator]
+    span_rel = f"{rel}__{lookup}" if operator else rel
+    value = exp[len(operator) :]
+    if rel == "issue":
+        return _parse_issue_values(span_rel, value)
+    return _parse_operator_numeric(span_rel, rel_class, value)
+
+
+def _parse_operator_range(rel, rel_class, value) -> dict:
+    """Parse range operator."""
+    range_from_value, range_to_value = _RANGE_RE.split(value, 1)
+    rel = f"{rel}__range"
+    if rel == ("issue__range"):
+        return _parse_issue_values(
+            rel,
+            range_from_value,
+            range_to_value,
+        )
+    range_value = (
+        _cast_value(rel, rel_class, range_from_value),
+        _cast_value(rel, rel_class, range_to_value),
+    )
+    return {rel: range_value}
+
+
+def _glob_to_like(value) -> str:
+    """Transform globs into like lookups."""
+    # Escape like tokens
+    value = _LIKE_RE.sub(r"\\\g<1>", value)
+
+    # Remove double stars
+    while True:
+        new_value = value.replace("**", "*")
+        if new_value == value:
+            value = new_value
+            break
+        value = new_value
+
+    if not value:
+        return "%"
+
+    # Replace starts with like operands
+    value = value.replace("*", "%")
+
+    # If not a prefix or suffix search, make a like term search
+    if not value.startswith("%") and not value.endswith("%"):
+        value = f"%{value}%"
+
+    return value
+
+
+def parse_expression(rel, rel_class, exp) -> dict:
+    """Parse the operators of the value size of the field query."""
+    exp = _QUOTES_RE.sub("", exp)
+
+    for op in _OP_MAP:
+        if exp.startswith(op):
+            q_dict = _parse_operator(
+                op,
+                rel,
+                rel_class,
+                exp,
+            )
+            break
+    else:
+        if ".." in exp:
+            q_dict = _parse_operator_range(rel, rel_class, exp)
+        elif rel_class in (CharField, TextField) and not rel.startswith("volume"):
+            q_dict = _parse_operator_text(rel, exp)
+        else:
+            q_dict = _parse_operator_numeric(rel, rel_class, exp)
+    return q_dict