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

codex/search/backend_search.py

@@ -0,0 +1,229 @@
+"""Backend search that gets the reverse variable as a parameter."""
+
+import warnings
+from datetime import date, datetime
+
+from django.conf import settings
+from django.utils.encoding import force_str
+
+# Bubble up the correct error.
+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
+    def search(
+        self,
+        query_string,
+        sort_by=None,
+        start_offset=0,
+        end_offset=None,
+        fields="",
+        highlight=False,
+        facets=None,
+        date_facets=None,
+        query_facets=None,
+        narrow_queries=None,
+        spelling_query=None,
+        within=None,
+        dwithin=None,
+        distance_point=None,
+        models=None,
+        limit_to_registered_models=None,
+        result_class=None,
+        reverse=False,
+        **kwargs,
+    ):
+        if not self.setup_complete:
+            self.setup()
+
+        # A zero length query should return no results.
+        if len(query_string) == 0:
+            return {"results": [], "hits": 0}
+
+        query_string = force_str(query_string)
+
+        # A one-character query (non-wildcard) gets nabbed by a stopwords
+        # filter and should yield zero results.
+        if len(query_string) <= 1 and query_string != "*":
+            return {"results": [], "hits": 0}
+
+        # reverse = False # old reverse flag
+
+        if sort_by is not None:
+            # Determine if we need to reverse the results and if Whoosh can
+            # handle what it's being asked to sort by. Reversing is an
+            # all-or-nothing action, unfortunately.
+            sort_by_list = []
+            reverse_counter = 0
+
+            for order_by in sort_by:
+                if order_by.startswith("-"):
+                    reverse_counter += 1
+            if reverse_counter and reverse_counter != len(sort_by):
+                raise SearchBackendError(
+                    "Whoosh requires all order_by fields"
+                    " to use the same sort direction"
+                )
+
+            for order_by in sort_by:
+                if order_by.startswith("-"):
+                    sort_by_list.append(order_by[1:])
+
+                    if len(sort_by_list) == 1:
+                        reverse = True
+                else:
+                    sort_by_list.append(order_by)
+
+                    if len(sort_by_list) == 1:
+                        reverse = False
+
+            sort_by = sort_by_list
+
+        group_by = []
+        facet_types = {}
+        if facets is not None:
+            group_by += [
+                FieldFacet(facet, allow_overlap=True, maptype=Count) for facet in facets
+            ]
+            facet_types.update({facet: "fields" for facet in facets})
+
+        if date_facets is not None:
+
+            def _fixup_datetime(dt):
+                if isinstance(dt, datetime):
+                    return dt
+                if isinstance(dt, date):
+                    return datetime(dt.year, dt.month, dt.day)
+                raise ValueError
+
+            for key, value in date_facets.items():
+                start = _fixup_datetime(value["start_date"])
+                end = _fixup_datetime(value["end_date"])
+                gap_by = value["gap_by"]
+                gap_amount = value.get("gap_amount", 1)
+                gap = RelativeDelta(**{"%ss" % gap_by: gap_amount})
+                group_by.append(DateRangeFacet(key, start, end, gap, maptype=Count))
+                facet_types[key] = "dates"
+
+        if query_facets is not None:
+            warnings.warn(
+                "Whoosh does not handle query faceting.", Warning, stacklevel=2
+            )
+
+        narrowed_results = None
+        self.index = self.index.refresh()
+
+        if limit_to_registered_models is None:
+            limit_to_registered_models = getattr(
+                settings, "HAYSTACK_LIMIT_TO_REGISTERED_MODELS", True
+            )
+
+        if models and len(models):
+            model_choices = sorted(get_model_ct(model) for model in models)
+        elif limit_to_registered_models:
+            # Using narrow queries, limit the results to only models handled
+            # with the current routers.
+            model_choices = self.build_models_list()
+        else:
+            model_choices = []
+
+        if len(model_choices) > 0:
+            if narrow_queries is None:
+                narrow_queries = set()
+
+            narrow_queries.add(
+                " OR ".join(["%s:%s" % (DJANGO_CT, rm) for rm in model_choices])
+            )
+
+        narrow_searcher = None
+
+        if narrow_queries is not None:
+            # Potentially expensive? I don't see another way to do it in Whoosh...
+            narrow_searcher = self.index.searcher()
+
+            for nq in narrow_queries:
+                recent_narrowed_results = narrow_searcher.search(
+                    self.parser.parse(force_str(nq)), limit=None
+                )
+
+                if len(recent_narrowed_results) <= 0:
+                    return {"results": [], "hits": 0}
+
+                if narrowed_results is not None:
+                    narrowed_results.filter(recent_narrowed_results)
+                else:
+                    narrowed_results = recent_narrowed_results
+
+        self.index = self.index.refresh()
+
+        if self.index.doc_count():
+            searcher = self.index.searcher()
+            parsed_query = self.parser.parse(query_string)
+
+            # In the event of an invalid/stopworded query, recover gracefully.
+            if parsed_query is None:
+                return {"results": [], "hits": 0}
+
+            page_num, page_length = self.calculate_page(start_offset, end_offset)
+
+            search_kwargs = {
+                "pagelen": page_length,
+                "sortedby": sort_by,
+                "reverse": reverse,
+                "groupedby": group_by,
+            }
+
+            # Handle the case where the results have been narrowed.
+            if narrowed_results is not None:
+                search_kwargs["filter"] = narrowed_results
+
+            try:
+                raw_page = searcher.search_page(parsed_query, page_num, **search_kwargs)
+            except ValueError:
+                if not self.silently_fail:
+                    raise
+
+                return {"results": [], "hits": 0, "spelling_suggestion": None}
+
+            # Because as of Whoosh 2.5.1, it will return the wrong page of
+            # results if you request something too high. :(
+            if raw_page.pagenum < page_num:
+                return {"results": [], "hits": 0, "spelling_suggestion": None}
+
+            results = self._process_results(
+                raw_page,
+                highlight=highlight,
+                query_string=query_string,
+                spelling_query=spelling_query,
+                result_class=result_class,
+                facet_types=facet_types,
+            )
+            searcher.close()
+
+            if hasattr(narrow_searcher, "close"):
+                narrow_searcher.close()
+
+            return results
+        else:
+            if self.include_spelling:
+                if spelling_query:
+                    spelling_suggestion = self.create_spelling_suggestion(
+                        spelling_query
+                    )
+                else:
+                    spelling_suggestion = self.create_spelling_suggestion(query_string)
+            else:
+                spelling_suggestion = None
+
+            return {
+                "results": [],
+                "hits": 0,
+                "spelling_suggestion": spelling_suggestion,
+            }

codex/search/engine.py

@@ -3,10 +3,10 @@
 from codex._vendor.haystack.backends import UnifiedIndex
 from codex._vendor.haystack.backends.whoosh_backend import (
     WhooshEngine,
-    WhooshSearchQuery,
 )
 from codex.search.backend import CodexSearchBackend
 from codex.search.indexes import ComicIndex
+from codex.search.query import CodexSearchQuery
 
 
 class CodexUnifiedIndex(UnifiedIndex):
@@ -18,14 +18,6 @@ class CodexUnifiedIndex(UnifiedIndex):
         return [ComicIndex()]
 
 
-class CodexSearchQuery(WhooshSearchQuery):
-    """Custom search qeuery."""
-
-    def clean(self, query_fragment):
-        """Optimize to noop because RESERVED_ consts are empty in the backend."""
-        return query_fragment
-
-
 class CodexSearchEngine(WhooshEngine):
     """A search engine with a locking backend."""
 

codex/search/query.py

@@ -0,0 +1,67 @@
+"""Custom Codex search query classes."""
+
+from codex._vendor.haystack.backends.whoosh_backend import (
+    WhooshSearchQuery,
+)
+from codex._vendor.haystack.constants import DJANGO_ID
+from codex._vendor.haystack.query import SearchQuerySet
+
+
+class CodexSearchQuery(WhooshSearchQuery):
+    """Custom search qeuery."""
+
+    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
+
+    def clean(self, query_fragment):
+        """Optimize to noop because RESERVED_ consts are empty in the backend."""
+        return query_fragment
+
+    def order_reverse(self):
+        """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)
+
+
+class CodexSearchQuerySet(SearchQuerySet):
+    """SearchQuerySet with order_reverse method."""
+
+    def order_reverse(self):
+        """Alters the order in which the results should appear."""
+        clone = self._clone()
+        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
-    AsycnWriter. The AsyncWriter could possibly be extended to not lock until commit
+    AsycWriter. The AsyncWriter could possibly be extended to not lock until commit
     time like this one and use less code.
     """
 

codex/serializers/admin.py

@@ -27,7 +27,9 @@ LOG = get_logger(__name__)
 class UserSerializer(BaseModelSerializer):
     """User Serializer."""
 
-    last_active = DateTimeField(read_only=True, allow_null=True)
+    last_active = DateTimeField(
+        read_only=True, source="useractive.updated_at", allow_null=True
+    )
 
     class Meta(BaseModelSerializer.Meta):
         """Specify Model."""
@@ -99,8 +101,17 @@ class LibrarySerializer(BaseModelSerializer):
         """Specify Model."""
 
         model = Library
-        fields = ("pk", "events", "groups", "last_poll", "path", "poll", "poll_every")
-        read_only_fields = ("last_poll", "pk")
+        fields = (
+            "pk",
+            "path",
+            "events",
+            "last_poll",
+            "poll",
+            "poll_every",
+            "groups",
+            "covers_only",
+        )
+        read_only_fields = ("last_poll", "pk", "covers_only")
 
     def validate_path(self, path):
         """Validate new library paths."""
@@ -162,8 +173,7 @@ class AdminFolderSerializer(Serializer):
     def validate_show_hidden(self, show_hidden):
         """Snakecase the showHidden field."""
         return (
-            show_hidden == "true"
-            or self.initial_data.get("showHidden", False) == "true"
+            show_hidden == "true" or self.initial_data.get("showHidden") == "true"  # type: ignore
         )
 
 
@@ -171,67 +181,68 @@ class AdminGroupSerializer(Serializer):
     """Group Counts."""
 
     publishers_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)
+    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)
 
 
 class AdminFileTypeSerializer(Serializer):
     """File Type Counts."""
 
-    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)
+    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)
 
 
 class AdminComicMetadataSerializer(Serializer):
     """Metadata Counts."""
 
-    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)
+    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)
     story_arcs_count = IntegerField(required=False)
-    story_arc_numbers_count = IntegerField(required=False)
-    tags_count = IntegerField(required=False)
-    taggers_count = IntegerField(required=False)
-    teams_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)
 
 
 class AdminConfigSerializer(Serializer):
     """Config Information."""
 
-    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)
+    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)
 
 
 class AdminPlatformSerializer(Serializer):
     """Platform Information."""
 
-    docker = BooleanField()
-    machine = CharField()
-    system = CharField()
-    system_release = CharField()
-    python = CharField()
-    codex = CharField()
+    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)
 
 
 class AdminStatsSerializer(Serializer):

codex/serializers/browser/choices.py

@@ -2,65 +2,60 @@
 
 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 (
-    BooleanListField,
-    BrowserSettingsFilterSerializer,
-    CharListField,
-    DecadeListField,
-    FloatListField,
-    IntListField,
+from codex.serializers.browser.filters import BrowserSettingsFilterSerializer
+from codex.serializers.fields import (
+    VuetifyCharField,
+    VuetifyIntegerField,
 )
+from codex.serializers.models.pycountry import CountrySerializer, LanguageSerializer
 
 
 class BrowserChoicesCharPkSerializer(Serializer):
-    """Named Model Serailizer with pk = char hack for languages & countries."""
+    """Named Model Serializer."""
 
-    pk = CharField(read_only=True)
+    pk = VuetifyCharField(read_only=True)
     name = CharField(read_only=True)
 
 
-class BrowserChoicesBoolPkSerializer(BrowserChoicesCharPkSerializer):
+class BrowserChoicesIntegerPkSerializer(BrowserChoicesCharPkSerializer):
     """Named Model Serailizer with pk = char hack for languages & countries."""
 
-    pk = BooleanField(read_only=True)
-
-
-class BrowserChoicesIntPkSerializer(BrowserChoicesCharPkSerializer):
-    """Named Model Serailizer with pk = char hack for languages & countries."""
+    pk = VuetifyIntegerField(read_only=True)
 
-    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,
-    }
-)
 
-_BSFS = BrowserSettingsFilterSerializer
-CHOICES_SERIALIZER_CLASS_MAP = MappingProxyType(
+_CHOICES_NAME_SERIALIZER_MAP = MappingProxyType(
     {
-        name: _CHOICES_TYPE_SERIALIZER_MAP[field.__class__]
-        for name, field in _BSFS().fields.items()  # type: ignore
+        "bookmark": BrowserChoicesCharPkSerializer,
+        "country": CountrySerializer,
+        "language": LanguageSerializer,
     }
 )
+_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