codex 1.7.15__py3-none-any.whl → 1.8.0__py3-none-any.whl

codex/librarian/scribe/importer/const.py

@@ -0,0 +1,369 @@
+"""Consts and maps for import."""
+
+from types import MappingProxyType, SimpleNamespace
+
+from bidict import frozenbidict
+from django.db.models.fields import Field
+from django.db.models.fields.related import ForeignObjectRel, ManyToManyField
+
+from codex.models.base import BaseModel
+from codex.models.comic import Comic
+from codex.models.groups import (
+    BrowserGroupModel,
+    Folder,
+    Imprint,
+    Publisher,
+    Series,
+    Volume,
+)
+from codex.models.identifier import Identifier, IdentifierSource
+from codex.models.named import (
+    AgeRating,
+    Character,
+    Country,
+    Credit,
+    CreditPerson,
+    CreditRole,
+    Genre,
+    Language,
+    Location,
+    OriginalFormat,
+    ScanInfo,
+    SeriesGroup,
+    Story,
+    StoryArc,
+    StoryArcNumber,
+    Tag,
+    Tagger,
+    Team,
+    Universe,
+)
+from codex.models.paths import CustomCover
+
+###############
+# FIELD NAMES #
+###############
+FOLDERS_FIELD_NAME = "folders"
+PUBLISHER_FIELD_NAME = "publisher"
+IMPRINT_FIELD_NAME = "imprint"
+VOLUME_FIELD_NAME = "volume"
+SERIES_FIELD_NAME = "series"
+PARENT_FOLDER_FIELD_NAME = "parent_folder"
+VOLUME_COUNT_FIELD_NAME = "volume_count"
+ISSUE_COUNT_FIELD_NAME = "issue_count"
+PATH_FIELD_NAME = "path"
+NON_FTS_FIELDS = frozenset(
+    {
+        # Attributes
+        "critical_rating",
+        "day",
+        "metadata_mtime",
+        "monochrome",
+        "month",
+        "page_count",
+        "path",
+        "year",
+        "issue_number",
+        "issue_suffix",
+        # FKs
+        PARENT_FOLDER_FIELD_NAME,
+        VOLUME_FIELD_NAME,
+        # M2Ms
+        FOLDERS_FIELD_NAME,
+    }
+)
+
+##########################
+# IMPORTER METADATA KEYS #
+##########################
+EXTRACTED = "extracted"
+SKIPPED = "skipped"
+QUERY_MODELS = "query_models"
+CREATE_COMICS = "create_comics"
+CREATE_FKS = "create_fks"
+CREATE_COVERS = "create_covers"
+UPDATE_COMICS = "update_comics"
+UPDATE_FKS = "update_fks"
+UPDATE_COVERS = "update_covers"
+LINK_COVER_PKS = "link_cover_pks"
+LINK_FKS = "link_fks"
+LINK_M2MS = "link_m2ms"
+DELETE_M2MS = "delete_m2ms"
+FIS = "fis"
+TOTAL = "total"
+FK_KEYS = SimpleNamespace(CREATE_FKS=CREATE_FKS, UPDATE_FKS=UPDATE_FKS)
+FTS_UPDATE = "fts_update"
+FTS_CREATE = "fts_create"
+FTS_EXISTING_M2MS = "fts_existing_m2ms"
+FTS_CREATED_M2MS = "fts_created_m2ms"
+FTS_UPDATED_M2MS = "fts_updated_m2ms"
+
+#######
+# M2M #
+#######
+GROUP_MODEL_COUNT_FIELDS: MappingProxyType[type[BrowserGroupModel], str | None] = (
+    MappingProxyType(
+        {
+            Publisher: None,
+            Imprint: None,
+            Series: VOLUME_COUNT_FIELD_NAME,
+            Volume: ISSUE_COUNT_FIELD_NAME,
+        }
+    )
+)
+COMIC_M2M_FIELDS: tuple[ManyToManyField, ...] = tuple(  # pyright: ignore[reportAssignmentType]
+    field for field in Comic._meta.get_fields() if field.many_to_many
+)
+COMIC_M2M_FIELD_NAMES: tuple[str, ...] = tuple(field.name for field in COMIC_M2M_FIELDS)
+COMPLEX_M2M_MODELS = (Credit, Identifier, StoryArcNumber)
+
+########################
+# COMPLEX M2M METADATA #
+########################
+DictModelType = Credit | Identifier | StoryArcNumber
+CREDITS_FIELD_NAME = "credits"
+CREDIT_PERSON_FIELD_NAME = "person"
+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"
+IDENTIFIER_URL_FIELD_NAME = "url"
+UNIVERSES_FIELD_NAME = "universes"
+NAME_FIELD_NAME = "name"
+NUMBER_TO_FIELD_NAME = "number_to"
+IDENTIFIER_FIELD_NAME = "identifier"
+DESIGNATION_FIELD_NAME = "designation"
+
+########################
+# QUERY AND CREATE FKS #
+########################
+COMIC_FK_FIELDS: tuple[Field | ForeignObjectRel, ...] = tuple(
+    field
+    for field in Comic._meta.get_fields()
+    if field
+    and field.many_to_one
+    and field.name != "library"
+    and field.related_model
+    and not issubclass(field.related_model, BrowserGroupModel)
+)
+_GROUP_FIELD_NAMES = ("publisher", "imprint", "series", "volume")
+_COMIC_GROUP_FIELDS: tuple[Field, ...] = tuple(
+    Comic._meta.get_field(field_name) for field_name in _GROUP_FIELD_NAMES
+)
+ALL_COMIC_FK_FIELDS = (*_COMIC_GROUP_FIELDS, *COMIC_FK_FIELDS)
+COMIC_FK_FIELD_NAMES: tuple[str, ...] = tuple(
+    field.name for field in ALL_COMIC_FK_FIELDS
+)
+PROTAGONIST_FIELD_MODEL_MAP = MappingProxyType(
+    {"main_character": Character, "main_team": Team}
+)
+_DEFAULT_KEY_INDEX = 1
+_IDENTIFIER_RELS = (
+    "identifier__source__name",
+    "identifier__id_type",
+    "identifier__key",
+)
+_NAMED_MODEL_RELS = ((NAME_FIELD_NAME,), "")
+NAMED_MODELS = frozenset(
+    {
+        AgeRating,
+        Country,
+        Language,
+        OriginalFormat,
+        Tagger,
+        ScanInfo,
+        SeriesGroup,
+        IdentifierSource,
+    }
+)
+_IDENTIFIED_MODEL_RELS = ((NAME_FIELD_NAME,), _IDENTIFIER_RELS)
+IDENTIFIED_MODELS = frozenset(
+    {Character, CreditPerson, CreditRole, Genre, Location, Story, StoryArc, Tag, Team}
+)
+MODEL_REL_MAP: MappingProxyType[type[BaseModel], tuple[str | tuple[str, ...], ...]] = (
+    MappingProxyType(
+        {
+            **dict.fromkeys(NAMED_MODELS, _NAMED_MODEL_RELS),
+            **dict.fromkeys(IDENTIFIED_MODELS, _IDENTIFIED_MODEL_RELS),
+            Identifier: (
+                (
+                    f"{IDENTIFIER_SOURCE_FIELD_NAME}__name",
+                    IDENTIFIER_TYPE_FIELD_NAME,
+                    IDENTIFIER_ID_KEY_FIELD_NAME,
+                ),
+                "",
+                IDENTIFIER_URL_FIELD_NAME,
+            ),
+            Publisher: _IDENTIFIED_MODEL_RELS,
+            Imprint: (
+                (
+                    "publisher__name",
+                    NAME_FIELD_NAME,
+                ),
+                _IDENTIFIER_RELS,
+            ),
+            Series: (
+                (
+                    "publisher__name",
+                    "imprint__name",
+                    NAME_FIELD_NAME,
+                ),
+                _IDENTIFIER_RELS,
+                VOLUME_COUNT_FIELD_NAME,
+            ),
+            Volume: (
+                (
+                    "publisher__name",
+                    "imprint__name",
+                    "series__name",
+                    NAME_FIELD_NAME,
+                    NUMBER_TO_FIELD_NAME,
+                ),
+                "",
+                ISSUE_COUNT_FIELD_NAME,
+            ),
+            Folder: (
+                (PATH_FIELD_NAME,),
+                "",
+            ),
+            Credit: (
+                (
+                    f"{CREDIT_PERSON_FIELD_NAME}__name",
+                    f"{CREDIT_ROLE_FIELD_NAME}__name",
+                ),
+                "",
+            ),
+            StoryArcNumber: (
+                (f"{STORY_ARC_FIELD_NAME}__name", NUMBER_FIELD_NAME),
+                "",
+            ),
+            Universe: ((NAME_FIELD_NAME,), _IDENTIFIER_RELS, DESIGNATION_FIELD_NAME),
+        }
+    )
+)
+_IDENTIFIED_SELECT_RELATED = ("identifier", "identifier__source")
+MODEL_SELECT_RELATED: MappingProxyType[type[BaseModel], tuple[str, ...]] = (
+    MappingProxyType(
+        {
+            **dict.fromkeys(IDENTIFIED_MODELS, _IDENTIFIED_SELECT_RELATED),
+            Identifier: (IDENTIFIER_SOURCE_FIELD_NAME,),
+            Publisher: _IDENTIFIED_SELECT_RELATED,
+            Imprint: ("publisher",),
+            Series: ("publisher", "imprint"),
+            Volume: ("publisher", "imprint", "series"),
+            Credit: (CREDIT_PERSON_FIELD_NAME, CREDIT_ROLE_FIELD_NAME),
+            StoryArcNumber: (STORY_ARC_FIELD_NAME,),
+            Universe: _IDENTIFIED_SELECT_RELATED,
+        }
+    )
+)
+FIELD_NAME_KEYS_REL_MAP = MappingProxyType(
+    {
+        field.name: MODEL_REL_MAP[field.related_model][0]  # pyright: ignore[reportArgumentType]
+        for field in (*ALL_COMIC_FK_FIELDS, *COMIC_M2M_FIELDS)
+    }
+)
+_NAMED_MODEL_ATTRS = ("name",)
+_IDENTIFIER_KEY_ATTRS = (
+    IDENTIFIER_SOURCE_FIELD_NAME,
+    IDENTIFIER_TYPE_FIELD_NAME,
+    IDENTIFIER_ID_KEY_FIELD_NAME,
+)
+FIELD_NAME_KEY_ATTRS_MAP = MappingProxyType(
+    {
+        **dict.fromkeys(COMIC_M2M_FIELD_NAMES, _NAMED_MODEL_ATTRS),
+        FOLDERS_FIELD_NAME: ("path",),
+        IDENTIFIER_FIELD_NAME: _IDENTIFIER_KEY_ATTRS,
+        IDENTIFIERS_FIELD_NAME: _IDENTIFIER_KEY_ATTRS,
+        PUBLISHER_FIELD_NAME: _NAMED_MODEL_ATTRS,
+        IMPRINT_FIELD_NAME: (PUBLISHER_FIELD_NAME, *_NAMED_MODEL_ATTRS),
+        SERIES_FIELD_NAME: (
+            PUBLISHER_FIELD_NAME,
+            IMPRINT_FIELD_NAME,
+            *_NAMED_MODEL_ATTRS,
+        ),
+        VOLUME_FIELD_NAME: (
+            PUBLISHER_FIELD_NAME,
+            IMPRINT_FIELD_NAME,
+            SERIES_FIELD_NAME,
+            *_NAMED_MODEL_ATTRS,
+        ),
+        CREDITS_FIELD_NAME: (CREDIT_PERSON_FIELD_NAME, CREDIT_ROLE_FIELD_NAME),
+        STORY_ARC_NUMBERS_FIELD_NAME: (STORY_ARC_FIELD_NAME, NUMBER_FIELD_NAME),
+    }
+)
+
+
+def get_key_index(model: type[BaseModel]) -> int:
+    """Return the key index divider for a model tuple."""
+    return len(MODEL_REL_MAP[model][0])
+
+
+#################
+# CREATE COMICS #
+#################
+_EXCLUDEBULK_UPDATE_COMIC_FIELDS = {
+    "bookmark",
+    "created_at",
+    "id",
+    "library",
+    "comicfts",
+}
+BULK_UPDATE_COMIC_FIELDS = tuple(
+    sorted(
+        field.name
+        for field in Comic._meta.get_fields()
+        if (not field.many_to_many)
+        and (field.name not in _EXCLUDEBULK_UPDATE_COMIC_FIELDS)
+    )
+)
+BULK_CREATE_COMIC_FIELDS = (*BULK_UPDATE_COMIC_FIELDS, "library")
+BULK_UPDATE_FOLDER_FIELDS = (
+    "name",
+    "parent_folder",
+    "path",
+    "sort_name",
+    "stat",
+    "updated_at",
+)
+BULK_UPDATE_FOLDER_MODIFIED_FIELDS = ("stat", "updated_at")
+
+##########
+# COVERS #
+##########
+CLASS_CUSTOM_COVER_GROUP_MAP = frozenbidict(
+    {
+        Publisher: CustomCover.GroupChoice.P.value,
+        Imprint: CustomCover.GroupChoice.I.value,
+        Series: CustomCover.GroupChoice.S.value,
+        StoryArc: CustomCover.GroupChoice.A.value,
+        Folder: CustomCover.GroupChoice.F.value,
+    }
+)
+
+#########
+# MOVED #
+#########
+MOVED_BULK_COMIC_UPDATE_FIELDS = ("path", "parent_folder", "stat", "updated_at")
+CUSTOM_COVER_UPDATE_FIELDS = ("path", "stat", "updated_at", "sort_name", "group")
+
+###########
+# DELETED #
+###########
+ALL_COMIC_GROUP_FIELD_NAMES = (
+    *_GROUP_FIELD_NAMES,
+    "story_arc_numbers",
+    "folders",
+)
+
+##########
+# Failed #
+##########
+UPDATE_FIS = "update_fis"
+CREATE_FIS = "create_fis"
+DELETE_FI_PATHS = "delete_fi_paths"
+BULK_UPDATE_FAILED_IMPORT_FIELDS = ("name", "stat", "updated_at")

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

@@ -0,0 +1,37 @@
+"""
+Create all missing comic foreign keys for an import.
+
+So we may safely create the comics next.
+"""
+
+from codex.librarian.scribe.importer.create.foreign_keys import (
+    CreateForeignKeysCreateUpdateImporter,
+)
+
+
+class CreateForeignKeysImporter(CreateForeignKeysCreateUpdateImporter):
+    """Methods for creating foreign keys."""
+
+    def create_and_update(self):
+        """Create and update FKs, covers and comics."""
+        if self.abort_event.is_set():
+            return
+        fk_count = self.create_all_fks()
+        if self.abort_event.is_set():
+            return
+        fk_count += self.update_all_fks()
+        self.counts.tags = fk_count
+        if self.abort_event.is_set():
+            return
+
+        cover_count = self.create_custom_covers()
+        if self.abort_event.is_set():
+            return
+        cover_count += self.update_custom_covers()
+        self.counts.covers = cover_count
+
+        if self.abort_event.is_set():
+            return
+        comic_count = self.update_comics()
+        comic_count += self.create_comics()
+        self.counts.comic = comic_count

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

@@ -0,0 +1,172 @@
+"""Bulk update and create comic objects and bulk update m2m fields."""
+
+from django.db.models import NOT_PROVIDED
+from django.db.models.functions import Now
+
+from codex.librarian.scribe.importer.const import (
+    BULK_CREATE_COMIC_FIELDS,
+    BULK_UPDATE_COMIC_FIELDS,
+    CREATE_COMICS,
+    FTS_CREATE,
+    FTS_UPDATE,
+    LINK_FKS,
+    NON_FTS_FIELDS,
+    PATH_FIELD_NAME,
+    UPDATE_COMICS,
+)
+from codex.librarian.scribe.importer.create.link_fks import (
+    CreateForeignKeyLinksImporter,
+)
+from codex.librarian.scribe.importer.statii.create import (
+    ImporterCreateComicsStatus,
+    ImporterUpdateComicsStatus,
+)
+from codex.models import Comic
+
+
+class CreateComicsImporter(CreateForeignKeyLinksImporter):
+    """Create comics methods."""
+
+    def _populate_fts_attribute_values(self, key: str, sub_key: str | int, md):
+        if sub_key not in self.metadata[key]:
+            self.metadata[key][sub_key] = {}
+        for field_name, value in md.items():
+            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():
+            setattr(comic, field_name, value)
+
+        self._populate_fts_attribute_values(FTS_UPDATE, comic.pk, md)
+        link_md = self.get_comic_fk_links(comic.pk, comic.path)
+        for field_name, value in link_md.items():
+            set_value = value
+            if set_value is None:
+                default_value = Comic._meta.get_field(field_name).default
+                if default_value != NOT_PROVIDED:
+                    set_value = default_value
+            setattr(comic, field_name, set_value)
+        comic.presave()
+        comic.updated_at = Now()
+        update_comics.append(comic)
+        comic_pks.append(comic.pk)
+
+    def update_comics(self):
+        """Bulk update comics, and move nonextant comics into create job.."""
+        count = 0
+        pks = tuple(sorted(self.metadata[UPDATE_COMICS].keys()))
+        num_comics = len(pks)
+        status = ImporterUpdateComicsStatus(None, num_comics)
+        try:
+            if not num_comics:
+                self.metadata.pop(UPDATE_COMICS)
+                self.status_controller.finish(status)
+                return count
+
+            self.log.debug(
+                f"Preparing {num_comics} comics for update in library {self.library.path}."
+            )
+            self.status_controller.start(status)
+            self.metadata[FTS_UPDATE] = {}
+            # Get existing comics to update
+            comics = Comic.objects.filter(library=self.library, pk__in=pks).only(
+                PATH_FIELD_NAME, *BULK_UPDATE_COMIC_FIELDS
+            )
+
+            # set attributes for each comic
+            update_comics = []
+            comic_pks = []
+            for comic in comics:
+                if self.abort_event.is_set():
+                    return count
+                try:
+                    self._update_comic_values(comic, update_comics, comic_pks)
+                except Exception:
+                    self.log.exception(f"Error preparing {comic} for update.")
+            self.metadata.pop(UPDATE_COMICS)
+
+            count = len(update_comics)
+            if count:
+                self.log.debug(f"Bulk updating {len(update_comics)} comics.")
+                Comic.objects.bulk_update(update_comics, BULK_UPDATE_COMIC_FIELDS)
+                if comic_pks:
+                    self.log.debug(
+                        f"Purging covers for {len(comic_pks)} updated comics."
+                    )
+                    self.remove_covers(comic_pks, custom=False)
+        except Exception:
+            self.log.exception(f"While updating comics: {pks}")
+        finally:
+            self.status_controller.finish(status)
+        return count
+
+    def _bulk_create_comic(self, path: str, create_comics: list[Comic]):
+        md = self.metadata[CREATE_COMICS].pop(path, {})
+        self._populate_fts_attribute_values(FTS_CREATE, path, md)
+        link_md = self.get_comic_fk_links(path, path)
+        md.update(link_md)
+        if not md:
+            return
+        comic = Comic(**md, library=self.library)
+        comic.presave()
+        create_comics.append(comic)
+
+    def create_comics(self):
+        """Bulk create comics."""
+        count = 0
+        paths = tuple(sorted(self.metadata[CREATE_COMICS].keys()))
+        num_comics = len(paths)
+        status = ImporterCreateComicsStatus(None, num_comics)
+        try:
+            if not num_comics:
+                self.metadata.pop(CREATE_COMICS)
+                self.metadata.pop(LINK_FKS)
+                self.status_controller.finish(status)
+                return count
+
+            self.log.debug(
+                f"Preparing {num_comics} comics for creation in library {self.library.path}."
+            )
+            self.status_controller.start(status)
+
+            self.metadata[FTS_CREATE] = {}
+            create_comics = []
+            for path in paths:
+                if self.abort_event.is_set():
+                    return count
+                try:
+                    self._bulk_create_comic(path, create_comics)
+                except KeyError:
+                    self.log.warning(f"No comic metadata for {path}")
+                    self.log.exception(f"Error preparing {path} for create.")
+                except Exception:
+                    self.log.exception(f"Error preparing {path} for create.")
+            self.metadata.pop(CREATE_COMICS)
+            self.metadata.pop(LINK_FKS)
+
+            num_comics = len(create_comics)
+            if num_comics:
+                self.log.debug(f"Bulk creating {num_comics} comics...")
+                created_comics = Comic.objects.bulk_create(
+                    create_comics,
+                    update_conflicts=True,
+                    update_fields=BULK_CREATE_COMIC_FIELDS,
+                    unique_fields=Comic._meta.unique_together[0],
+                )
+                count = len(created_comics)
+
+                # Replace FTS_CREATE path keyed entries with pk keys
+                for created_comic in created_comics:
+                    self.metadata[FTS_CREATE][created_comic.pk] = self.metadata[
+                        FTS_CREATE
+                    ].pop(created_comic.path)
+        except Exception:
+            self.log.exception(f"While creating {num_comics} comics")
+        finally:
+            self.status_controller.finish(status)
+        return count

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

@@ -0,0 +1,131 @@
+"""Create fks consts."""
+
+from collections.abc import Mapping
+from types import MappingProxyType
+
+from codex.librarian.scribe.importer.const import (
+    CREDIT_PERSON_FIELD_NAME,
+    CREDIT_ROLE_FIELD_NAME,
+    DESIGNATION_FIELD_NAME,
+    IDENTIFIED_MODELS,
+    IDENTIFIER_FIELD_NAME,
+    IDENTIFIER_ID_KEY_FIELD_NAME,
+    IDENTIFIER_SOURCE_FIELD_NAME,
+    IDENTIFIER_TYPE_FIELD_NAME,
+    IDENTIFIER_URL_FIELD_NAME,
+    IMPRINT_FIELD_NAME,
+    ISSUE_COUNT_FIELD_NAME,
+    NAME_FIELD_NAME,
+    NAMED_MODELS,
+    NUMBER_FIELD_NAME,
+    NUMBER_TO_FIELD_NAME,
+    PUBLISHER_FIELD_NAME,
+    SERIES_FIELD_NAME,
+    STORY_ARC_FIELD_NAME,
+    VOLUME_COUNT_FIELD_NAME,
+)
+from codex.models import (
+    Credit,
+    StoryArc,
+    StoryArcNumber,
+    Volume,
+)
+from codex.models.base import BaseModel
+from codex.models.comic import Comic
+from codex.models.groups import Folder, Imprint, Publisher, Series
+from codex.models.identifier import (
+    Identifier,
+    IdentifierSource,
+)
+from codex.models.named import (
+    CreditPerson,
+    CreditRole,
+    Universe,
+)
+
+ORDERED_CREATE_MODELS = (
+    IdentifierSource,
+    Identifier,
+    Publisher,
+    Imprint,
+    Series,
+    Volume,
+)
+
+CUSTOM_COVER_MODELS = frozenset({Publisher, Imprint, Series, Volume, Folder, StoryArc})
+GROUP_BASE_MODELS = frozenset({Publisher, Imprint, Series, StoryArc})
+GROUP_BASE_FIELDS = ("name", "sort_name")
+DEFAULT_NON_NULL_CHARFIELD_NAMES = frozenset({"name"})
+NON_NULL_CHARFIELD_NAMES: MappingProxyType[type[BaseModel], frozenset[str]] = (
+    MappingProxyType(
+        {
+            Universe: frozenset({"designation"}),
+            Identifier: frozenset({"id_type", "key", "url"}),
+            Comic: frozenset({"path"}),
+            Volume: frozenset({}),
+        }
+    )
+)
+_NAMED_CREATE_ARGS = ({NAME_FIELD_NAME: None}, {})
+_IDENTIFIED_CREATE_ARGS = ({NAME_FIELD_NAME: None}, {IDENTIFIER_FIELD_NAME: Identifier})
+MODEL_CREATE_ARGS_MAP: MappingProxyType[
+    type[BaseModel], tuple[Mapping[str, type[BaseModel] | None], ...]
+] = MappingProxyType(
+    {
+        **dict.fromkeys(NAMED_MODELS, _NAMED_CREATE_ARGS),
+        Identifier: (
+            {
+                IDENTIFIER_SOURCE_FIELD_NAME: IdentifierSource,
+                IDENTIFIER_TYPE_FIELD_NAME: None,
+                IDENTIFIER_ID_KEY_FIELD_NAME: None,
+            },
+            {
+                IDENTIFIER_URL_FIELD_NAME: None,
+            },
+        ),
+        Publisher: _IDENTIFIED_CREATE_ARGS,
+        Imprint: (
+            {
+                PUBLISHER_FIELD_NAME: Publisher,
+                NAME_FIELD_NAME: None,
+            },
+            {IDENTIFIER_FIELD_NAME: Identifier},
+        ),
+        Series: (
+            {
+                PUBLISHER_FIELD_NAME: Publisher,
+                IMPRINT_FIELD_NAME: Imprint,
+                NAME_FIELD_NAME: None,
+            },
+            {IDENTIFIER_FIELD_NAME: Identifier, VOLUME_COUNT_FIELD_NAME: None},
+        ),
+        Volume: (
+            {
+                PUBLISHER_FIELD_NAME: Publisher,
+                IMPRINT_FIELD_NAME: Imprint,
+                SERIES_FIELD_NAME: Series,
+                NAME_FIELD_NAME: None,
+                NUMBER_TO_FIELD_NAME: None,
+            },
+            {ISSUE_COUNT_FIELD_NAME: None},
+        ),
+        **dict.fromkeys(IDENTIFIED_MODELS, _IDENTIFIED_CREATE_ARGS),
+        Credit: (
+            {
+                CREDIT_PERSON_FIELD_NAME: CreditPerson,
+                CREDIT_ROLE_FIELD_NAME: CreditRole,
+            },
+            {},
+        ),
+        StoryArcNumber: ({STORY_ARC_FIELD_NAME: StoryArc, NUMBER_FIELD_NAME: None}, {}),
+        Universe: (
+            {
+                NAME_FIELD_NAME: None,
+            },
+            {
+                IDENTIFIER_FIELD_NAME: Identifier,
+                DESIGNATION_FIELD_NAME: None,
+            },
+        ),
+    }
+)