codex 1.8.5__py3-none-any.whl → 1.8.8__py3-none-any.whl

codex/choices/admin.py

@@ -109,6 +109,7 @@ ADMIN_TASK_GROUPS: MappingProxyType[
                         "value": "search_index_clear",
                         "title": "Clear Search Index",
                         "desc": "of all entries",
+                        "confirm": "Are you sure? Resyncing the search index can take a while.",
                     },
                     {
                         "value": "db_fts_integrity_check",

codex/librarian/scribe/importer/const.py

@@ -52,24 +52,29 @@ PARENT_FOLDER_FIELD_NAME = "parent_folder"
 VOLUME_COUNT_FIELD_NAME = "volume_count"
 ISSUE_COUNT_FIELD_NAME = "issue_count"
 PATH_FIELD_NAME = "path"
+IDENTIFIERS_FIELD_NAME = "identifiers"
 NON_FTS_FIELDS = frozenset(
     {
         # Attributes
         "critical_rating",
         "day",
+        "file_type",
+        "issue_number",
+        "issue_suffix",
         "metadata_mtime",
         "monochrome",
         "month",
+        "notes",
         "page_count",
         "path",
+        "reading_direction",
         "year",
-        "issue_number",
-        "issue_suffix",
         # FKs
         PARENT_FOLDER_FIELD_NAME,
         VOLUME_FIELD_NAME,
         # M2Ms
         FOLDERS_FIELD_NAME,
+        IDENTIFIERS_FIELD_NAME,
     }
 )
 
@@ -127,7 +132,6 @@ CREDIT_ROLE_FIELD_NAME = "role"
 STORY_ARC_NUMBERS_FIELD_NAME = "story_arc_numbers"
 STORY_ARC_FIELD_NAME = "story_arc"
 NUMBER_FIELD_NAME = "number"
-IDENTIFIERS_FIELD_NAME = "identifiers"
 IDENTIFIER_SOURCE_FIELD_NAME = "source"
 IDENTIFIER_TYPE_FIELD_NAME = "id_type"
 IDENTIFIER_ID_KEY_FIELD_NAME = "key"

codex/librarian/scribe/importer/create/comics.py

@@ -34,9 +34,6 @@ class CreateComicsImporter(CreateForeignKeyLinksImporter):
             if field_name not in NON_FTS_FIELDS:
                 self.metadata[key][sub_key][field_name] = (value,)
 
-        issue = (str(md.get("issue_number", "")) + md.get("issue_suffix", ""),)
-        self.metadata[key][sub_key]["issue"] = issue
-
     def _update_comic_values(self, comic: Comic, update_comics: list, comic_pks: list):
         md = self.metadata[UPDATE_COMICS].pop(comic.pk, {})
         for field_name, value in md.items():

codex/librarian/scribe/importer/delete/comics.py

@@ -4,7 +4,7 @@ from codex.librarian.scribe.importer.const import ALL_COMIC_GROUP_FIELD_NAMES
 from codex.librarian.scribe.importer.delete.covers import DeletedCoversImporter
 from codex.librarian.scribe.importer.statii.delete import ImporterRemoveComicsStatus
 from codex.models import Comic, Folder, StoryArc
-from codex.settings import MAX_CHUNK_SIZE
+from codex.settings import DELETE_MAX_CHUNK_SIZE
 
 
 class DeletedComicsImporter(DeletedCoversImporter):
@@ -29,7 +29,7 @@ class DeletedComicsImporter(DeletedCoversImporter):
         comics_deleted_qs = delete_qs.only(
             *ALL_COMIC_GROUP_FIELD_NAMES
         ).prefetch_related("story_arc_numbers__story_arc")
-        for comic in comics_deleted_qs.iterator(chunk_size=MAX_CHUNK_SIZE):
+        for comic in comics_deleted_qs.iterator(chunk_size=DELETE_MAX_CHUNK_SIZE):
             for field_name in ALL_COMIC_GROUP_FIELD_NAMES:
                 if field_name == "story_arc_numbers":
                     for san in comic.story_arc_numbers.select_related("story_arc").only(
@@ -47,10 +47,12 @@ class DeletedComicsImporter(DeletedCoversImporter):
 
     def bulk_comics_deleted(self, **kwargs) -> tuple[int, dict]:
         """Bulk delete comics found missing from the filesystem."""
+        count = 0
+        deleted_comic_groups = {}
         status = ImporterRemoveComicsStatus(0, len(self.task.files_deleted))
         try:
             if not self.task.files_deleted:
-                return 0, {}
+                return count, deleted_comic_groups
             self.status_controller.start(status)
             delete_qs = Comic.objects.filter(
                 library=self.library, path__in=self.task.files_deleted
@@ -60,7 +62,8 @@ class DeletedComicsImporter(DeletedCoversImporter):
             deleted_comic_groups = self._populate_deleted_comic_groups(delete_qs)
 
             delete_comic_pks = frozenset(delete_qs.values_list("pk", flat=True))
-            count, _ = delete_qs.delete()
+            delete_qs.delete()
+            count = len(delete_comic_pks)
 
             self.remove_covers(delete_comic_pks, custom=False)
         finally:

codex/librarian/scribe/importer/delete/folders.py

@@ -25,7 +25,8 @@ class DeletedFoldersImporter(DeletedComicsImporter):
                 .distinct()
                 .values_list("pk", flat=True)
             )
-            count, _ = folders.delete()
+            folders.delete()
+            count = len(delete_comic_pks)
 
             self.remove_covers(delete_comic_pks, custom=False)
         finally:

codex/librarian/scribe/importer/read/aggregate_path.py

@@ -23,17 +23,56 @@ from codex.librarian.scribe.importer.statii.failed import (
 )
 from codex.librarian.scribe.importer.statii.read import ImporterAggregateStatus
 
-_UNUSED_COMICBOX_FIELDS = (
-    "alternate_images",
-    "bookmark",
-    "credit_primaries",
-    "ext",
-    "manga",
-    "pages",
-    "prices",
-    "remainders",
-    "reprints",
-    "updated_at",
+_USED_COMICBOX_FIELDS = frozenset(
+    {
+        # "alternate_images",
+        "age_rating",
+        "arcs",
+        # "bookmark",
+        "characters",
+        "collection_title",
+        "country",
+        "credits",
+        # "credit_primaries",
+        "critical_rating",
+        "date",
+        # "ext",
+        "file_type",  # extra
+        "genres",
+        "identifiers",
+        # "identifier_primary_source",
+        "imprint",
+        "issue",
+        "language",
+        "locations",
+        "metadata_mtime",  # extra
+        "monochrome",
+        "notes",
+        "original_format",
+        "path",  # extra
+        # "pages",
+        "page_count",
+        "protagonist",
+        # "prices",
+        "publisher",
+        "reading_direction",
+        # "remainders",
+        # "reprints",
+        "review",
+        # "rights",
+        "scan_info",
+        "series",
+        "series_groups",
+        "stories",
+        "summary",
+        "tagger",
+        "tags",
+        "teams",
+        "title",
+        "universes",
+        # "updated_at",
+        "volume",
+    }
 )
 
 
@@ -42,8 +81,9 @@ class AggregateMetadataImporter(AggregatePathMetadataImporter):
 
     @staticmethod
     def _transform_metadata(md):
-        for key in _UNUSED_COMICBOX_FIELDS:
-            md.pop(key, None)
+        for key in tuple(md.keys()):
+            if key not in _USED_COMICBOX_FIELDS:
+                md.pop(key, None)
 
         if date := md.pop(DATE_KEY, None):
             date.pop(COVER_DATE_KEY, None)

codex/librarian/scribe/importer/read/extract.py

@@ -1,6 +1,6 @@
 """Extract metadata from comic archive."""
 
-from datetime import datetime
+from datetime import datetime, timezone
 from tarfile import TarError
 from zipfile import BadZipFile, LargeZipFile
 
@@ -29,7 +29,10 @@ class ExtractMetadataImporter(AggregateMetadataImporter):
             comic = Comic.objects.get(path=path)
         except Comic.DoesNotExist:
             return None
-        return comic.metadata_mtime
+        mtime = comic.metadata_mtime
+        if mtime and (mtime.tzinfo is None or mtime.tzinfo.utcoffset(mtime) is None):
+            mtime = mtime.replace(tzinfo=timezone.utc)
+        return mtime
 
     def _set_import_metadata_flag(self):
         """Set import_metadata flag."""
@@ -50,17 +53,17 @@ class ExtractMetadataImporter(AggregateMetadataImporter):
             with Comicbox(path, config=COMICBOX_CONFIG, logger=self.log) as cb:
                 if import_metadata:
                     new_md_mtime = cb.get_metadata_mtime()
-                    if self.task.check_metadata_mtime:
-                        old_md_mtime = self._metadata_mtime(path)
-                        if (
-                            old_md_mtime
-                            and new_md_mtime
-                            and new_md_mtime <= old_md_mtime
-                        ):
-                            return md
-                    md = cb.to_dict()
-                    md = md.get("comicbox", {})
-                    md["metadata_mtime"] = new_md_mtime
+                    if (
+                        not self.task.check_metadata_mtime
+                        or not new_md_mtime
+                        or not (old_md_mtime := self._metadata_mtime(path))
+                        or (new_md_mtime > old_md_mtime)
+                    ):
+                        md = cb.to_dict()
+                        md = md.get("comicbox", {})
+                        md["metadata_mtime"] = new_md_mtime
+                    else:
+                        md["page_count"] = cb.get_page_count()
                 else:
                     md["page_count"] = cb.get_page_count()
                 md["file_type"] = cb.get_file_type()

codex/librarian/scribe/importer/search/prepare.py

@@ -6,7 +6,6 @@ from codex.librarian.scribe.importer.const import (
     FTS_CREATED_M2MS,
     FTS_EXISTING_M2MS,
     FTS_UPDATE,
-    IDENTIFIERS_FIELD_NAME,
     NON_FTS_FIELDS,
     STORY_ARC_FIELD_NAME,
     STORY_ARC_NUMBERS_FIELD_NAME,
@@ -25,8 +24,6 @@ class SearchIndexPrepareImporter(SearchIndexCreateUpdateImporter):
         """Only store the fts relevant parts of complex links."""
         if field_name == CREDITS_FIELD_NAME:
             values = tuple(subvalues[0] for subvalues in values)
-        if field_name == IDENTIFIERS_FIELD_NAME:
-            values = tuple(subvalues[-1] for subvalues in values)
         elif field_name == STORY_ARC_NUMBERS_FIELD_NAME:
             field_name = STORY_ARC_FIELD_NAME + "s"
         return field_name, tuple(values)
@@ -41,10 +38,6 @@ class SearchIndexPrepareImporter(SearchIndexCreateUpdateImporter):
         """Add the existing values for creating a changed search entry."""
         if field_name in NON_FTS_FIELDS or not values:
             return
-        if field_name == IDENTIFIERS_FIELD_NAME:
-            # sources extracton must come before identifiers is minified
-            sources = tuple(subvalues[0] for subvalues in values)
-            self.add_to_fts_existing(pk, "sources", sources)
         field_name, values = self.minify_complex_link_to_fts_tuple(field_name, values)
         fts_values = self._to_fts_tuple(values)
         if not fts_values:

codex/librarian/scribe/importer/search/sync_m2m.py

@@ -52,7 +52,8 @@ class SearchIndexSyncManyToManyImporter(FinishImporter):
             .only(*update_fields)
         )
         for comicfts in comicftss:
-            setattr(comicfts, field_name, comicfts.fts_value)  # pyright: ignore[reportAttributeAccessIssue]
+            value = comicfts.fts_value.strip(",")  # pyright: ignore[reportAttributeAccessIssue]
+            setattr(comicfts, field_name, value)
             comicfts.updated_at = Now()
             update_objs.append(comicfts)
 

codex/librarian/scribe/importer/search/update.py

@@ -1,11 +1,7 @@
 """Search Index update."""
 
-from contextlib import suppress
 from time import time
 
-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 humanize import naturaldelta
 
 from codex.librarian.scribe.importer.const import (
@@ -13,10 +9,6 @@ from codex.librarian.scribe.importer.const import (
     FTS_EXISTING_M2MS,
     FTS_UPDATE,
 )
-from codex.librarian.scribe.importer.search.const import (
-    COMICFTS_UPDATE_FIELDS,
-    PYCOUNTRY_FIELDS,
-)
 from codex.librarian.scribe.importer.search.sync_m2m import (
     SearchIndexSyncManyToManyImporter,
 )
@@ -25,6 +17,8 @@ from codex.librarian.scribe.importer.statii.search import (
     ImporterFTSStatus,
     ImporterFTSUpdateStatus,
 )
+from codex.librarian.scribe.search.const import COMICFTS_UPDATE_FIELDS
+from codex.librarian.scribe.search.prepare import SearchEntryPrepare
 from codex.librarian.status import Status
 from codex.models.comic import ComicFTS
 
@@ -32,73 +26,17 @@ from codex.models.comic import ComicFTS
 class SearchIndexCreateUpdateImporter(SearchIndexSyncManyToManyImporter):
     """Search Index update methods."""
 
-    @staticmethod
-    def _get_pycountry_fts_field(entry, field_name) -> str:
-        iso_code = entry.get(field_name)
-        if not iso_code:
-            return ""
-        field = PYCOUNTRY_FIELDS[field_name]
-        return ",".join((iso_code, field.to_representation(iso_code)))
-
-    @staticmethod
-    def _get_sources_fts_field(entry) -> tuple[str, ...]:
-        sources = entry.get("sources", ())
-        names = []
-        for source_str in sources:
-            names.append(source_str)
-            with suppress(ValueError):
-                id_source = IdSources(source_str)
-                if long_name := ID_SOURCE_NAME_MAP.get(id_source):
-                    names.append(long_name)
-        return tuple(names)
-
-    @staticmethod
-    def _create_comicfts_entry_attributes(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")
-
-    @staticmethod
-    def _to_fts_values(value):
-        """Create a tuple of fts value strings."""
-        return tuple(
-            subvalue
-            for values_tuple in value
-            for subvalue in values_tuple
-            if isinstance(subvalue, str)
-        )
-
-    def _create_comicfts_entry_m2ms(self, pk: int, entry):
-        if sources := self._get_sources_fts_field(entry):
-            entry["sources"] = sources
-        if existing_values := self.metadata[FTS_EXISTING_M2MS].get(pk):
-            for field_name in tuple(existing_values.keys()):
-                if values := existing_values.get(field_name):
-                    entry[field_name] = entry.get(field_name, ()) + values
-
     def _create_comicfts_entry(
         self,
-        pk,
-        entry,
+        pk: int,
+        entry: dict,
         obj_list: list[ComicFTS],
         status: Status,
     ):
-        self._create_comicfts_entry_m2ms(pk, entry)
-        for field_name in entry:
-            value = entry[field_name]
-            if isinstance(value, tuple):
-                entry[field_name] = ",".join(sorted(value))
-        self._create_comicfts_entry_attributes(entry, create=True)
-        self._create_comicfts_entry_fks(entry)
-        comicfts = ComicFTS(comic_id=pk, **entry)
-        obj_list.append(comicfts)
-        status.increment_complete()
+        existing_m2m_values = self.metadata[FTS_EXISTING_M2MS].get(pk)
+        SearchEntryPrepare.prepare_import_fts_entry(
+            pk, entry, existing_m2m_values, None, obj_list, status, create=True
+        )
         self.status_controller.update(status)
 
     def _update_comicfts_entry(
@@ -109,17 +47,16 @@ class SearchIndexCreateUpdateImporter(SearchIndexSyncManyToManyImporter):
     ):
         comic_id = comicfts.comic_id  # pyright:ignore[reportAttributeAccessIssue], # ty: ignore[unresolved-attribute]
         entry = self.metadata[FTS_UPDATE].pop(comic_id)
-        self._create_comicfts_entry_m2ms(comic_id, entry)
-        for field_name in entry:
-            value = entry[field_name]
-            if isinstance(value, tuple):
-                entry[field_name] = ",".join(sorted(value))
-        self._create_comicfts_entry_attributes(entry, create=True)
-        self._create_comicfts_entry_fks(entry)
-        for field_name, value in entry.items():
-            setattr(comicfts, field_name, value)
-        obj_list.append(comicfts)
-        status.increment_complete()
+        existing_m2m_values = self.metadata[FTS_EXISTING_M2MS].get(comic_id)
+        SearchEntryPrepare.prepare_import_fts_entry(
+            comic_id,
+            entry,
+            existing_m2m_values,
+            comicfts,
+            obj_list,
+            status,
+            create=False,
+        )
         self.status_controller.update(status)
 
     def _update_search_index_operate_get_status(

codex/librarian/scribe/scribed.py

@@ -29,23 +29,12 @@ from codex.librarian.scribe.tasks import (
 )
 from codex.librarian.scribe.timestamp_update import TimestampUpdater
 from codex.librarian.threads import QueuedThread
-from codex.settings import SEARCH_INDEX_BATCH_SIZE
 
-_ABORT_SEARCH_UPDATE_TASKS = (
+ABORT_SEARCH_UPDATE_TASKS = (
     SearchIndexClearTask,
     SearchIndexSyncAbortTask,
     JanitorFTSRebuildTask,
 )
-_ABORT_SEARCH_UPDATE_ON_IMPORT_TASKS = (
-    ImportTask,
-    JanitorAdoptOrphanFoldersTask,
-)
-_ABORT_SEARCH_UPDATE_ON_IMPORT_BATCH_SIZE = 1000
-ABORT_SEARCH_UPDATE_TASKS = (
-    _ABORT_SEARCH_UPDATE_TASKS + _ABORT_SEARCH_UPDATE_ON_IMPORT_TASKS
-    if SEARCH_INDEX_BATCH_SIZE <= _ABORT_SEARCH_UPDATE_ON_IMPORT_BATCH_SIZE
-    else _ABORT_SEARCH_UPDATE_TASKS
-)
 
 
 class ScribeThread(QueuedThread):
@@ -118,7 +107,7 @@ class ScribeThread(QueuedThread):
                 self.log.debug("Abort cleanup db signal given.")
             elif isinstance(task, SearchIndexSyncAbortTask):
                 self.log.debug(
-                    "Search Index Update abort signal given. May take a bit for the current import subtask to finish."
+                    "Search Index Sync abort signal given. It may take a while for the current import chunk to finish."
                 )
                 return
         elif isinstance(task, ImportAbortTask):

codex/librarian/scribe/{importer/search → search}/const.py

@@ -1,16 +1,8 @@
-"""Search import consts."""
-
-from types import MappingProxyType
-
-from codex.serializers.fields.browser import CountryField, LanguageField
+"""FTS constants."""
 
 _COMICFTS_ATTRIBUTES = (
     "collection_title",
-    "file_type",
-    "issue",
     "name",
-    "notes",
-    "reading_direction",
     "review",
     "summary",
     "updated_at",
@@ -30,7 +22,6 @@ _COMICFTS_M2MS = (
     "characters",
     "credits",
     "genres",
-    "identifiers",
     "locations",
     "series_groups",
     "sources",
@@ -45,6 +36,3 @@ COMICFTS_UPDATE_FIELDS = (
     *_COMICFTS_FKS,
     *_COMICFTS_M2MS,
 )
-PYCOUNTRY_FIELDS = MappingProxyType(
-    {"country": CountryField(), "language": LanguageField()}
-)

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)