codex 1.8.6__py3-none-any.whl → 1.8.9__py3-none-any.whl

codex/librarian/scribe/search/prepare.py

@@ -0,0 +1,162 @@
+"""Prepare ComicFTS objects."""
+
+from contextlib import suppress
+from types import MappingProxyType
+
+from comicbox.enums.comicbox import IdSources
+from comicbox.enums.maps.identifiers import ID_SOURCE_NAME_MAP
+from django.db.models.functions.datetime import Now
+
+from codex.librarian.status import Status
+from codex.models.comic import ComicFTS
+from codex.serializers.fields.browser import CountryField, LanguageField
+
+_PYCOUNTRY_FIELDS = MappingProxyType(
+    {"country": CountryField(), "language": LanguageField()}
+)
+_COMIC_KEYS = (
+    "collection_title",
+    "country",
+    "language",
+    "name",
+    "review",
+    "summary",
+    "fts_publisher",
+    "fts_imprint",
+    "fts_series",
+    "fts_age_rating",
+    "fts_original_format",
+    "fts_scan_info",
+    "fts_tagger",
+    "fts_characters",
+    "fts_credits",
+    "fts_country",
+    "fts_genres",
+    "fts_sources",
+    "fts_language",
+    "fts_locations",
+    "fts_series_groups",
+    "fts_stories",
+    "fts_story_arcs",
+    "fts_tags",
+    "fts_teams",
+    "fts_universes",
+)
+
+
+class SearchEntryPrepare:
+    """Prepare ComicFTS objects."""
+
+    @staticmethod
+    def _get_entry_str_value(entry: dict, key: str) -> str:
+        value = entry.get(key)
+        if not value:
+            return ""
+        if isinstance(value, tuple):
+            value = value[0]
+            if not value:
+                return ""
+        return value
+
+    @staticmethod
+    def _get_sources_fts_field(entry: dict) -> str:
+        sources = entry.get("sources", ())
+        if not sources:
+            return ""
+        if isinstance(sources, str):
+            sources = (sources,)
+        names = set()
+        for source_str in sources:
+            if not source_str:
+                continue
+            names.add(source_str)
+            with suppress(ValueError):
+                id_source = IdSources(source_str)
+                if long_name := ID_SOURCE_NAME_MAP.get(id_source):
+                    names.add(long_name)
+        return ",".join(sorted(names))
+
+    @classmethod
+    def _get_pycountry_fts_field(cls, entry, field_name) -> str:
+        iso_code = cls._get_entry_str_value(entry, field_name)
+        if not iso_code:
+            return ""
+        field = _PYCOUNTRY_FIELDS[field_name]
+        return ",".join((iso_code, field.to_representation(iso_code)))
+
+    @classmethod
+    def _create_comicfts_entry_attributes(cls, entry, *, create: bool):
+        now = Now()
+        entry["updated_at"] = now
+        if create:
+            entry["created_at"] = now
+
+    @classmethod
+    def _create_comicfts_entry_fks(cls, entry):
+        entry["country"] = cls._get_pycountry_fts_field(entry, "country")
+        entry["language"] = cls._get_pycountry_fts_field(entry, "language")
+
+    @classmethod
+    def _create_comicfts_entry_m2ms(cls, entry, existing_values: dict | None):
+        if sources := cls._get_sources_fts_field(entry):
+            entry["sources"] = sources
+        if existing_values:
+            for field_name in tuple(existing_values.keys()):
+                if values := existing_values.get(field_name):
+                    entry[field_name] = entry.get(field_name, ()) + values
+
+    @classmethod
+    def prepare_import_fts_entry(  # noqa: PLR0913
+        cls,
+        comic_id: int,
+        entry: dict,
+        existing_m2m_values: dict | None,
+        comicfts: ComicFTS | None,
+        obj_list: list[ComicFTS],
+        status: Status,
+        *,
+        create: bool,
+    ):
+        """Prepare ComicFTS object from import data."""
+        cls._create_comicfts_entry_m2ms(entry, existing_m2m_values)
+        cls._create_comicfts_entry_fks(entry)
+        for field_name in entry:  # noqa: PLC0206
+            value = entry[field_name]
+            if isinstance(value, tuple):
+                entry[field_name] = ",".join(sorted(value))
+
+        cls._create_comicfts_entry_attributes(entry, create=create)
+
+        if comicfts:
+            for field_name, value in entry.items():
+                setattr(comicfts, field_name, value)
+        else:
+            entry["comic_id"] = comic_id
+            comicfts = ComicFTS(**entry)
+
+        obj_list.append(comicfts)
+        status.increment_complete()
+
+    @classmethod
+    def prepare_sync_fts_entry(
+        cls,
+        comic: dict,
+        obj_list: list[ComicFTS],
+        *,
+        create: bool,
+    ):
+        """Prepare ComicFTS object from sync query data."""
+        entry = {
+            key.removeprefix("fts_"): comic.get(key, "")
+            for key in _COMIC_KEYS
+            if comic.get(key)
+        }
+        if sources := cls._get_sources_fts_field(entry):
+            entry["sources"] = sources
+        cls._create_comicfts_entry_fks(entry)
+        entry["universes"] = entry["universes"].strip(",")
+        cls._create_comicfts_entry_attributes(entry, create=create)
+        entry["comic_id"] = comic["id"]
+
+        comicfts: ComicFTS = ComicFTS(**entry)
+        obj_list.append(comicfts)

codex/librarian/scribe/search/remove.py

@@ -1,11 +1,13 @@
 """Search Index cleanup."""
 
+from django.db.models import F, Max
+
 from codex.librarian.scribe.search.optimize import SearchIndexerOptimize
 from codex.librarian.scribe.search.status import (
     SearchIndexCleanStatus,
     SearchIndexClearStatus,
 )
-from codex.models.comic import ComicFTS
+from codex.models.comic import Comic, ComicFTS
 
 
 class SearchIndexerRemove(SearchIndexerOptimize):
@@ -22,7 +24,9 @@ class SearchIndexerRemove(SearchIndexerOptimize):
         """Remove records not in the database from the index."""
         self.status_controller.start(status)
         self.log.debug("Finding stale records to remove...")
-        delete_comicfts = ComicFTS.objects.filter(comic__isnull=True)
+        delete_comicfts = ComicFTS.objects.exclude(
+            comic_id__in=Comic.objects.only("pk")
+        )
         status.total = delete_comicfts.count()
         self.status_controller.update(status)
         if status.total:
@@ -42,3 +46,19 @@ class SearchIndexerRemove(SearchIndexerOptimize):
         finally:
             self.status_controller.finish(status)
         return count
+
+    def remove_duplicate_records(self) -> int:
+        """Remove duplicate FTS records."""
+        self.log.debug("Looking for duplicate search entries...")
+        duplicates = ComicFTS.objects.annotate(max_updated_at=Max("updated_at")).filter(
+            updated_at__lt=F("max_updated_at")
+        )
+
+        num_dupes = duplicates.count()
+        self.log.debug(f"Found {num_dupes} duplicate search entries")
+        count = num_dupes
+        if num_dupes:
+            count, _ = duplicates.delete()
+            if count:
+                self.log.info(f"Deleted {count} duplicate search entries")
+        return count

codex/librarian/scribe/search/sync.py

@@ -6,15 +6,16 @@ from time import time
 from typing import TYPE_CHECKING
 from zoneinfo import ZoneInfo
 
-from comicbox.enums.maps.identifiers import ID_SOURCE_NAME_MAP
+from django.db.models import Q
 from django.db.models.aggregates import Max
 from django.db.models.expressions import F, Value
 from django.db.models.functions import Concat
-from django.db.models.functions.datetime import Now
 from django.db.models.query import QuerySet
 from humanize import intcomma, naturaldelta
 
 from codex.librarian.memory import get_mem_limit
+from codex.librarian.scribe.search.const import COMICFTS_UPDATE_FIELDS
+from codex.librarian.scribe.search.prepare import SearchEntryPrepare
 from codex.librarian.scribe.search.remove import SearchIndexerRemove
 from codex.librarian.scribe.search.status import (
     SEARCH_INDEX_STATII,
@@ -26,54 +27,13 @@ from codex.librarian.scribe.search.status import (
 from codex.models import Comic
 from codex.models.comic import ComicFTS
 from codex.models.functions import GroupConcat
-from codex.serializers.fields.browser import CountryField, LanguageField, PyCountryField
 from codex.settings import SEARCH_SYNC_BATCH_MEMORY_RATIO
 
 if TYPE_CHECKING:
     from codex.librarian.status import Status
 
-_COMICFTS_ATTRIBUTES = (
-    "collection_title",
-    "file_type",
-    "issue",
-    "name",
-    "notes",
-    "reading_direction",
-    "review",
-    "summary",
-    "updated_at",
-)
-_COMICFTS_FKS = (
-    "publisher",
-    "imprint",
-    "series",
-    "age_rating",
-    "country",
-    "language",
-    "original_format",
-    "scan_info",
-    "tagger",
-)
-_COMICFTS_M2MS = (
-    "characters",
-    "credits",
-    "genres",
-    "identifiers",
-    "locations",
-    "series_groups",
-    "sources",
-    "stories",
-    "story_arcs",
-    "tags",
-    "teams",
-    "universes",
-)
-_COMICFTS_UPDATE_FIELDS = (
-    *_COMICFTS_ATTRIBUTES,
-    *_COMICFTS_FKS,
-    *_COMICFTS_M2MS,
-)
 _MIN_UTC_DATE = datetime.min.replace(tzinfo=ZoneInfo("UTC"))
+_ALL_FTS_COMIC_IDS_QUERY = Q(pk__in=ComicFTS.objects.values_list("comic_id", flat=True))
 
 
 class SearchIndexerSync(SearchIndexerRemove):
@@ -171,23 +131,6 @@ class SearchIndexerSync(SearchIndexerRemove):
             ),
         )
 
-    @staticmethod
-    def _get_pycountry_fts_field(field: PyCountryField, iso_code) -> str:
-        if not iso_code:
-            return ""
-        return ",".join((iso_code, field.to_representation(iso_code)))
-
-    @staticmethod
-    def _get_sources_fts_field(sources) -> str | None:
-        names = []
-        if not sources:
-            return None
-        for source in sources.split(","):
-            names.append(source)
-            if long_name := ID_SOURCE_NAME_MAP.get(source):
-                names.append(long_name)
-        return ",".join(names)
-
     def _update_search_index_operate_get_status(
         self, total_comics: int, chunk_human_size: str, *, create: bool
     ):
@@ -197,63 +140,6 @@ class SearchIndexerSync(SearchIndexerRemove):
         subtitle = f"Chunks of {chunk_human_size}" if total_comics else ""
         return status_class(total=total_comics, subtitle=subtitle)
 
-    def _create_comicfts_entry(
-        self,
-        comic,
-        obj_list: list[ComicFTS],
-        *,
-        create: bool,
-    ):
-        country_field: PyCountryField = CountryField()  # pyright: ignore[reportAssignmentType]
-        language_field: PyCountryField = LanguageField()  # pyright: ignore[reportAssignmentType]
-
-        country = self._get_pycountry_fts_field(country_field, comic.fts_country)
-        language = self._get_pycountry_fts_field(language_field, comic.fts_language)
-        sources = self._get_sources_fts_field(comic.fts_sources)
-
-        now = Now()
-        comicfts = ComicFTS(
-            comic_id=comic.pk,
-            # Attributes
-            collection_title=comic.collection_title,
-            file_type=comic.file_type,
-            issue=comic.issue(),
-            name=comic.name,
-            notes=comic.notes,
-            reading_direction=comic.reading_direction,
-            review=comic.review,
-            summary=comic.summary,
-            updated_at=now,
-            # Group FKs
-            publisher=comic.fts_publisher,
-            imprint=comic.fts_imprint,
-            series=comic.fts_series,
-            # FKS
-            age_rating=comic.fts_age_rating,
-            country=country,
-            language=language,
-            original_format=comic.fts_original_format,
-            scan_info=comic.fts_scan_info,
-            tagger=comic.fts_tagger,
-            # ManyToMany
-            characters=comic.fts_characters,
-            credits=comic.fts_credits,
-            genres=comic.fts_genres,
-            identifiers=comic.fts_identifiers,
-            sources=sources,  # comic.fts_sources,
-            locations=comic.fts_locations,
-            series_groups=comic.fts_series_groups,
-            stories=comic.fts_stories,
-            story_arcs=comic.fts_story_arcs,
-            tags=comic.fts_tags,
-            teams=comic.fts_teams,
-            universes=comic.fts_universes,
-        )
-        if create:
-            comicfts.created_at = now
-
-        obj_list.append(comicfts)
-
     def _update_search_index_create_or_update(
         self,
         obj_list: list[ComicFTS],
@@ -272,11 +158,17 @@ class SearchIndexerSync(SearchIndexerRemove):
         if create:
             ComicFTS.objects.bulk_create(obj_list)
         else:
-            ComicFTS.objects.bulk_update(obj_list, _COMICFTS_UPDATE_FIELDS)
+            ComicFTS.objects.bulk_update(obj_list, COMICFTS_UPDATE_FIELDS)
 
         status.increment_complete(num_comic_fts)
         self.status_controller.update(status, notify=True)
 
+    @staticmethod
+    def _get_operation_comics_query(qs, *, create: bool):
+        if create and not ComicFTS.objects.exists():
+            qs = Comic.objects.all()
+        return qs
+
     def _update_search_index_operate(
         self, comics_filtered_qs: QuerySet, *, create: bool
     ):
@@ -289,7 +181,10 @@ class SearchIndexerSync(SearchIndexerRemove):
 
         verb = "create" if create else "update"
         self.log.debug(f"Counting total search index entries to {verb}...")
-        total_comics = comics_filtered_qs.count()
+        total_comics = self._get_operation_comics_query(
+            comics_filtered_qs, create=create
+        )
+        total_comics = total_comics.count()
         status = self._update_search_index_operate_get_status(
             total_comics, chunk_human_size, create=create
         )
@@ -300,23 +195,29 @@ class SearchIndexerSync(SearchIndexerRemove):
                 return total_comics
 
             self.status_controller.start(status, notify=True)
-            while True:
+            start = 0
+            while start < total_comics:
                 obj_list = []
                 if self.abort_event.is_set():
                     break
                 # Not using standard iterator chunking to control memory and really
                 # do this in batches.
                 self.log.debug(
-                    f"Preparing up to {search_index_batch_size} comics for search indexing..."
+                    f"Preparing up to {chunk_human_size} comics for search indexing..."
+                )
+                # This query is supposed to get only comics that don't need creating but it doesn't
+                # So the start total exit assists it with that.
+                comics = self._get_operation_comics_query(
+                    comics_filtered_qs, create=create
                 )
-                comics = comics_filtered_qs
-                comics = self._select_related_fts_query(comics)
                 comics = self._prefetch_related_fts_query(comics)
                 comics = comics.order_by("pk")
                 comics = comics[:search_index_batch_size]
                 comics = self._annotate_fts_query(comics)
-                for comic in comics:
-                    self._create_comicfts_entry(comic, obj_list, create=create)
+                for comic in comics.values():
+                    SearchEntryPrepare.prepare_sync_fts_entry(
+                        comic, obj_list, create=create
+                    )
 
                 if not obj_list:
                     break
@@ -325,6 +226,7 @@ class SearchIndexerSync(SearchIndexerRemove):
                     status,
                     create=create,
                 )
+                start += search_index_batch_size
 
         finally:
             self.status_controller.finish(status)
@@ -332,25 +234,36 @@ class SearchIndexerSync(SearchIndexerRemove):
 
     def _update_search_index_update(self):
         """Update out of date search entries."""
+        out_of_date_comics = Comic.objects.filter(_ALL_FTS_COMIC_IDS_QUERY)
+        self.log.debug("Looking for search index watermark...")
         fts_watermark = ComicFTS.objects.aggregate(max=Max("updated_at"))["max"]
-        since = fts_watermark or "the fracturing of the multiverse"
+        if fts_watermark:
+            since = fts_watermark
+            out_of_date_comics = out_of_date_comics.filter(updated_at__gt=fts_watermark)
+        else:
+            since = "the fracturing of the multiverse"
+            fts_watermark = fts_watermark or _MIN_UTC_DATE
         self.log.info(f"Looking for search entries to update since {since}...")
-        fts_watermark = fts_watermark or _MIN_UTC_DATE
-        out_of_date_comics = Comic.objects.filter(
-            pk__in=ComicFTS.objects.values("comic_id"), updated_at__gt=fts_watermark
-        )
+        count = out_of_date_comics.count()
+        self.log.debug(f"Found {count} comics with out of date search entries.")
+
         return self._update_search_index_operate(out_of_date_comics, create=False)
 
     def _update_search_index_create(self):
         """Create missing search entries."""
         self.log.info("Looking for missing search entries to create...")
-        missing_comics = Comic.objects.exclude(
-            pk__in=ComicFTS.objects.values("comic_id")
-        )
+        missing_comics = Comic.objects.all()
+        count = None if ComicFTS.objects.exists() else missing_comics.count()
+        missing_comics = missing_comics.exclude(_ALL_FTS_COMIC_IDS_QUERY)
+        if count is None:
+            count = missing_comics.count()
+
+        self.log.debug(f"Found {count} comics missing from the search index.")
         return self._update_search_index_operate(missing_comics, create=True)
 
     def _update_search_index(self, *, rebuild: bool):
         """Update or Rebuild the search index."""
+        self.log.debug("In update search index before init statii.")
         start_time = time()
         self._init_statuses(rebuild)
 

codex/migrations/0035_fts_optmize.py

@@ -0,0 +1,136 @@
+"""Generated by Django 5.2.4 on 2025-07-21 15:05."""
+
+from itertools import chain
+
+import django.db.models.deletion
+from comicbox.enums.maps.identifiers import ID_SOURCE_NAME_MAP, get_id_source_by_alias
+from django.db import migrations, models
+
+
+def _map_identifiers_to_canonical_names(apps):
+    id_source_model = apps.get_model("codex", "identifiersource")
+    identifier_source_map = {}
+
+    for source in id_source_model.objects.all():
+        if id_source_enum := get_id_source_by_alias(source.name, default=None):
+            canon_name = ID_SOURCE_NAME_MAP.get(id_source_enum, source.name)
+            if canon_name != source.name:
+                if canon_name not in identifier_source_map:
+                    identifier_source_map[canon_name] = set()
+                identifier_source_map[canon_name] |= set(
+                    source.identifier_set.values_list("pk", flat=True)
+                )
+    return identifier_source_map
+
+
+def _prepare_canonical_id_sources(apps, identifier_source_map):
+    id_source_model = apps.get_model("codex", "identifiersource")
+    source_names = identifier_source_map.keys()
+    existing_id_sources = id_source_model.objects.filter(name__in=source_names).only(
+        "name"
+    )
+    existing_id_source_names = id_source_model.objects.filter(
+        name__in=source_names
+    ).values_list("name", flat=True)
+    create_id_source_names = sorted(
+        frozenset(set(identifier_source_map.keys()) - set(existing_id_source_names))
+    )
+    return tuple(
+        id_source_model(name=name) for name in create_id_source_names
+    ), existing_id_sources
+
+
+def _create_link_map(identifier_source_map, sources):
+    link_map = {}
+    for id_source in chain(*sources):
+        for id_pk in identifier_source_map[id_source.name]:
+            link_map[id_pk] = id_source
+    return link_map
+
+
+def _prepare_updatatable_identifiers(apps, identifier_source_map, sources):
+    link_map = _create_link_map(identifier_source_map, sources)
+    identifier_model = apps.get_model("codex", "identifier")
+    updateable_identifiers = identifier_model.objects.filter(pk__in=link_map.keys())
+    obj_list = []
+    for identifier in updateable_identifiers:
+        identifier.source = link_map[identifier.pk]
+        obj_list.append(identifier)
+    return tuple(obj_list)
+
+
+def _create_canonical_sources(apps):
+    print("Examining identifier sources for conversion to canonical sources...")
+    identifier_source_map = _map_identifiers_to_canonical_names(apps)
+    print("Preparing missing canonical identifiers sources for creation...")
+    obj_list, existing_id_sources = _prepare_canonical_id_sources(
+        apps, identifier_source_map
+    )
+    id_source_model = apps.get_model("codex", "identifiersource")
+    created_id_sources = id_source_model.objects.bulk_create(obj_list)
+    count = len(obj_list)
+    print(f"Created {count} canonical identifier sources")
+    return identifier_source_map, (existing_id_sources, created_id_sources)
+
+
+def _update_identifiers_with_canonical_sources(apps, identifier_source_map, sources):
+    print("Preparing identifiers for update with canonical sources...")
+    obj_list = _prepare_updatatable_identifiers(apps, identifier_source_map, sources)
+    identifier_model = apps.get_model("codex", "identifier")
+    identifier_model.objects.bulk_update(obj_list, fields=("source",))
+    count = len(obj_list)
+    print(f"Updated {count} identifiers with canonical sources.")
+
+
+def _convert_identifier_sources(apps, _schema_editor):
+    identifier_source_map, sources = _create_canonical_sources(apps)
+    _update_identifiers_with_canonical_sources(apps, identifier_source_map, sources)
+
+
+class Migration(migrations.Migration):
+    """Migrate db."""
+
+    dependencies = [
+        ("codex", "0034_comicbox2"),
+    ]
+
+    operations = [
+        migrations.RunPython(_convert_identifier_sources),
+        migrations.SeparateDatabaseAndState(
+            database_operations=[
+                migrations.RunSQL(
+                    sql="DROP TABLE IF EXISTS codex_comicfts;",
+                ),
+                migrations.RunSQL(
+                    sql="CREATE VIRTUAL TABLE codex_comicfts USING fts5(comic_id UNINDEXED, created_at UNINDEXED, updated_at UNINDEXED, publisher, imprint, series, name, collection_title, age_rating, country, language, original_format, review, scan_info, summary, tagger, characters, credits, genres, locations, roles, series_groups, stories, story_arcs, tags, teams, universes, sources)",
+                    reverse_sql="DROP TABLE IF EXISTS codex_comicfts",
+                ),
+            ],
+            state_operations=[
+                migrations.DeleteModel(
+                    name="ComicFTS",
+                ),
+                migrations.CreateModel(
+                    name="ComicFTS",
+                    fields=[
+                        ("created_at", models.DateTimeField(auto_now_add=True)),
+                        ("updated_at", models.DateTimeField(auto_now=True)),
+                        (
+                            "comic",
+                            models.OneToOneField(
+                                on_delete=django.db.models.deletion.CASCADE,
+                                primary_key=True,
+                                serialize=False,
+                                to="codex.comic",
+                            ),
+                        ),
+                        ("body", models.TextField()),
+                    ],
+                    options={
+                        "get_latest_by": "updated_at",
+                        "managed": False,
+                    },
+                ),
+            ],
+        ),
+    ]

codex/models/comic.py

@@ -326,23 +326,12 @@ class Comic(WatchedPathBrowserGroup):
         """Most common text representation for logging."""
         return self.get_title(self, volume=True, name=True, filename_fallback=True)
 
-    def issue(self) -> str:
-        """Combine issue parts for search."""
-        res = ""
-        if self.issue_number is not None:
-            res += str(self.issue_number.normalize())
-        if self.issue_suffix:
-            res += self.issue_suffix
-        return res
-
 
 class ComicFTS(BaseModel):
     comic = OneToOneField(primary_key=True, to=Comic, on_delete=CASCADE)
     # Attributes
     collection_title = CharField(db_collation="nocase", max_length=MAX_NAME_LEN)
-    issue = CharField(db_collation="nocase", max_length=MAX_NAME_LEN)
     name = CharField(db_collation="nocase", max_length=MAX_NAME_LEN)
-    notes = TextField(db_collation="nocase")
     review = TextField(db_collation="nocase")
     summary = TextField(db_collation="nocase")
     # FK groups
@@ -352,7 +341,6 @@ class ComicFTS(BaseModel):
     # FK
     age_rating = CharField(db_collation="nocase", max_length=MAX_NAME_LEN)
     country = CharField(db_collation="nocase", max_length=MAX_NAME_LEN)
-    file_type = CharField(db_collation="nocase", max_length=max_choices_len(FileType))
     language = CharField(db_collation="nocase", max_length=MAX_NAME_LEN)
     original_format = CharField(db_collation="nocase", max_length=MAX_NAME_LEN)
     scan_info = CharField(db_collation="nocase", max_length=MAX_NAME_LEN)
@@ -361,12 +349,8 @@ class ComicFTS(BaseModel):
     characters = CharField(db_collation="nocase", max_length=MAX_NAME_LEN)
     credits = CharField(db_collation="nocase", max_length=MAX_NAME_LEN)
     genres = CharField(db_collation="nocase", max_length=MAX_NAME_LEN)
-    identifiers = CharField(db_collation="nocase", max_length=MAX_NAME_LEN)
     sources = CharField(db_collation="nocase", max_length=MAX_NAME_LEN)
     locations = CharField(db_collation="nocase", max_length=MAX_NAME_LEN)
-    reading_direction = CharField(
-        db_collation="nocase", max_length=max_choices_len(ReadingDirection)
-    )
     series_groups = CharField(db_collation="nocase", max_length=MAX_NAME_LEN)
     stories = CharField(db_collation="nocase", max_length=MAX_NAME_LEN)
     story_arcs = CharField(db_collation="nocase", max_length=MAX_NAME_LEN)

codex/models/functions.py

@@ -2,7 +2,7 @@
 
 from django.db.models.aggregates import Aggregate
 from django.db.models.expressions import Func
-from django.db.models.fields import CharField, FloatField
+from django.db.models.fields import CharField, FloatField, TextField
 from django.db.models.fields.json import JSONField
 from django.db.models.fields.related import OneToOneField
 from django.db.models.lookups import Lookup
@@ -55,12 +55,14 @@ class FTS5Match(Lookup):
 
 
 @CharField.register_lookup
+@TextField.register_lookup
 @CleaningCharField.register_lookup
 @CleaningTextField.register_lookup
 class Like(Lookup):
     """SQL LIKE lookup."""
 
     lookup_name = "like"
+    prepare_rhs = False
 
     @override
     def as_sql(self, compiler, connection):