codex 1.6.0a7__py3-none-any.whl → 1.6.0a8__py3-none-any.whl

codex/views/mtime.py

@@ -9,7 +9,7 @@ from codex.util import max_none
 from codex.views.auth import AuthGenericAPIView
 from codex.views.browser.filters.bookmark import BookmarkFilterMixin
 from codex.views.const import GROUP_MODEL_MAP
-from codex.views.utils import reparse_json_query_params
+from codex.views.util import reparse_json_query_params
 
 _REPARSE_JSON_FIELDS = frozenset({"groups"})
 
@@ -20,23 +20,27 @@ class MtimeView(AuthGenericAPIView, BookmarkFilterMixin):
     serializer_class = GroupsMtimeSerializer
     response_serializer_class = MtimeSerializer
 
-    def _get_group_mtime(self, group, pks, use_bookmark_filter):
+    def _parse_params(self):
+        params = reparse_json_query_params(self.request.GET, _REPARSE_JSON_FIELDS)
+        self.groups = params.get("groups", "")
+        self.use_bookmark_filter = self.request.GET.get("use_bookmark_filter", False)
+
+    def _get_group_mtime(self, group, pks):
         """Get one group's mtimes."""
         model = GROUP_MODEL_MAP[group]
         if not model:
             model = Publisher
 
-        qs = model.objects
+        qs = model.objects.all()
 
         if pks and 0 not in pks:
             qs = qs.filter(pk__in=pks)
         updated_at_max = qs.aggregate(max=Max("updated_at"))["max"]
 
-        if use_bookmark_filter:
+        if self.use_bookmark_filter:
             bm_rel = self.get_bm_rel(model)
             bm_filter = self.get_my_bookmark_filter(bm_rel)
             qs = qs.filter(bm_filter)
-            # TODO can these be combined into one max?
             bookmark_updated_at_max = qs.aggregate(max=(Max(f"{bm_rel}__updated_at")))[
                 "max"
             ]
@@ -44,25 +48,23 @@ class MtimeView(AuthGenericAPIView, BookmarkFilterMixin):
 
         return updated_at_max
 
-    def get_max_groups_mtime(self, groups, use_bookmark_filter):
+    def get_max_groups_mtime(self):
         """Get max mtime for all groups."""
         max_mtime = None
 
-        for item in groups:
+        for item in self.groups:
             group = item["group"]
             pks = tuple(int(pk) for pk in item["pks"].split(","))
-            mtime = self._get_group_mtime(group, pks, use_bookmark_filter)
+            mtime = self._get_group_mtime(group, pks)
             max_mtime = max_none(max_mtime, mtime)
         return max_mtime
 
     def get(self, *args, **kwargs):
         """Get the mtimes for the submitted groups."""
         # Parse Request
-        params = reparse_json_query_params(self.request.GET, _REPARSE_JSON_FIELDS)
-        groups = params.get("groups", "")
-        use_bookmark_filter = self.request.GET.get("use_bookmark_filter", False)
+        self._parse_params()
 
-        max_mtime = self.get_max_groups_mtime(groups, use_bookmark_filter)
+        max_mtime = self.get_max_groups_mtime()
 
         # Serialize Response
         result = {"max_mtime": max_mtime}

codex/views/opds/binary.py

@@ -1,6 +1,6 @@
 """Binary views with Basic Authentication added."""
 
-from codex.views.cover import CoverView
+from codex.views.browser.cover import CoverView
 from codex.views.download import DownloadView
 from codex.views.opds.auth import OPDSAuthMixin
 from codex.views.reader.page import ReaderPageView

codex/views/opds/urls.py

@@ -6,6 +6,7 @@ from rest_framework.response import Response
 from codex.serializers.choices import DEFAULTS
 from codex.serializers.opds.urls import OPDSURLsSerializer
 from codex.views.auth import AuthGenericAPIView
+from codex.views.util import pop_name
 
 _OPDS_VERSIONS = (1, 2)
 
@@ -19,7 +20,7 @@ class OPDSURLsView(AuthGenericAPIView):
         """Resolve the urls."""
         obj = {}
         route = DEFAULTS["breadcrumbs"][0]
-        route.pop("name", None)
+        route = pop_name(route)
         for version in _OPDS_VERSIONS:
             key = f"v{version}"
             name = f"opds:v{version}:feed"

codex/views/opds/util.py

@@ -8,9 +8,9 @@ from django.utils.http import urlencode
 from codex.models import (
     Contributor,
     ContributorPerson,
-    StoryArc,
 )
 from codex.serializers.choices import DEFAULTS
+from codex.views.auth import GroupACLMixin
 from codex.views.opds.const import OPDS_M2M_MODELS
 
 
@@ -58,9 +58,7 @@ def get_m2m_objects(pks) -> dict:
     cats = {}
     for model in OPDS_M2M_MODELS:
         table = model.__name__.lower()
-        rel = "comic"
-        if model == StoryArc:
-            rel = "storyarcnumber__" + rel
+        rel = GroupACLMixin.get_rel_prefix(model)
         comic_filter = {rel + "__in": pks}
         qs = model.objects.filter(**comic_filter).order_by("name").only("name")
         cats[table] = qs

codex/views/opds/v1/entry/links.py

@@ -1,12 +1,12 @@
 """OPDS v1 Entry Links Methods."""
 
+from datetime import datetime
+from math import floor
 from urllib.parse import quote_plus
 
-from django.contrib.staticfiles.storage import staticfiles_storage
 from django.urls import reverse
 
 from codex.logger.logging import get_logger
-from codex.views.const import MISSING_COVER_FN, MISSING_COVER_NAME_MAP
 from codex.views.opds.const import MimeType, Rel
 from codex.views.opds.util import update_href_query_params
 from codex.views.opds.v1.data import OPDS1Link
@@ -31,39 +31,24 @@ class OPDS1EntryLinksMixin:
         self.mime_type_map = data.mime_type_map
         self.title_filename_fallback = title_filename_fallback
 
-    def _thumb_link(self):
+    def _cover_link(self, rel):
         if self.fake:
             return None
-        cover_pk = getattr(self.obj, "cover_pk", None)
-        if cover_pk:
-            kwargs = {"pk": cover_pk}
+        # cover_pk = getattr(self.obj, "cover_pk", None)
+        try:
+            kwargs = {"group": self.obj.group, "pks": self.obj.ids}
+            ts = floor(datetime.timestamp(self.obj.updated_at))
+            query_params = {
+                "customCovers": True,
+                "dynamicCovers": False,
+                "ts": ts,
+            }
             href = reverse("opds:bin:cover", kwargs=kwargs)
+            href = update_href_query_params(href, query_params)
             mime_type = "image/webp"
-        else:
-            cover_name = MISSING_COVER_NAME_MAP.get(self.obj.group)
-            cover_path = "img/"
-            if cover_name:
-                cover_path += cover_name + ".svg"
-                mime_type = "image/svg+xml"
-            else:
-                cover_path += MISSING_COVER_FN
-                mime_type = "image/webp"
-            href = staticfiles_storage.url(cover_path)
-        return OPDS1Link(Rel.THUMBNAIL, href, mime_type)
-
-    def _image_link(self):
-        if self.fake:
-            return None
-        cover_pk = getattr(self.obj, "cover_pk", None)
-        if cover_pk:
-            kwargs = {"pk": cover_pk, "page": 0}
-            href = reverse("opds:bin:page", kwargs=kwargs)
-            mime_type = "image/jpeg"
-        else:
-            fn = f"img/{MISSING_COVER_FN}"
-            href = staticfiles_storage.url(fn)
-            mime_type = "image/webp"
-        return OPDS1Link(Rel.IMAGE, href, mime_type)
+            return OPDS1Link(rel, href, mime_type)
+        except Exception:
+            LOG.exception("create thumb")
 
     def _nav_href(self, metadata=False):
         try:
@@ -149,9 +134,9 @@ class OPDS1EntryLinksMixin:
         """Create all entry links."""
         result = []
         try:
-            if thumb := self._thumb_link():
+            if thumb := self._cover_link(Rel.THUMBNAIL):
                 result += [thumb]
-            if image := self._image_link():
+            if image := self._cover_link(Rel.IMAGE):
                 result += [image]
 
             if self.obj.group == "c" and not self.fake:

codex/views/opds/v1/facets.py

@@ -12,6 +12,7 @@ from codex.views.opds.util import update_href_query_params
 from codex.views.opds.v1.data import OPDS1Link
 from codex.views.opds.v1.entry.data import OPDS1EntryData, OPDS1EntryObject
 from codex.views.opds.v1.entry.entry import OPDS1Entry
+from codex.views.util import pop_name
 
 
 @dataclass
@@ -89,7 +90,7 @@ class OPDS1FacetsView(BrowserView):
     obj = MappingProxyType({})
 
     def _facet(self, kwargs, facet_group, facet_title, new_query_params):
-        kwargs.pop("name", None)
+        kwargs = pop_name(kwargs)
         href = reverse("opds:v1:feed", kwargs=kwargs)
         facet_active = False
         for key, val in new_query_params.items():

codex/views/opds/v1/feed.py

@@ -41,13 +41,13 @@ class OpdsNs:
     ACQUISITION = "http://opds-spec.org/2010/acquisition"
 
 
-class UserAgentPrefixes:
+class UserAgentNames:
     """Control whether to hack in facets with nav links."""
 
-    CLIENT_REORDERS = ("Chunky",)
-    FACET_SUPPORT = ("yar",)  # kybooks
-    SIMPLE_DOWNLOAD_MIME_TYPES = ("PocketBook",)
-    # Other known valid  prefixes:
+    CLIENT_REORDERS = frozenset({"Chunky"})
+    FACET_SUPPORT = frozenset({"yar"})  # kybooks
+    SIMPLE_DOWNLOAD_MIME_TYPES = frozenset({"PocketBook Reader"})
+    # Other known valid  names:
     # "Panels", "Chunky"
 
 
@@ -168,14 +168,17 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
 
     def _ensure_page_counts(self):
         """Ensure page counts on books with just in time comicbox."""
+        if self.admin_flags.get("import_metadata"):
+            return
         books_qs: QuerySet = self.obj["books"]  # type: ignore
         import_pks = set()
         new_books = []
         for book in books_qs:
-            if not book.page_count:
-                with Comicbox(book.path) as cb:
-                    book.file_type = cb.get_file_type()
-                    book.page_count = cb.get_page_count()
+            if book.page_count is not None:
+                continue
+            with Comicbox(book.path) as cb:
+                book.file_type = cb.get_file_type()
+                book.page_count = cb.get_page_count()
             new_books.append(book)
             import_pks.add(book.pk)
         if new_books:
@@ -187,7 +190,24 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
 
     def get_object(self):  # type: ignore
         """Get the browser page and serialize it for this subclass."""
-        self.obj = super().get_object()
+        group_qs, book_qs, num_pages, total_count, zero_pad, mtime = (
+            super()._get_group_and_books()
+        )
+        book_qs = book_qs.select_related("series", "volume", "language")
+
+        title = self.get_browser_page_title()
+        self.obj = MappingProxyType(
+            {
+                "title": title,
+                "groups": group_qs,
+                "books": book_qs,
+                "zero_pad": zero_pad,
+                "num_pages": num_pages,
+                "total_count": total_count,
+                "mtime": mtime,
+            }
+        )
+
         self.is_aq_feed = self.model_group in ("c", "f")
 
         self._ensure_page_counts()
@@ -197,22 +217,21 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
 
     def _set_user_agent_variables(self):
         """Set User Agent variables."""
-        # defaults in FacetsMixin
         user_agent = self.request.headers.get("User-Agent")
         if not user_agent:
             return
-        for prefix in UserAgentPrefixes.FACET_SUPPORT:
-            if user_agent.startswith(prefix):
-                self.use_facets = True
-                break
-        for prefix in UserAgentPrefixes.CLIENT_REORDERS:
-            if user_agent.startswith(prefix):
-                self.skip_order_facets = True
-                break
-        for prefix in UserAgentPrefixes.SIMPLE_DOWNLOAD_MIME_TYPES:
-            if user_agent.startswith(prefix):
-                self.mime_type_map = MimeType.SIMPLE_FILE_TYPE_MAP
-                break
+        user_agent_parts = user_agent.split("/", 1)
+        if user_agent_parts:
+            user_agent_name = user_agent_parts[0]
+        else:
+            return
+
+        if user_agent_name in UserAgentNames.FACET_SUPPORT:
+            self.use_facets = True
+        if user_agent_name in UserAgentNames.CLIENT_REORDERS:
+            self.skip_order_facets = True
+        if user_agent_name in UserAgentNames.SIMPLE_DOWNLOAD_MIME_TYPES:
+            self.mime_type_map = MimeType.SIMPLE_FILE_TYPE_MAP
 
     def set_opds_request_type(self):
         """Set the opds request type variables."""

codex/views/opds/v1/links.py

@@ -15,6 +15,7 @@ from codex.views.opds.v1.data import OPDS1Link
 from codex.views.opds.v1.entry.data import OPDS1EntryData, OPDS1EntryObject
 from codex.views.opds.v1.entry.entry import OPDS1Entry
 from codex.views.opds.v1.facets import OPDS1FacetsView
+from codex.views.util import pop_name
 
 LOG = get_logger(__name__)
 
@@ -129,7 +130,7 @@ class OPDS1LinksView(OPDS1FacetsView):
         """Create a link."""
         if query_params is None:
             query_params = self.request.GET
-        kwargs.pop("name", None)
+        kwargs = pop_name(kwargs)
         href = reverse("opds:v1:feed", kwargs=kwargs)
         href = update_href_query_params(href, query_params)
         return OPDS1Link(rel, href, mime_type)

codex/views/opds/v2/feed.py

@@ -175,32 +175,34 @@ class OPDS2FeedView(OPDSAuthMixin, OPDS2PublicationView):
 
     def get_object(self):
         """Get the browser page and serialize it for this subclass."""
-        browser_page = super().get_object()
-
+        group_qs, book_qs, num_pages, total_count, zero_pad, mtime = (
+            self._get_group_and_books()
+        )
+        title = self.get_browser_page_title()
         # convert browser_page into opds page
 
         # instance vars
-        self.is_aq_feed = browser_page.get("model_group") in ("c", "f")
-        self.num_pages = browser_page["num_pages"]
+        self.is_aq_feed = self.model_group in ("c", "f")
+        self.num_pages = num_pages
 
         # opds page
-        title = self._title(browser_page.get("title"))
-        number_of_items = browser_page["total_count"]
+        title = self._title(title)
+        number_of_items = total_count
         current_page = self.kwargs.get("page")
         up_route = self.get_last_route()
         links = self.get_links(up_route)
         facets = self._get_facets()
 
         # opds groups
-        page_groups = browser_page.get("groups")
-        page_books = browser_page.get("books")
-        zero_pad = browser_page["zero_pad"]
+        page_groups = group_qs
+        page_books = book_qs
         groups = self._get_groups(page_groups, page_books, title, zero_pad)
 
         return MappingProxyType(
             {
                 "metadata": {
                     "title": title,
+                    "modified": mtime,
                     "number_of_items": number_of_items,
                     "items_per_page": MAX_OBJ_PER_PAGE,
                     "current_page": current_page,

codex/views/opds/v2/links.py

@@ -10,6 +10,7 @@ from codex.views.browser.browser import BrowserView
 from codex.views.const import FALSY
 from codex.views.opds.const import MimeType, Rel
 from codex.views.opds.util import update_href_query_params
+from codex.views.util import pop_name
 
 
 @dataclass
@@ -69,7 +70,7 @@ class OPDS2LinksView(BrowserView):
         if "page" in kwargs and not self._href_page_validate(kwargs, data):
             return None
 
-        kwargs.pop("name", None)
+        kwargs = pop_name(kwargs)
         href = reverse(url_name, kwargs=kwargs)
         return self._href_update_query_params(href, data)
 

codex/views/opds/v2/publications.py

@@ -1,10 +1,10 @@
 """Publication Methods for OPDS v2.0 feed."""
 
+from datetime import datetime
+from math import floor
 from types import MappingProxyType
 from urllib.parse import quote_plus
 
-from django.contrib.staticfiles.storage import staticfiles_storage
-
 from codex.librarian.covers.create import CoverCreateMixin
 from codex.models import Comic
 from codex.views.opds.const import AUTHOR_ROLES, MimeType, Rel
@@ -32,39 +32,16 @@ class OPDS2PublicationView(OPDS2TopLinksView):
 
     is_opds_metadata = False
 
-    def _get_big_image_link(self, obj, cover_pk):
-        if cover_pk:
-            mime_type = MimeType.JPEG
-            url_name = "opds:bin:page"
-            href = None
-            min_page = 0
-            max_page = obj.max_page or 1
-        else:
-            mime_type = MimeType.WEBP
-            href = staticfiles_storage.url("img/missing_cover.webp")
-            url_name = None
-            min_page = None
-            max_page = None
-
-        kwargs = {"pk": obj.pk, "page": 0}
-        href_data = HrefData(
-            kwargs,
-            absolute_query_params=True,
-            url_name=url_name,
-            min_page=min_page,
-            max_page=max_page,
-        )
-        link_data = LinkData(Rel.IMAGE, href_data, href=href, mime_type=mime_type)
-        return self.link(link_data)
-
     def _images(self, obj):
         # Images
-        cover_pk = obj.cover_pk
-
-        kwargs = {"pk": cover_pk}
-        href_data = HrefData(
-            kwargs, url_name="opds:bin:cover", absolute_query_params=True
-        )
+        kwargs = {"group": obj.group, "pks": obj.ids}
+        ts = floor(datetime.timestamp(obj.updated_at))
+        query_params = {
+            "customCovers": True,
+            "dynamicCovers": False,
+            "ts": ts,
+        }
+        href_data = HrefData(kwargs, query_params, True, "opds:bin:cover")
         link_data = LinkData(
             Rel.THUMBNAIL,
             href_data,
@@ -75,7 +52,9 @@ class OPDS2PublicationView(OPDS2TopLinksView):
 
         cover_link = self.link(link_data)
 
-        image_link = self._get_big_image_link(obj, cover_pk)
+        link_data.rel = Rel.IMAGE
+
+        image_link = self.link(link_data)
 
         return [
             cover_link,

codex/views/public.py

@@ -2,7 +2,6 @@
 
 from rest_framework.generics import GenericAPIView
 from rest_framework.mixins import RetrieveModelMixin
-from rest_framework.parsers import JSONParser
 
 from codex.logger.logging import get_logger
 from codex.models import AdminFlag
@@ -21,7 +20,6 @@ _ADMIN_FLAG_KEYS = frozenset(
 class AdminFlagsView(GenericAPIView, RetrieveModelMixin):
     """Get admin flags relevant to auth."""
 
-    parser_classes = (JSONParser,)
     serializer_class = AuthAdminFlagsSerializer
     queryset = AdminFlag.objects.filter(key__in=_ADMIN_FLAG_KEYS).only("key", "on")
 

codex/views/reader/books.py

@@ -75,7 +75,7 @@ class ReaderBooksView(BookmarkBaseView, SessionView, SharedAnnotationsMixin):
 
     def _get_comics_list(self):
         """Get the reader naviation group filter."""
-        select_related = ("series", "volume")
+        select_related = ("series",)
         prefetch_related = ()
 
         arc: Mapping = self.params.get("arc", {})  # type: ignore

codex/views/reader/reader.py

@@ -15,6 +15,7 @@ from codex.logger.logging import get_logger
 from codex.serializers.reader import ReaderArcSerializer, ReaderComicsSerializer
 from codex.serializers.redirect import ReaderRedirectSerializer
 from codex.views.reader.arcs import ReaderArcsView
+from codex.views.util import pop_name
 
 LOG = get_logger(__name__)
 _VALID_ARC_GROUPS = frozenset({"f", "s", "a"})
@@ -140,8 +141,7 @@ class ReaderView(
             arc["pks"] = (current.arc_pk,)  # type: ignore
         arc["index"] = current.arc_index  # type:ignore
         arc["count"] = current.arc_count  # type: ignore
-        close_route = self.last_route
-        close_route.pop("name", None)
+        close_route = pop_name(self.last_route)
 
         return {
             "books": books,

codex/views/session.py

@@ -7,6 +7,7 @@ from types import MappingProxyType
 from codex.logger.logging import get_logger
 from codex.serializers.choices import DEFAULTS
 from codex.views.auth import AuthFilterGenericAPIView
+from codex.views.util import pop_name
 
 LOG = get_logger(__name__)
 
@@ -62,8 +63,9 @@ class SessionView(AuthFilterGenericAPIView, ABC):
                 "q": DEFAULTS["q"],
                 "search_results_limit": DEFAULTS["searchResultsLimit"],
                 "show": DEFAULTS["show"],
-                "cover_style": DEFAULTS["coverStyle"],
-                "twenty_four_hour_time": False,
+                "dynamic_covers": DEFAULTS["dynamicCovers"],
+                "custom_covers": DEFAULTS["customCovers"],
+                "twenty_four_hour_time": DEFAULTS["twentyFourHourTime"],
                 "top_group": DEFAULTS["topGroup"],
             },
             READER_SESSION_KEY: {
@@ -96,7 +98,7 @@ class SessionView(AuthFilterGenericAPIView, ABC):
             breadcrumbs = DEFAULTS["breadcrumbs"]
         last_route = breadcrumbs[-1]
         if not name:
-            last_route.pop("name", None)
+            last_route = pop_name(last_route)
 
         return last_route
 

codex/views/util.py

@@ -1,6 +1,14 @@
 """Utility classes by many views."""
 
+import json
+from collections.abc import Mapping
+from contextlib import suppress
 from dataclasses import asdict, dataclass
+from json.decoder import JSONDecodeError
+from urllib.parse import unquote_plus
+
+from djangorestframework_camel_case.settings import api_settings
+from djangorestframework_camel_case.util import underscoreize
 
 
 @dataclass()
@@ -29,3 +37,27 @@ class Route(dict):
         )
 
     dict = asdict
+
+
+def reparse_json_query_params(query_params, keys) -> dict:
+    """Reparse JSON encoded query_params."""
+    # It is an unbelievable amount of trouble to try to parse axios native bracket
+    # encoded complex objects in python
+    parsed_dict = {}
+    for key, value in query_params.items():
+        if key in keys:
+            parsed_value = unquote_plus(value)
+            with suppress(JSONDecodeError):
+                parsed_value = json.loads(parsed_value)
+        else:
+            parsed_value = value
+
+        parsed_dict[key] = parsed_value
+    return dict(underscoreize(parsed_dict, **api_settings.JSON_UNDERSCOREIZE))  # type:ignore
+
+
+def pop_name(kwargs: Mapping):
+    """Pop name from a mapping route."""
+    kwargs = dict(kwargs)
+    kwargs.pop("name", None)
+    return kwargs

{codex-1.6.0a7.dist-info → codex-1.6.0a8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: codex
-Version: 1.6.0a7
+Version: 1.6.0a8
 Summary: A comic archive web server.
 Home-page: https://github.com/ajslater/codex
 License: GPL-3.0-only
@@ -29,7 +29,7 @@ Requires-Dist: ansicolors (>=1.1,<2.0)
 Requires-Dist: bidict (>=0.23.1,<0.24.0)
 Requires-Dist: case-converter (>=1.1.0,<2.0.0)
 Requires-Dist: channels (>=4.0.0,<5.0.0)
-Requires-Dist: comicbox[pdf] (>=1.1.7,<2.0.0)
+Requires-Dist: comicbox[pdf] (>=1.1.8,<2.0.0)
 Requires-Dist: django (>=5.0.6,<6.0.0)
 Requires-Dist: django-cachalot (>=2.6.2,<3.0.0)
 Requires-Dist: django-cors-headers (>=4.0,<5.0)
@@ -348,12 +348,13 @@ index, a Django cache and comic book cover thumbnails.
 
 Codex contains some experimental throttling controls. The value supplied to
 these variables will be interpreted as the maximum number of allowed requests
-per minute.
+per minute. For example, the following settings would limit each described group
+to 2 queries per second.
 
-- `CODEX_THROTTLE_ANON=60` Anonymous users
-- `CODEX_THROTTLE_USER=60` Authenticated users
-- `CODEX_THROTTLE_OPDS=60` The OPDS v1 & v2 APIs
-- `CODEX_THROTTLE_OPENSEARCH=60` The OPDS v1 Opensearch API
+- `CODEX_THROTTLE_ANON=30` Anonymous users
+- `CODEX_THROTTLE_USER=30` Authenticated users
+- `CODEX_THROTTLE_OPDS=30` The OPDS v1 & v2 APIs (Panels uses this for search)
+- `CODEX_THROTTLE_OPENSEARCH=30` The OPDS v1 Opensearch API
 
 ### Reverse Proxy