seerapi-models 1.0.0__py3-none-any.whl

seerapi_models/pet/pet.py

@@ -0,0 +1,482 @@
+from typing import TYPE_CHECKING, Optional, cast
+
+from pydantic import BaseModel
+from sqlmodel import Field, Integer, Relationship, SQLModel
+
+from seerapi_models.build_model import (
+    BaseCategoryModel,
+    BaseResModel,
+    ConvertToORM,
+)
+from seerapi_models.common import ResourceRef, SixAttributes, SixAttributesORM
+
+if TYPE_CHECKING:
+    from seerapi_models.element_type import TypeCombination, TypeCombinationORM
+    from seerapi_models.items import (
+        SkillActivationItem,
+        SkillActivationItemORM,
+        SuitBonusORM,
+    )
+    from seerapi_models.mintmark import MintmarkORM
+    from seerapi_models.skill import Skill, SkillORM
+
+    from . import (
+        PetArchiveStoryEntry,
+        PetArchiveStoryEntryORM,
+        PetEncyclopediaEntry,
+        PetEncyclopediaEntryORM,
+        PetSkinORM,
+        Soulmark,
+        SoulmarkORM,
+    )
+
+
+class BaseStatORM(SixAttributesORM, table=True):
+    id: int | None = Field(
+        default=None,
+        primary_key=True,
+        foreign_key='pet.id',
+    )
+    pet: 'PetORM' = Relationship(
+        back_populates='base_stats',
+        sa_relationship_kwargs={
+            'primaryjoin': 'BaseStatORM.id == PetORM.id',
+        },
+    )
+
+    @classmethod
+    def resource_name(cls) -> str:
+        return 'pet_base_stats'
+
+
+class YieldingEvORM(SixAttributesORM, table=True):
+    id: int | None = Field(default=None, primary_key=True, foreign_key='pet.id')
+    pet: 'PetORM' = Relationship(
+        back_populates='yielding_ev',
+        sa_relationship_kwargs={
+            'primaryjoin': 'YieldingEvORM.id == PetORM.id',
+        },
+    )
+
+    @classmethod
+    def resource_name(cls) -> str:
+        return 'pet_yielding_ev'
+
+
+class DiyStatsRangeORM(BaseResModel, table=True):
+    id: int = Field(default=None, primary_key=True, foreign_key='pet.id')
+    pet: 'PetORM' = Relationship(
+        back_populates='diy_stats',
+        sa_relationship_kwargs={
+            'primaryjoin': 'DiyStatsRangeORM.id == PetORM.id',
+        },
+    )
+    atk_min: int = Field(description='精灵自定义种族值攻击最小值')
+    def_min: int = Field(description='精灵自定义种族值防御最小值')
+    sp_atk_min: int = Field(description='精灵自定义种族值特攻最小值')
+    sp_def_min: int = Field(description='精灵自定义种族值特防最小值')
+    spd_min: int = Field(description='精灵自定义种族值速度最小值')
+    hp_min: int = Field(description='精灵自定义种族值体力最小值')
+    atk_max: int = Field(description='精灵自定义种族值攻击最大值')
+    def_max: int = Field(description='精灵自定义种族值防御最大值')
+    sp_atk_max: int = Field(description='精灵自定义种族值特攻最大值')
+    sp_def_max: int = Field(description='精灵自定义种族值特防最大值')
+    spd_max: int = Field(description='精灵自定义种族值速度最大值')
+    hp_max: int = Field(description='精灵自定义种族值体力最大值')
+
+    @classmethod
+    def resource_name(cls) -> str:
+        return 'pet_diy_stats_range'
+
+
+class DiyStatsRange(BaseModel):
+    min: SixAttributes = Field(description='精灵自定义种族值最小值')
+    max: SixAttributes = Field(description='精灵自定义种族值最大值')
+
+    def to_orm(self, pet_id: int) -> DiyStatsRangeORM:
+        """将DiyStats转换为DiyStatsRangeORM"""
+        return DiyStatsRangeORM(
+            id=pet_id,
+            atk_min=self.min.atk,
+            def_min=self.min.def_,
+            sp_atk_min=self.min.sp_atk,
+            sp_def_min=self.min.sp_def,
+            spd_min=self.min.spd,
+            hp_min=self.min.hp,
+            atk_max=self.max.atk,
+            def_max=self.max.def_,
+            sp_atk_max=self.max.sp_atk,
+            sp_def_max=self.max.sp_def,
+            spd_max=self.max.spd,
+            hp_max=self.max.hp,
+        )
+
+
+class SkillInPetBase(BaseResModel):
+    id: int = Field(
+        exclude=True,
+        primary_key=True,
+        foreign_key='skill.id',
+        sa_type=Integer,
+        sa_column_kwargs={
+            'name': 'skill_id',
+        },
+        schema_extra={
+            'serialization_alias': 'skill_id',
+        },
+    )
+    pet_id: int = Field(primary_key=True, foreign_key='pet.id', exclude=True)
+    learning_level: int | None = Field(
+        default=None,
+        description='技能的学习等级，当该技能无法通过升级获得时，该字段为null',
+    )
+    is_special: bool = Field(default=False, description='是否是特训技能')
+    is_advanced: bool = Field(default=False, description='是否是神谕觉醒技能')
+    is_fifth: bool = Field(default=False, description='是否是第五技能')
+
+    @classmethod
+    def resource_name(cls) -> str:
+        return 'skill_in_pet'
+
+
+class SkillInPet(SkillInPetBase, ConvertToORM['SkillInPetORM']):
+    skill: ResourceRef['Skill'] = Field(description='技能资源')
+    skill_activation_item: ResourceRef['SkillActivationItem'] | None = Field(
+        default=None, description='学习该技能需要的激活道具'
+    )
+
+    @classmethod
+    def get_orm_model(cls) -> type['SkillInPetORM']:
+        return SkillInPetORM
+
+    def to_orm(self) -> 'SkillInPetORM':
+        return SkillInPetORM(
+            id=self.id,
+            pet_id=self.pet_id,
+            learning_level=self.learning_level,
+            is_special=self.is_special,
+            is_advanced=self.is_advanced,
+            is_fifth=self.is_fifth,
+            skill_activation_item_id=(
+                self.skill_activation_item.id if self.skill_activation_item else None
+            ),
+        )
+
+
+class SkillInPetORM(SkillInPetBase, table=True):
+    skill: 'SkillORM' = Relationship(back_populates='pet_links')
+    pet: 'PetORM' = Relationship(back_populates='skill_links')
+    skill_activation_item_id: int | None = Field(
+        default=None,
+        foreign_key='skill_activation_item.id',
+    )
+    skill_activation_item: Optional['SkillActivationItemORM'] = Relationship(
+        back_populates='skill_in_pet',
+        sa_relationship_kwargs={
+            'primaryjoin': 'SkillInPetORM.skill_activation_item_id == SkillActivationItemORM.id',
+        },
+    )
+
+
+class PetBase(BaseResModel):
+    name: str = Field(description='精灵名称')
+    # 精灵基础信息
+    yielding_exp: int = Field(description='击败精灵可获得的经验值')
+    catch_rate: int = Field(description='精灵捕捉率')
+    evolving_lv: int | None = Field(
+        default=None, description='精灵进化等级，当精灵无法再通过等级进化时为null'
+    )
+    # 其他
+    releaseable: bool = Field(description='精灵是否可放生')
+    fusion_master: bool = Field(description='精灵是否可作为融合精灵的主宠')
+    fusion_sub: bool = Field(description='精灵是否可作为融合精灵的副宠')
+    has_resistance: bool = Field(description='精灵是否可获得抗性')
+
+    resource_id: int = Field(description='精灵资源ID')
+    enemy_resource_id: int | None = Field(
+        default=None,
+        description='该精灵在对手侧时使用的资源的ID，仅少数精灵存在这种资源',
+    )
+
+    @classmethod
+    def resource_name(cls) -> str:
+        return 'pet'
+
+
+class Pet(PetBase, ConvertToORM['PetORM']):
+    type: ResourceRef['TypeCombination'] = Field(description='精灵属性')
+    gender: ResourceRef['PetGenderCategory'] = Field(description='精灵性别')
+    base_stats: SixAttributes = Field(description='精灵种族值')
+    pet_class: ResourceRef['PetClass'] | None = Field(
+        default=None, description='精灵类别，同一进化链中的精灵属于同一类'
+    )
+    evolution_chain_index: int = Field(description='该精灵在进化链中的位置，从0开始')
+    yielding_ev: SixAttributes = Field(description='击败精灵可获得的学习力')
+    vipbuff: ResourceRef['PetVipBuffCategory'] | None = Field(
+        default=None, description='精灵VIP加成，仅在闪光/暗黑精灵上使用'
+    )
+    mount_type: ResourceRef['PetMountTypeCategory'] | None = Field(
+        default=None, description='精灵骑乘类型，仅在坐骑精灵上使用'
+    )
+    diy_stats: DiyStatsRange | None = Field(
+        default=None, description='精灵自定义种族值，仅在合体精灵王上使用'
+    )
+    skill: list['SkillInPet'] = Field(description='精灵可学习的技能')
+    soulmark: list[ResourceRef['Soulmark']] | None = Field(
+        default=None, description='精灵可持有的魂印'
+    )
+    # 其他数据
+    encyclopedia_entry: ResourceRef['PetEncyclopediaEntry'] | None = Field(
+        default=None, description='精灵图鉴条目'
+    )
+    archive_story_entry: ResourceRef['PetArchiveStoryEntry'] | None = Field(
+        default=None, description='精灵故事条目'
+    )
+
+    @classmethod
+    def get_orm_model(cls) -> 'type[PetORM]':
+        return PetORM
+
+    def to_orm(self) -> 'PetORM':
+        base_stats = BaseStatORM(
+            id=self.id,
+            **self.base_stats.model_dump(),
+        )
+        yielding_ev = YieldingEvORM(
+            id=self.id,
+            **self.yielding_ev.model_dump(),
+        )
+        diy_stats = self.diy_stats.to_orm(self.id) if self.diy_stats else None
+        skill_links = [skill.to_orm() for skill in self.skill]
+        return PetORM(
+            id=self.id,
+            name=self.name,
+            yielding_exp=self.yielding_exp,
+            catch_rate=self.catch_rate,
+            evolving_lv=self.evolving_lv,
+            releaseable=self.releaseable,
+            fusion_master=self.fusion_master,
+            fusion_sub=self.fusion_sub,
+            has_resistance=self.has_resistance,
+            type_id=self.type.id,
+            gender_id=self.gender.id,
+            pet_class_id=self.pet_class.id if self.pet_class else None,
+            base_stats_id=cast(int, base_stats.id),
+            base_stats=base_stats,
+            skill_links=skill_links,
+            yielding_ev_id=cast(int, yielding_ev.id),
+            yielding_ev=yielding_ev,
+            vipbuff_id=self.vipbuff.id if self.vipbuff else None,
+            mount_type_id=self.mount_type.id if self.mount_type else None,
+            diy_stats_id=diy_stats.id if diy_stats else None,
+            diy_stats=diy_stats,
+            resource_id=self.resource_id,
+            enemy_resource_id=self.enemy_resource_id,
+        )
+
+
+class PetORM(PetBase, table=True):
+    type_id: int = Field(foreign_key='element_type_combination.id')
+    type: 'TypeCombinationORM' = Relationship(
+        back_populates='pet',
+    )
+    gender_id: int = Field(foreign_key='pet_gender.id')
+    gender: 'PetGenderORM' = Relationship(
+        back_populates='pet',
+    )
+    pet_class_id: int | None = Field(default=None, foreign_key='pet_class.id')
+    pet_class: Optional['PetClassORM'] = Relationship(
+        back_populates='evolution_chain',
+    )
+    base_stats_id: int = Field(foreign_key='pet_base_stats.id')
+    base_stats: BaseStatORM = Relationship(
+        back_populates='pet',
+        sa_relationship_kwargs={
+            'primaryjoin': 'PetORM.id == BaseStatORM.id',
+        },
+    )
+    yielding_ev_id: int = Field(foreign_key='pet_yielding_ev.id')
+    yielding_ev: YieldingEvORM = Relationship(
+        back_populates='pet',
+        sa_relationship_kwargs={
+            'primaryjoin': 'PetORM.id == YieldingEvORM.id',
+        },
+    )
+    # 技能，魂印
+    skill_links: list['SkillInPetORM'] = Relationship(
+        back_populates='pet',
+    )
+    soulmark: list['SoulmarkORM'] = Relationship(
+        back_populates='pet',
+        sa_relationship_kwargs={
+            'secondary': 'petsoulmarklink',
+        },
+    )
+    # 杂项分类
+    vipbuff_id: int | None = Field(default=None, foreign_key='pet_vipbuff.id')
+    vipbuff: Optional['PetVipBuffORM'] = Relationship(
+        back_populates='pet',
+    )
+    mount_type_id: int | None = Field(default=None, foreign_key='pet_mount_type.id')
+    mount_type: Optional['PetMountTypeORM'] = Relationship(
+        back_populates='pet',
+    )
+    diy_stats_id: int | None = Field(default=None, foreign_key='pet_diy_stats_range.id')
+    diy_stats: Optional['DiyStatsRangeORM'] = Relationship(
+        back_populates='pet',
+        sa_relationship_kwargs={
+            'primaryjoin': 'PetORM.id == DiyStatsRangeORM.id',
+        },
+    )
+    exclusive_mintmark: list['MintmarkORM'] = Relationship(
+        back_populates='pet',
+        sa_relationship_kwargs={
+            'secondary': 'petmintmarklink',
+        },
+    )
+    exclusive_suit_bonus: list['SuitBonusORM'] = Relationship(
+        back_populates='effective_pets',
+        sa_relationship_kwargs={
+            'secondary': 'petsuitlink',
+        },
+    )
+    skins: list['PetSkinORM'] = Relationship(
+        back_populates='pet',
+        sa_relationship_kwargs={
+            'primaryjoin': 'PetORM.id == PetSkinORM.pet_id',
+        },
+    )
+    encyclopedia: Optional['PetEncyclopediaEntryORM'] = Relationship(
+        back_populates='pet',
+        sa_relationship_kwargs={
+            'primaryjoin': 'PetORM.id == PetEncyclopediaEntryORM.id',
+        },
+    )
+    archive_story: Optional['PetArchiveStoryEntryORM'] = Relationship(
+        back_populates='pet',
+        sa_relationship_kwargs={
+            'primaryjoin': 'PetORM.id == PetArchiveStoryEntryORM.pet_id',
+        },
+    )
+
+
+class PetClassBase(BaseResModel):
+    is_variant_pet: bool = Field(default=False, description='是否是异能精灵')
+    is_dark_pet: bool = Field(default=False, description='是否是暗黑精灵')
+    is_shine_pet: bool = Field(default=False, description='是否是闪光精灵')
+    is_rare_pet: bool = Field(default=False, description='是否是稀有精灵')
+    is_breeding_pet: bool = Field(default=False, description='是否是繁殖二代精灵')
+    is_fusion_pet: bool = Field(default=False, description='是否是融合二代精灵')
+
+    @classmethod
+    def resource_name(cls) -> str:
+        return 'pet_class'
+
+
+class PetClass(PetClassBase, ConvertToORM['PetClassORM']):
+    """描述一个精灵类别，所有第一形态为同一ID的精灵为一类"""
+
+    evolution_chain: list[ResourceRef['Pet']] = Field(
+        description='精灵进化链，从第一形态到最终形态的精灵列表'
+    )
+
+    @classmethod
+    def get_orm_model(cls) -> type['PetClassORM']:
+        return PetClassORM
+
+    def to_orm(self) -> 'PetClassORM':
+        return PetClassORM(
+            id=self.id,
+            is_variant_pet=self.is_variant_pet,
+            is_dark_pet=self.is_dark_pet,
+            is_shine_pet=self.is_shine_pet,
+            is_rare_pet=self.is_rare_pet,
+            is_breeding_pet=self.is_breeding_pet,
+            is_fusion_pet=self.is_fusion_pet,
+        )
+
+
+class PetClassORM(PetClassBase, table=True):
+    evolution_chain: list['PetORM'] = Relationship(back_populates='pet_class')
+
+
+class PetCategoryBase(BaseCategoryModel):
+    name: str = Field(description='名称')
+    description: str = Field(description='描述')
+
+
+class PetCategoryRefs(SQLModel):
+    pet: list[ResourceRef['Pet']] = Field(description='精灵列表')
+
+
+class PetGenderBase(PetCategoryBase):
+    @classmethod
+    def resource_name(cls) -> str:
+        return 'pet_gender'
+
+
+class PetGenderCategory(PetGenderBase, PetCategoryRefs, ConvertToORM['PetGenderORM']):
+    @classmethod
+    def get_orm_model(cls) -> type['PetGenderORM']:
+        return PetGenderORM
+
+    def to_orm(self) -> 'PetGenderORM':
+        return PetGenderORM(
+            id=self.id,
+            name=self.name,
+            description=self.description,
+        )
+
+
+class PetGenderORM(PetGenderBase, table=True):
+    pet: list['PetORM'] = Relationship(back_populates='gender')
+
+
+class PetVipBuffBase(PetCategoryBase):
+    @classmethod
+    def resource_name(cls) -> str:
+        return 'pet_vipbuff'
+
+
+class PetVipBuffCategory(
+    PetVipBuffBase, PetCategoryRefs, ConvertToORM['PetVipBuffORM']
+):
+    @classmethod
+    def get_orm_model(cls) -> type['PetVipBuffORM']:
+        return PetVipBuffORM
+
+    def to_orm(self) -> 'PetVipBuffORM':
+        return PetVipBuffORM(
+            id=self.id,
+            name=self.name,
+            description=self.description,
+        )
+
+
+class PetVipBuffORM(PetVipBuffBase, table=True):
+    pet: list['PetORM'] = Relationship(back_populates='vipbuff')
+
+
+class PetMountTypeBase(PetCategoryBase):
+    @classmethod
+    def resource_name(cls) -> str:
+        return 'pet_mount_type'
+
+
+class PetMountTypeCategory(
+    PetMountTypeBase, PetCategoryRefs, ConvertToORM['PetMountTypeORM']
+):
+    @classmethod
+    def get_orm_model(cls) -> type['PetMountTypeORM']:
+        return PetMountTypeORM
+
+    def to_orm(self) -> 'PetMountTypeORM':
+        return PetMountTypeORM(
+            id=self.id,
+            name=self.name,
+            description=self.description,
+        )
+
+
+class PetMountTypeORM(PetMountTypeBase, table=True):
+    pet: list['PetORM'] = Relationship(back_populates='mount_type')

seerapi_models/pet/pet_skin.py

@@ -0,0 +1,78 @@
+from typing import TYPE_CHECKING
+
+from sqlmodel import Field, Relationship
+
+from seerapi_models.build_model import BaseResModel, ConvertToORM
+from seerapi_models.common import ResourceRef
+
+if TYPE_CHECKING:
+    from . import Pet, PetORM
+
+
+class PetSkinBase(BaseResModel):
+    id: int = Field(
+        primary_key=True, description='皮肤ID，注意该字段不是头像/立绘等所使用的资源ID'
+    )
+    name: str = Field(description='皮肤名称')
+    resource_id: int = Field(description='皮肤资源ID')
+    enemy_resource_id: int | None = Field(
+        default=None,
+        description='该皮肤在对手侧时使用的资源的ID，仅少数皮肤存在这种资源',
+    )
+
+    @classmethod
+    def resource_name(cls) -> str:
+        return 'pet_skin'
+
+
+class PetSkin(PetSkinBase, ConvertToORM['PetSkinORM']):
+    pet: ResourceRef['Pet'] = Field(description='使用该皮肤的精灵')
+    category: ResourceRef['PetSkinCategory'] = Field(description='该皮肤所属的系列')
+
+    @classmethod
+    def get_orm_model(cls) -> type['PetSkinORM']:
+        return PetSkinORM
+
+    def to_orm(self) -> 'PetSkinORM':
+        return PetSkinORM(
+            id=self.id,
+            name=self.name,
+            resource_id=self.resource_id,
+            pet_id=self.pet.id,
+            category_id=self.category.id,
+        )
+
+
+class PetSkinORM(PetSkinBase, table=True):
+    pet_id: int = Field(foreign_key='pet.id')
+    pet: 'PetORM' = Relationship(back_populates='skins')
+    category_id: int = Field(foreign_key='pet_skin_category.id')
+    category: 'PetSkinCategoryORM' = Relationship(back_populates='skins')
+
+
+class PetSkinCategoryBase(BaseResModel):
+    id: int = Field(primary_key=True, description='系列ID')
+    # name: str = Field(
+    # 	description='系列名称'
+    # ) TODO: 该字段可能在数据中不存在，暂时忽略，等待游戏内数据或打补丁补充
+
+    @classmethod
+    def resource_name(cls) -> str:
+        return 'pet_skin_category'
+
+
+class PetSkinCategory(PetSkinCategoryBase, ConvertToORM['PetSkinCategoryORM']):
+    skins: list[ResourceRef['PetSkin']] = Field(
+        default_factory=list, description='该系列的皮肤列表'
+    )
+
+    @classmethod
+    def get_orm_model(cls) -> type['PetSkinCategoryORM']:
+        return PetSkinCategoryORM
+
+    def to_orm(self) -> 'PetSkinCategoryORM':
+        return PetSkinCategoryORM(id=self.id)
+
+
+class PetSkinCategoryORM(PetSkinCategoryBase, table=True):
+    skins: list['PetSkinORM'] = Relationship(back_populates='category')

seerapi_models/pet/petbook.py

@@ -0,0 +1,124 @@
+from typing import TYPE_CHECKING
+
+from sqlmodel import Field, Relationship
+
+from seerapi_models.build_model import (
+    BaseCategoryModel,
+    BaseResModel,
+    ConvertToORM,
+)
+from seerapi_models.common import ResourceRef
+
+if TYPE_CHECKING:
+    from .pet import Pet, PetORM
+
+
+class PetEncyclopediaEntryBase(BaseResModel):
+    id: int = Field(primary_key=True, description='精灵图鉴ID', foreign_key='pet.id')
+    name: str = Field(description='精灵名称')
+    has_sound: bool = Field(description='精灵是否存在叫声')
+    height: float | None = Field(
+        default=None,
+        description="精灵身高，当这个值在图鉴中为'未知'时，这个值为null",
+    )
+    weight: float | None = Field(
+        default=None,
+        description="精灵重量，当这个值在图鉴中为'未知'时，这个值为null",
+    )
+    foundin: str | None = Field(default=None, description='精灵发现地点')
+    food: str | None = Field(default=None, description='精灵喜爱的食物')
+    introduction: str = Field(description='精灵介绍')
+
+    @classmethod
+    def resource_name(cls) -> str:
+        return 'pet_encyclopedia_entry'
+
+
+class PetEncyclopediaEntry(
+    PetEncyclopediaEntryBase, ConvertToORM['PetEncyclopediaEntryORM']
+):
+    pet: ResourceRef['Pet'] = Field(description='精灵')
+
+    @classmethod
+    def get_orm_model(cls) -> type['PetEncyclopediaEntryORM']:
+        return PetEncyclopediaEntryORM
+
+    def to_orm(self) -> 'PetEncyclopediaEntryORM':
+        return PetEncyclopediaEntryORM(
+            id=self.id,
+            name=self.name,
+            has_sound=self.has_sound,
+            height=self.height,
+            weight=self.weight,
+            foundin=self.foundin,
+            food=self.food,
+            introduction=self.introduction,
+        )
+
+
+class PetEncyclopediaEntryORM(PetEncyclopediaEntryBase, table=True):
+    pet: 'PetORM' = Relationship(back_populates='encyclopedia')
+
+
+class PetArchiveStoryEntryBase(BaseResModel):
+    id: int = Field(primary_key=True, description='故事条目ID')
+    content: str = Field(description='故事条目内容')
+
+    @classmethod
+    def resource_name(cls) -> str:
+        return 'pet_archive_story_entry'
+
+
+class PetArchiveStoryEntry(
+    PetArchiveStoryEntryBase, ConvertToORM['PetArchiveStoryEntryORM']
+):
+    pet: ResourceRef['Pet'] = Field(description='精灵')
+    book: ResourceRef['PetArchiveStoryBook'] = Field(description='故事')
+
+    @classmethod
+    def get_orm_model(cls) -> type['PetArchiveStoryEntryORM']:
+        return PetArchiveStoryEntryORM
+
+    def to_orm(self) -> 'PetArchiveStoryEntryORM':
+        return PetArchiveStoryEntryORM(
+            id=self.id, content=self.content, pet_id=self.pet.id, book_id=self.book.id
+        )
+
+
+class PetArchiveStoryEntryORM(PetArchiveStoryEntryBase, table=True):
+    pet_id: int = Field(description='精灵ID', foreign_key='pet.id')
+    pet: 'PetORM' = Relationship(back_populates='archive_story')
+    book_id: int = Field(
+        foreign_key='pet_archive_story_book.id',
+    )
+    book: 'PetArchiveStoryBookORM' = Relationship(back_populates='entries')
+
+
+class PetArchiveStoryBookBase(BaseCategoryModel):
+    name: str = Field(description='故事名称')
+
+    @classmethod
+    def resource_name(cls) -> str:
+        return 'pet_archive_story_book'
+
+
+class PetArchiveStoryBook(
+    PetArchiveStoryBookBase, ConvertToORM['PetArchiveStoryBookORM']
+):
+    entries: list[ResourceRef[PetArchiveStoryEntryBase]] = Field(
+        default_factory=list, description='故事条目'
+    )
+
+    @classmethod
+    def get_orm_model(cls) -> type['PetArchiveStoryBookORM']:
+        return PetArchiveStoryBookORM
+
+    def to_orm(self) -> 'PetArchiveStoryBookORM':
+        return PetArchiveStoryBookORM(
+            id=self.id,
+            name=self.name,
+        )
+
+
+class PetArchiveStoryBookORM(PetArchiveStoryBookBase, table=True):
+    entries: list[PetArchiveStoryEntryORM] = Relationship(back_populates='book')