seerapi-models 1.0.0__py3-none-any.whl

seerapi_models/items/mintmark_gem.py

@@ -0,0 +1,267 @@
+from typing import Optional, cast
+
+from sqlmodel import Field, Relationship, SQLModel
+
+from seerapi_models.build_model import BaseCategoryModel, BaseResModel, ConvertToORM
+from seerapi_models.common import ResourceRef, SkillEffectInUse, SkillEffectInUseORM
+from seerapi_models.items import Item, ItemORM
+
+
+class GemEffectLink(SQLModel, table=True):
+    gem_id: int | None = Field(default=None, foreign_key='gem.id', primary_key=True)
+    skill_effect_in_use_id: int | None = Field(
+        default=None, foreign_key='skill_effect_in_use.id', primary_key=True
+    )
+
+
+class GemBase(BaseResModel):
+    id: int = Field(primary_key=True, foreign_key='item.id', description='宝石ID')
+    name: str = Field(description='宝石名称')
+    level: int = Field(description='宝石等级')
+    generation_id: int = Field(
+        description='宝石世代', foreign_key='gem_generation_category.id'
+    )
+
+    @classmethod
+    def resource_name(cls) -> str:
+        return 'gem'
+
+
+class GemResRefs(SQLModel):
+    next_level_gem: ResourceRef['Gem'] | None = Field(
+        default=None,
+        description='该宝石的下一等级的引用，当为None时表示该宝石为最高等级',
+    )
+    category: ResourceRef['GemCategory'] = Field(description='宝石类型引用')
+    effect: list[SkillEffectInUse] = Field(description='宝石效果')
+    item: ResourceRef['Item'] = Field(description='宝石物品资源引用')
+
+
+class Gem(GemBase, GemResRefs, ConvertToORM['GemORM']):
+    inlay_rate: float | None = Field(default=None, description='镶嵌成功率')
+    equivalent_level1_count: int | None = Field(
+        default=None, description='相当于多少个1级宝石'
+    )
+    fail_compensate_range: tuple[int, int] | None = Field(
+        default=None, description='当镶嵌失败时返还的宝石的等级范围，仅在1代宝石中有效'
+    )
+
+    upgrade_cost: int | None = Field(
+        default=None, description='升级到该等级需要的石之砂数量，仅在2代宝石中有效'
+    )
+
+    @classmethod
+    def get_orm_model(cls) -> type['GemORM']:
+        return GemORM
+
+    def to_orm(self) -> 'GemORM':
+        gen1_part = None
+        gen2_part = None
+        if self.generation_id == 1:
+            fail_compensate_range = cast(tuple[int, int], self.fail_compensate_range)
+            gen1_part = GemGen1PartORM(
+                id=self.id,
+                inlay_rate=cast(float, self.inlay_rate),
+                equivalent_level1_count=cast(int, self.equivalent_level1_count),
+                fail_compensate_level_start=fail_compensate_range[0],
+                fail_compensate_level_end=fail_compensate_range[1],
+            )
+        elif self.generation_id == 2:
+            gen2_part = GemGen2PartORM(
+                id=self.id,
+                upgrade_cost=cast(int, self.upgrade_cost),
+            )
+        return GemORM(
+            id=self.id,
+            name=self.name,
+            level=self.level,
+            generation_id=self.generation_id,
+            gen1_part=gen1_part,
+            gen2_part=gen2_part,
+            next_level_gem_id=self.next_level_gem.id if self.next_level_gem else None,
+            category_id=self.category.id,
+            skill_effect_in_use=[effect.to_orm() for effect in self.effect],
+        )
+
+    def to_detailed(self) -> 'GemGen1 | GemGen2':
+        general_args = {
+            'id': self.id,
+            'name': self.name,
+            'level': self.level,
+            'generation_id': self.generation_id,
+            'category': self.category,
+            'effect': self.effect,
+            'next_level_gem': self.next_level_gem,
+            'item': self.item,
+        }
+        if self.generation_id == 1:
+            return GemGen1(
+                **general_args,
+                inlay_rate=cast(float, self.inlay_rate),
+                equivalent_level1_count=cast(int, self.equivalent_level1_count),
+                fail_compensate_range=cast(tuple[int, int], self.fail_compensate_range),
+            )
+        else:
+            return GemGen2(
+                **general_args,
+                upgrade_cost=cast(int, self.upgrade_cost),
+            )
+
+
+class GemGen1(GemBase, GemResRefs):
+    inlay_rate: float = Field(description='镶嵌成功率')
+    equivalent_level1_count: int = Field(description='相当于多少个1级宝石')
+    fail_compensate_range: tuple[int, int] = Field(
+        description='当镶嵌失败时返还的宝石的等级范围'
+    )
+
+
+class GemGen2(GemBase, GemResRefs):
+    upgrade_cost: int = Field(description='升级到该等级需要的石之砂数量')
+
+
+class GemORM(GemBase, table=True):
+    next_level_gem_id: int | None = Field(
+        default=None,
+        description='该宝石的下一等级的引用，当为None时表示该宝石为最高等级',
+    )
+    category_id: int = Field(foreign_key='gem_category.id')
+    generation: 'GemGenCategoryORM' = Relationship(
+        back_populates='gem',
+    )
+    category: Optional['GemCategoryORM'] = Relationship(
+        back_populates='gem',
+        sa_relationship_kwargs={
+            'primaryjoin': 'GemORM.category_id == GemCategoryORM.id',
+        },
+    )
+    skill_effect_in_use_id: int | None = Field(
+        default=None, foreign_key='skill_effect_in_use.id'
+    )
+    skill_effect_in_use: list['SkillEffectInUseORM'] = Relationship(
+        back_populates='gem',
+        link_model=GemEffectLink,
+    )
+
+    gen1_part: Optional['GemGen1PartORM'] = Relationship(
+        back_populates='gem',
+        sa_relationship_kwargs={
+            'primaryjoin': 'GemORM.id == GemGen1PartORM.id',
+        },
+    )
+    gen2_part: Optional['GemGen2PartORM'] = Relationship(
+        back_populates='gem',
+        sa_relationship_kwargs={
+            'primaryjoin': 'GemORM.id == GemGen2PartORM.id',
+        },
+    )
+
+    item: 'ItemORM' = Relationship(back_populates='gem')
+
+
+class GemGen1PartORM(BaseResModel, table=True):
+    id: int = Field(primary_key=True, foreign_key='gem.id')
+    inlay_rate: float = Field(description='镶嵌成功率')
+    equivalent_level1_count: int = Field(description='相当于多少个1级宝石')
+
+    fail_compensate_level_start: int = Field(
+        description='当镶嵌失败时返还的宝石的等级范围'
+    )
+    fail_compensate_level_end: int = Field(
+        description='当镶嵌失败时返还的宝石的等级范围'
+    )
+
+    gem: 'GemORM' = Relationship(
+        back_populates='gen1_part',
+        sa_relationship_kwargs={
+            'primaryjoin': 'GemORM.id == GemGen1PartORM.id',
+        },
+    )
+
+    @classmethod
+    def resource_name(cls) -> str:
+        return 'gem_gen1_part'
+
+
+class GemGen2PartORM(BaseResModel, table=True):
+    id: int = Field(primary_key=True, foreign_key='gem.id')
+    upgrade_cost: int = Field(description='升级到该等级需要的石之砂数量')
+
+    gem: 'GemORM' = Relationship(
+        back_populates='gen2_part',
+        sa_relationship_kwargs={
+            'primaryjoin': 'GemORM.id == GemGen2PartORM.id',
+        },
+    )
+
+    @classmethod
+    def resource_name(cls) -> str:
+        return 'gem_gen2_part'
+
+
+class GemCategoryBase(BaseCategoryModel):
+    name: str = Field(description='名称')
+    generation_id: int = Field(
+        description='宝石世代', foreign_key='gem_generation_category.id'
+    )
+
+    @classmethod
+    def resource_name(cls) -> str:
+        return 'gem_category'
+
+
+class GemCategory(GemCategoryBase, ConvertToORM['GemCategoryORM']):
+    gem: list[ResourceRef] = Field(default_factory=list, description='宝石列表')
+
+    @classmethod
+    def get_orm_model(cls) -> type['GemCategoryORM']:
+        return GemCategoryORM
+
+    def to_orm(self) -> 'GemCategoryORM':
+        return GemCategoryORM(
+            id=self.id,
+            name=self.name,
+            generation_id=self.generation_id,
+        )
+
+
+class GemCategoryORM(GemCategoryBase, table=True):
+    gem: list['GemORM'] = Relationship(
+        back_populates='category',
+    )
+    generation: list['GemGenCategoryORM'] = Relationship(
+        back_populates='category',
+    )
+
+
+class GemGenCategoryBase(BaseCategoryModel):
+    @classmethod
+    def resource_name(cls) -> str:
+        return 'gem_generation_category'
+
+
+class GemGenCategory(GemGenCategoryBase, ConvertToORM['GemGenCategoryORM']):
+    gem_category: list[ResourceRef] = Field(
+        default_factory=list, description='宝石类别列表'
+    )
+
+    @classmethod
+    def get_orm_model(cls) -> type['GemGenCategoryORM']:
+        return GemGenCategoryORM
+
+    def to_orm(self) -> 'GemGenCategoryORM':
+        return GemGenCategoryORM(
+            id=self.id,
+        )
+
+
+class GemGenCategoryORM(GemGenCategoryBase, table=True):
+    gem: list['GemORM'] = Relationship(
+        back_populates='generation',
+        sa_relationship_kwargs={
+            'primaryjoin': 'GemORM.generation_id == GemGenCategoryORM.id',
+        },
+    )
+    category: 'GemCategoryORM' = Relationship(
+        back_populates='generation',
+    )

seerapi_models/items/skill_activation_item.py

@@ -0,0 +1,44 @@
+from sqlmodel import Field, Relationship
+
+from seerapi_models.build_model import BaseResModel, ConvertToORM
+from seerapi_models.common import ResourceRef
+from seerapi_models.pet import Pet, SkillInPetORM
+from seerapi_models.skill import Skill
+
+from ._common import Item, ItemORM
+
+
+class SkillActivationItemBase(BaseResModel):
+    id: int = Field(
+        primary_key=True, foreign_key='item.id', description='技能激活道具ID'
+    )
+    name: str = Field(description='技能激活道具名称')
+    item_number: int = Field(description='激活技能需要的该道具数量')
+
+    @classmethod
+    def resource_name(cls) -> str:
+        return 'skill_activation_item'
+
+
+class SkillActivationItem(
+    SkillActivationItemBase, ConvertToORM['SkillActivationItemORM']
+):
+    item: ResourceRef['Item'] = Field(description='道具资源引用')
+    skill: ResourceRef['Skill'] = Field(description='使用该道具激活的技能')
+    pet: ResourceRef['Pet'] = Field(description='使用该道具的精灵')
+
+    @classmethod
+    def get_orm_model(cls) -> type['SkillActivationItemORM']:
+        return SkillActivationItemORM
+
+    def to_orm(self) -> 'SkillActivationItemORM':
+        return SkillActivationItemORM(
+            id=self.id,
+            name=self.name,
+            item_number=self.item_number,
+        )
+
+
+class SkillActivationItemORM(SkillActivationItemBase, table=True):
+    item: 'ItemORM' = Relationship(back_populates='skill_activation_item')
+    skill_in_pet: 'SkillInPetORM' = Relationship(back_populates='skill_activation_item')

seerapi_models/items/skill_stone.py

@@ -0,0 +1,150 @@
+from typing import TYPE_CHECKING
+
+from sqlmodel import Field, Relationship, SQLModel
+
+from seerapi_models.build_model import (
+    BaseCategoryModel,
+    BaseResModel,
+    BaseResModelWithOptionalId,
+    ConvertToORM,
+)
+from seerapi_models.common import ResourceRef, SkillEffectInUse, SkillEffectInUseORM
+
+from ._common import Item, ItemORM
+
+if TYPE_CHECKING:
+    from ..element_type import TypeCombination, TypeCombinationORM
+
+
+class SkillStoneEffectLink(SQLModel, table=True):
+    """技能石效果链接表"""
+
+    skill_stone_effect_id: int | None = Field(
+        default=None, foreign_key='skill_stone_effect.id', primary_key=True
+    )
+    effect_in_use_id: int | None = Field(
+        default=None, foreign_key='skill_effect_in_use.id', primary_key=True
+    )
+
+
+class SkillStoneEffectBase(BaseResModelWithOptionalId):
+    prob: float = Field(description='技能石效果激活概率，0到1之间')
+    skill_stone_id: int = Field(
+        description='技能石ID', foreign_key='skill_stone.id', exclude=True
+    )
+
+    @classmethod
+    def resource_name(cls) -> str:
+        return 'skill_stone_effect'
+
+
+class SkillStoneEffect(SkillStoneEffectBase, ConvertToORM['SkillStoneEffectORM']):
+    effect: list['SkillEffectInUse'] = Field(description='技能石效果列表')
+
+    @classmethod
+    def get_orm_model(cls) -> type['SkillStoneEffectORM']:
+        return SkillStoneEffectORM
+
+    def to_orm(self) -> 'SkillStoneEffectORM':
+        return SkillStoneEffectORM(
+            id=self.id,
+            prob=self.prob,
+            skill_stone_id=self.skill_stone_id,
+            effect=[effect.to_orm() for effect in self.effect],
+        )
+
+
+class SkillStoneEffectORM(SkillStoneEffectBase, table=True):
+    effect: list['SkillEffectInUseORM'] = Relationship(
+        back_populates='skill_stone_effect',
+        link_model=SkillStoneEffectLink,
+    )
+    skill_stone: 'SkillStoneORM' = Relationship(back_populates='effect')
+
+
+class SkillStoneBase(BaseResModel):
+    id: int = Field(primary_key=True, foreign_key='item.id', description='技能石ID')
+    name: str = Field(description='技能石名称')
+    rank: int = Field(description='技能石等级，1到5分别对应D, C, B, A, S')
+    power: int = Field(description='技能石威力')
+    max_pp: int = Field(description='技能石最大PP')
+    accuracy: int = Field(description='技能石命中率')
+
+    @classmethod
+    def resource_name(cls) -> str:
+        return 'skill_stone'
+
+
+class SkillStone(SkillStoneBase, ConvertToORM['SkillStoneORM']):
+    category: ResourceRef['SkillStoneCategory'] = Field(description='技能石分类')
+    item: ResourceRef['Item'] = Field(description='技能石物品资源引用')
+    effect: list['SkillStoneEffect'] = Field(description='完美技能石效果列表')
+
+    @classmethod
+    def get_orm_model(cls) -> type['SkillStoneORM']:
+        return SkillStoneORM
+
+    def to_orm(self) -> 'SkillStoneORM':
+        return SkillStoneORM(
+            id=self.id,
+            name=self.name,
+            rank=self.rank,
+            power=self.power,
+            max_pp=self.max_pp,
+            accuracy=self.accuracy,
+            category_id=self.category.id,
+        )
+
+
+class SkillStoneORM(SkillStoneBase, table=True):
+    category_id: int = Field(
+        description='技能石分类ID', foreign_key='skill_stone_category.id'
+    )
+    category: 'SkillStoneCategoryORM' = Relationship(
+        back_populates='skill_stone',
+    )
+    item: 'ItemORM' = Relationship(
+        back_populates='skill_stone',
+    )
+    effect: list['SkillStoneEffectORM'] = Relationship(
+        back_populates='skill_stone',
+    )
+
+
+class SkillStoneCategoryBase(BaseCategoryModel):
+    name: str = Field(description='技能石分类名称')
+
+    @classmethod
+    def resource_name(cls) -> str:
+        return 'skill_stone_category'
+
+
+class SkillStoneCategory(SkillStoneCategoryBase, ConvertToORM['SkillStoneCategoryORM']):
+    skill_stone: list[ResourceRef['SkillStone']] = Field(
+        default_factory=list,
+        description='技能石列表',
+    )
+    type: ResourceRef['TypeCombination'] = Field(description='技能石类型')
+
+    @classmethod
+    def get_orm_model(cls) -> 'type[SkillStoneCategoryORM]':
+        return SkillStoneCategoryORM
+
+    def to_orm(self) -> 'SkillStoneCategoryORM':
+        return SkillStoneCategoryORM(
+            id=self.id,
+            name=self.name,
+            type_id=self.type.id,
+        )
+
+
+class SkillStoneCategoryORM(SkillStoneCategoryBase, table=True):
+    type_id: int = Field(
+        description='技能石类型ID', foreign_key='element_type_combination.id'
+    )
+    type: 'TypeCombinationORM' = Relationship(
+        back_populates='skill_stone_category',
+    )
+    skill_stone: list['SkillStoneORM'] = Relationship(
+        back_populates='category',
+    )

seerapi_models/metadata.py

@@ -0,0 +1,49 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+from sqlmodel import Field, SQLModel
+
+
+class ApiMetadata(BaseModel):
+    api_url: str = Field(description='当前API的URL')
+    api_version: str = Field(description='API版本')
+    generator_name: str = Field(description='生成器名称')
+    generator_version: str = Field(description='生成器版本')
+    generate_time: datetime = Field(
+        default_factory=datetime.now,
+        description='生成时间',
+    )
+    data_source: str = Field(
+        default='',
+        description='数据源，可填写git仓库地址或url',
+    )
+    data_version: str = Field(
+        default='',
+        description='数据版本',
+    )
+    patch_source: str = Field(
+        default='',
+        description='补丁源，可填写git仓库地址或url',
+    )
+    patch_version: str = Field(
+        default='',
+        description='补丁版本',
+    )
+
+    def to_orm(self) -> 'ApiMetadataORM':
+        return ApiMetadataORM(
+            api_url=self.api_url,
+            api_version=self.api_version,
+            generator_name=self.generator_name,
+            generator_version=self.generator_version,
+            generate_time=self.generate_time,
+            data_source=self.data_source,
+            data_version=self.data_version,
+            patch_source=self.patch_source,
+            patch_version=self.patch_version,
+        )
+
+
+class ApiMetadataORM(ApiMetadata, SQLModel, table=True):
+    __tablename__ = 'api_metadata'  # type: ignore
+    id: int | None = Field(default=None, description='ID', primary_key=True)