Genshin-bots/ArknightsUID
1
0
Fork 0
mirror of https://github.com/baiqwerdvd/ArknightsUID.git synced 2025-05-05 03:23:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

✨ make ruff happy and bug fix

Browse Source
This commit is contained in:
qwerdvd 2023-08-11 09:59:14 +08:00
parent a78f482d65
commit c93773334e
5 changed files with 266 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ArknightsUID/arknightsuid_resource/__init__.py
View File

@ -13,7 +13,7 @@ from .constants import Excel
sv_download_config = SV('下载资源', pm=2) sv_download_config = SV('下载资源', pm=2)
@sv_download_config.on_fullmatch(('下载全部资源')) @sv_download_config.on_fullmatch(('下载全部资源')) # noqa: UP034
async def send_download_resource_msg(bot: Bot, ev: Event): async def send_download_resource_msg(bot: Bot, ev: Event):
await bot.send('正在开始下载~可能需要较久的时间!') await bot.send('正在开始下载~可能需要较久的时间!')
im = await download_all_resource() im = await download_all_resource()
@ -25,7 +25,9 @@ async def startup():
await download_all_resource() await download_all_resource()
logger.info('[资源文件下载] 检查完毕, 正在加载 gamedata') logger.info('[资源文件下载] 检查完毕, 正在加载 gamedata')
for file_path in Path(get_res_path(['ArknightsUID', 'resource', 'gamedata'])).rglob('*.json'): for file_path in Path(
get_res_path(['ArknightsUID', 'resource', 'gamedata'])
).rglob('*.json'):
CacheData.readFile(file_path) CacheData.readFile(file_path)
Excel.preload_table() Excel.preload_table()

4
ArknightsUID/arknightsuid_resource/cachedata.py
View File

@ -33,7 +33,9 @@ class CacheData:
return cls.set_cache(local_path, data_name) return cls.set_cache(local_path, data_name)
@classmethod @classmethod
def set_cache(cls, local_path: Path | None, data_name: str, memory_data: dict | None = None) -> dict[Any, Any]: def set_cache(
cls, local_path: Path | None, data_name: str, memory_data: dict | None = None
) -> dict[Any, Any]:
data = read_json(local_path) if local_path else memory_data data = read_json(local_path) if local_path else memory_data
if data is None: if data is None:
raise FileNotFoundError raise FileNotFoundError

339
ArknightsUID/arknightsuid_resource/constants.py
View File

@ -103,42 +103,60 @@ class ExcelTableManager:
def ACTIVITY_TABLE(self) -> ActivityTable: def ACTIVITY_TABLE(self) -> ActivityTable:
if not self.activity_table_: if not self.activity_table_:
if hasattr(ActivityTable, 'model_validate'): if hasattr(ActivityTable, 'model_validate'):
self.activity_table_ = ActivityTable.model_validate(CacheData.readExcel('activity_table')) # type: ignore self.activity_table_ = ActivityTable.model_validate( # type: ignore
CacheData.readExcel('activity_table')
)
else: else:
self.activity_table_ = ActivityTable.parse_obj(CacheData.readExcel('activity_table')) self.activity_table_ = ActivityTable.parse_obj(
CacheData.readExcel('activity_table')
)
return self.activity_table_ return self.activity_table_
@property @property
def AUDIO_DATA(self) -> AudioData: def AUDIO_DATA(self) -> AudioData:
if not self.audio_data_: if not self.audio_data_:
if hasattr(AudioData, 'model_validate'): if hasattr(AudioData, 'model_validate'):
self.audio_data_ = AudioData.model_validate(CacheData.readExcel('audio_data')) # type: ignore self.audio_data_ = AudioData.model_validate( # type: ignore
CacheData.readExcel('audio_data')
)
else: else:
self.audio_data_ = AudioData.parse_obj(CacheData.readExcel('audio_data')) self.audio_data_ = AudioData.parse_obj(
CacheData.readExcel('audio_data')
)
return self.audio_data_ return self.audio_data_
@property @property
def BATTLE_EQUIP_TABLE(self) -> BattleEquipTable: def BATTLE_EQUIP_TABLE(self) -> BattleEquipTable:
if not self.battle_equip_table_: if not self.battle_equip_table_:
self.battle_equip_table_ = BattleEquipTable(CacheData.readExcel('battle_equip_table')) self.battle_equip_table_ = BattleEquipTable(
CacheData.readExcel('battle_equip_table')
)
return self.battle_equip_table_ return self.battle_equip_table_
@property @property
def BUILDING_DATA(self) -> BuildingData: def BUILDING_DATA(self) -> BuildingData:
if not self.building_data_: if not self.building_data_:
if hasattr(BuildingData, 'model_validate'): if hasattr(BuildingData, 'model_validate'):
self.building_data_ = BuildingData.model_validate(CacheData.readExcel('building_data')) # type: ignore self.building_data_ = BuildingData.model_validate( # type: ignore
CacheData.readExcel('building_data')
)
else: else:
self.building_data_ = BuildingData.parse_obj(CacheData.readExcel('building_data')) self.building_data_ = BuildingData.parse_obj(
CacheData.readExcel('building_data')
)
return self.building_data_ return self.building_data_
@property @property
def CAMPAIGN_TABLE(self) -> CampaignTable: def CAMPAIGN_TABLE(self) -> CampaignTable:
if not self.campaign_table_: if not self.campaign_table_:
if hasattr(CampaignTable, 'model_validate'): if hasattr(CampaignTable, 'model_validate'):
self.campaign_table_ = CampaignTable.model_validate(CacheData.readExcel('campaign_table')) # type: ignore self.campaign_table_ = CampaignTable.model_validate( # type: ignore
CacheData.readExcel('campaign_table')
)
else: else:
self.campaign_table_ = CampaignTable.parse_obj(CacheData.readExcel('campaign_table')) self.campaign_table_ = CampaignTable.parse_obj(
CacheData.readExcel('campaign_table')
)
return self.campaign_table_ return self.campaign_table_
@property @property
@ -151,261 +169,377 @@ class ExcelTableManager:
def CHARATER_TABLE(self) -> CharacterTable: def CHARATER_TABLE(self) -> CharacterTable:
if not self.character_table_: if not self.character_table_:
if hasattr(CharacterTable, 'model_validate'): if hasattr(CharacterTable, 'model_validate'):
self.character_table_ = CharacterTable.model_validate(CacheData.readExcel('character_table')) # type: ignore self.character_table_ = CharacterTable.model_validate( # type: ignore
CacheData.readExcel('character_table')
)
else: else:
self.character_table_ = CharacterTable(CacheData.readExcel('character_table')) self.character_table_ = CharacterTable(
CacheData.readExcel('character_table')
)
return self.character_table_ return self.character_table_
@property @property
def CHAR_META_TABLE(self) -> CharMetaTable: def CHAR_META_TABLE(self) -> CharMetaTable:
if not self.char_meta_table_: if not self.char_meta_table_:
if hasattr(CharMetaTable, 'model_validate'): if hasattr(CharMetaTable, 'model_validate'):
self.char_meta_table_ = CharMetaTable.model_validate(CacheData.readExcel('char_meta_table')) # type: ignore self.char_meta_table_ = CharMetaTable.model_validate( # type: ignore
CacheData.readExcel('char_meta_table')
)
else: else:
self.char_meta_table_ = CharMetaTable.parse_obj(CacheData.readExcel('char_meta_table')) self.char_meta_table_ = CharMetaTable.parse_obj(
CacheData.readExcel('char_meta_table')
)
return self.char_meta_table_ return self.char_meta_table_
@property @property
def CHARM_TABLE(self) -> CharmTable: def CHARM_TABLE(self) -> CharmTable:
if not self.charm_table_: if not self.charm_table_:
if hasattr(CharmTable, 'model_validate'): if hasattr(CharmTable, 'model_validate'):
self.charm_table_ = CharmTable.model_validate(CacheData.readExcel('charm_table')) # type: ignore self.charm_table_ = CharmTable.model_validate( # type: ignore
CacheData.readExcel('charm_table')
)
else: else:
self.charm_table_ = CharmTable.parse_obj(CacheData.readExcel('charm_table')) self.charm_table_ = CharmTable.parse_obj(
CacheData.readExcel('charm_table')
)
return self.charm_table_ return self.charm_table_
@property @property
def CHAR_PATH_TABLE(self) -> CharPatchTable: def CHAR_PATH_TABLE(self) -> CharPatchTable:
if not self.char_patch_table_: if not self.char_patch_table_:
if hasattr(CharPatchTable, 'model_validate'): if hasattr(CharPatchTable, 'model_validate'):
self.char_patch_table_ = CharPatchTable.model_validate(CacheData.readExcel('char_patch_table')) # type: ignore self.char_patch_table_ = CharPatchTable.model_validate( # type: ignore
CacheData.readExcel('char_patch_table')
)
else: else:
self.char_patch_table_ = CharPatchTable.parse_obj(CacheData.readExcel('char_patch_table')) self.char_patch_table_ = CharPatchTable.parse_obj(
CacheData.readExcel('char_patch_table')
)
return self.char_patch_table_ return self.char_patch_table_
@property @property
def CHARWORD_TABLE(self) -> CharwordTable: def CHARWORD_TABLE(self) -> CharwordTable:
if not self.charword_table_: if not self.charword_table_:
if hasattr(CharwordTable, 'model_validate'): if hasattr(CharwordTable, 'model_validate'):
self.charword_table_ = CharwordTable.model_validate(CacheData.readExcel('charword_table')) # type: ignore self.charword_table_ = CharwordTable.model_validate( # type: ignore
CacheData.readExcel('charword_table')
)
else: else:
self.charword_table_ = CharwordTable.parse_obj(CacheData.readExcel('charword_table')) self.charword_table_ = CharwordTable.parse_obj(
CacheData.readExcel('charword_table')
)
return self.charword_table_ return self.charword_table_
@property @property
def CHECKIN_TABLE(self) -> CheckinTable: def CHECKIN_TABLE(self) -> CheckinTable:
if not self.checkin_table_: if not self.checkin_table_:
if hasattr(CheckinTable, 'model_validate'): if hasattr(CheckinTable, 'model_validate'):
self.checkin_table_ = CheckinTable.model_validate(CacheData.readExcel('checkin_table')) # type: ignore self.checkin_table_ = CheckinTable.model_validate( # type: ignore
CacheData.readExcel('checkin_table')
)
else: else:
self.checkin_table_ = CheckinTable.parse_obj(CacheData.readExcel('checkin_table')) self.checkin_table_ = CheckinTable.parse_obj(
CacheData.readExcel('checkin_table')
)
return self.checkin_table_ return self.checkin_table_
@property @property
def CLIMB_TOWER_TABLE(self) -> ClimbTowerTable: def CLIMB_TOWER_TABLE(self) -> ClimbTowerTable:
if not self.climb_tower_table_: if not self.climb_tower_table_:
if hasattr(ClimbTowerTable, 'model_validate'): if hasattr(ClimbTowerTable, 'model_validate'):
self.climb_tower_table_ = ClimbTowerTable.model_validate(CacheData.readExcel('climb_tower_table')) # type: ignore self.climb_tower_table_ = ClimbTowerTable.model_validate( # type: ignore
CacheData.readExcel('climb_tower_table')
)
else: else:
self.climb_tower_table_ = ClimbTowerTable.parse_obj(CacheData.readExcel('climb_tower_table')) self.climb_tower_table_ = ClimbTowerTable.parse_obj(
CacheData.readExcel('climb_tower_table')
)
return self.climb_tower_table_ return self.climb_tower_table_
@property @property
def CLUE_DATA(self) -> ClueData: def CLUE_DATA(self) -> ClueData:
if not self.clue_data_: if not self.clue_data_:
if hasattr(ClueData, 'model_validate'): if hasattr(ClueData, 'model_validate'):
self.clue_data_ = ClueData.model_validate(CacheData.readExcel('clue_data')) # type: ignore self.clue_data_ = ClueData.model_validate( # type: ignore
CacheData.readExcel('clue_data')
)
else: else:
self.clue_data_ = ClueData.parse_obj(CacheData.readExcel('clue_data')) self.clue_data_ = ClueData.parse_obj(
CacheData.readExcel('clue_data')
)
return self.clue_data_ return self.clue_data_
@property @property
def CRISIS_TABLE(self) -> CrisisTable: def CRISIS_TABLE(self) -> CrisisTable:
if not self.crisis_table_: if not self.crisis_table_:
if hasattr(CrisisTable, 'model_validate'): if hasattr(CrisisTable, 'model_validate'):
self.crisis_table_ = CrisisTable.model_validate(CacheData.readExcel('crisis_table')) # type: ignore self.crisis_table_ = CrisisTable.model_validate( # type: ignore
CacheData.readExcel('crisis_table')
)
else: else:
self.crisis_table_ = CrisisTable.parse_obj(CacheData.readExcel('crisis_table')) self.crisis_table_ = CrisisTable.parse_obj(
CacheData.readExcel('crisis_table')
)
return self.crisis_table_ return self.crisis_table_
@property @property
def DISPLAY_META_TABLE(self) -> DisplayMetaTable: def DISPLAY_META_TABLE(self) -> DisplayMetaTable:
if not self.display_meta_table_: if not self.display_meta_table_:
if hasattr(DisplayMetaTable, 'model_validate'): if hasattr(DisplayMetaTable, 'model_validate'):
self.display_meta_table_ = DisplayMetaTable.model_validate(CacheData.readExcel('display_meta_table')) # type: ignore self.display_meta_table_ = DisplayMetaTable.model_validate( # type: ignore
CacheData.readExcel('display_meta_table')
)
else: else:
self.display_meta_table_ = DisplayMetaTable.parse_obj(CacheData.readExcel('display_meta_table')) self.display_meta_table_ = DisplayMetaTable.parse_obj(
CacheData.readExcel('display_meta_table')
)
return self.display_meta_table_ return self.display_meta_table_
@property @property
def ENEMY_HANDBOOK_TABLE(self) -> EnemyHandbookTable: def ENEMY_HANDBOOK_TABLE(self) -> EnemyHandbookTable:
if not self.enemy_handbook_table_: if not self.enemy_handbook_table_:
if hasattr(EnemyHandbookTable, 'model_validate'): if hasattr(EnemyHandbookTable, 'model_validate'):
self.enemy_handbook_table_ = EnemyHandbookTable.model_validate(CacheData.readExcel('enemy_handbook_table')) # type: ignore self.enemy_handbook_table_ = EnemyHandbookTable.model_validate( # type: ignore
CacheData.readExcel('enemy_handbook_table')
)
else: else:
self.enemy_handbook_table_ = EnemyHandbookTable.parse_obj(CacheData.readExcel('enemy_handbook_table')) self.enemy_handbook_table_ = EnemyHandbookTable.parse_obj(
CacheData.readExcel('enemy_handbook_table')
)
return self.enemy_handbook_table_ return self.enemy_handbook_table_
@property @property
def FAVOR_TABLE(self) -> FavorTable: def FAVOR_TABLE(self) -> FavorTable:
if not self.favor_table_: if not self.favor_table_:
if hasattr(FavorTable, 'model_validate'): if hasattr(FavorTable, 'model_validate'):
self.favor_table_ = FavorTable.model_validate(CacheData.readExcel('favor_table')) # type: ignore self.favor_table_ = FavorTable.model_validate( # type: ignore
CacheData.readExcel('favor_table')
)
else: else:
self.favor_table_ = FavorTable.parse_obj(CacheData.readExcel('favor_table')) self.favor_table_ = FavorTable.parse_obj(
CacheData.readExcel('favor_table')
)
return self.favor_table_ return self.favor_table_
@property @property
def GACHA_TABLE(self) -> GachaTable: def GACHA_TABLE(self) -> GachaTable:
if not self.gacha_table_: if not self.gacha_table_:
if hasattr(GachaTable, 'model_validate'): if hasattr(GachaTable, 'model_validate'):
self.gacha_table_ = GachaTable.model_validate(CacheData.readExcel('gacha_table')) # type: ignore self.gacha_table_ = GachaTable.model_validate( # type: ignore
CacheData.readExcel('gacha_table')
)
else: else:
self.gacha_table_ = GachaTable.parse_obj(CacheData.readExcel('gacha_table')) self.gacha_table_ = GachaTable.parse_obj(
CacheData.readExcel('gacha_table')
)
return self.gacha_table_ return self.gacha_table_
@property @property
def GAMEDATA_CONST(self) -> GamedataConst: def GAMEDATA_CONST(self) -> GamedataConst:
if not self.gamedata_const_: if not self.gamedata_const_:
if hasattr(GamedataConst, 'model_validate'): if hasattr(GamedataConst, 'model_validate'):
self.gamedata_const_ = GamedataConst.model_validate(CacheData.readExcel('gamedata_const')) # type: ignore self.gamedata_const_ = GamedataConst.model_validate( # type: ignore
CacheData.readExcel('gamedata_const')
)
else: else:
self.gamedata_const_ = GamedataConst.parse_obj(CacheData.readExcel('gamedata_const')) self.gamedata_const_ = GamedataConst.parse_obj(
CacheData.readExcel('gamedata_const')
)
return self.gamedata_const_ return self.gamedata_const_
@property @property
def HANDBOOK_INFO_TABLE(self) -> HandbookInfoTable: def HANDBOOK_INFO_TABLE(self) -> HandbookInfoTable:
if not self.handbook_info_table_: if not self.handbook_info_table_:
if hasattr(HandbookInfoTable, 'model_validate'): if hasattr(HandbookInfoTable, 'model_validate'):
self.handbook_info_table_ = HandbookInfoTable.model_validate(CacheData.readExcel('handbook_info_table')) # type: ignore self.handbook_info_table_ = HandbookInfoTable.model_validate( # type: ignore
CacheData.readExcel('handbook_info_table')
)
else: else:
self.handbook_info_table_ = HandbookInfoTable.parse_obj(CacheData.readExcel('handbook_info_table')) self.handbook_info_table_ = HandbookInfoTable.parse_obj(
CacheData.readExcel('handbook_info_table')
)
return self.handbook_info_table_ return self.handbook_info_table_
@property @property
def HANDBOOK_TABLE(self) -> HandbookTable: def HANDBOOK_TABLE(self) -> HandbookTable:
if not self.handbook_table_: if not self.handbook_table_:
if hasattr(HandbookTable, 'model_validate'): if hasattr(HandbookTable, 'model_validate'):
self.handbook_table_ = HandbookTable.model_validate(CacheData.readExcel('handbook_table')) # type: ignore self.handbook_table_ = HandbookTable.model_validate( # type: ignore
CacheData.readExcel('handbook_table')
)
else: else:
self.handbook_table_ = HandbookTable.parse_obj(CacheData.readExcel('handbook_table')) self.handbook_table_ = HandbookTable.parse_obj(
CacheData.readExcel('handbook_table')
)
return self.handbook_table_ return self.handbook_table_
@property @property
def HANDBOOK_TEAM_TABLE(self) -> HandbookTeamTable: def HANDBOOK_TEAM_TABLE(self) -> HandbookTeamTable:
if not self.handbook_team_table_: if not self.handbook_team_table_:
if hasattr(HandbookTeamTable, 'model_validate'): if hasattr(HandbookTeamTable, 'model_validate'):
self.handbook_team_table_ = HandbookTeamTable.model_validate(CacheData.readExcel('handbook_team_table')) # type: ignore self.handbook_team_table_ = HandbookTeamTable.model_validate( # type: ignore
CacheData.readExcel('handbook_team_table')
)
else: else:
self.handbook_team_table_ = HandbookTeamTable.parse_obj(CacheData.readExcel('handbook_team_table')) self.handbook_team_table_ = HandbookTeamTable.parse_obj(
CacheData.readExcel('handbook_team_table')
)
return self.handbook_team_table_ return self.handbook_team_table_
@property @property
def ITEM_TABLE(self) -> ItemTable: def ITEM_TABLE(self) -> ItemTable:
if not self.item_table_: if not self.item_table_:
if hasattr(ItemTable, 'model_validate'): if hasattr(ItemTable, 'model_validate'):
self.item_table_ = ItemTable.model_validate(CacheData.readExcel('item_table')) # type: ignore self.item_table_ = ItemTable.model_validate( # type: ignore
CacheData.readExcel('item_table')
)
else: else:
self.item_table_ = ItemTable.parse_obj(CacheData.readExcel('item_table')) self.item_table_ = ItemTable.parse_obj(
CacheData.readExcel('item_table')
)
return self.item_table_ return self.item_table_
@property @property
def MEDAL_TABLE(self) -> MedalTable: def MEDAL_TABLE(self) -> MedalTable:
if not self.medal_table_: if not self.medal_table_:
if hasattr(MedalTable, 'model_validate'): if hasattr(MedalTable, 'model_validate'):
self.medal_table_ = MedalTable.model_validate(CacheData.readExcel('medal_table')) # type: ignore self.medal_table_ = MedalTable.model_validate( # type: ignore
CacheData.readExcel('medal_table')
)
else: else:
self.medal_table_ = MedalTable.parse_obj(CacheData.readExcel('medal_table')) self.medal_table_ = MedalTable.parse_obj(
CacheData.readExcel('medal_table')
)
return self.medal_table_ return self.medal_table_
@property @property
def MISSION_TABLE(self) -> MissionTable: def MISSION_TABLE(self) -> MissionTable:
if not self.mission_table_: if not self.mission_table_:
if hasattr(MissionTable, 'model_validate'): if hasattr(MissionTable, 'model_validate'):
self.mission_table_ = MissionTable.model_validate(CacheData.readExcel('mission_table')) # type: ignore self.mission_table_ = MissionTable.model_validate( # type: ignore
CacheData.readExcel('mission_table')
)
else: else:
self.mission_table_ = MissionTable.parse_obj(CacheData.readExcel('mission_table')) self.mission_table_ = MissionTable.parse_obj(
CacheData.readExcel('mission_table')
)
return self.mission_table_ return self.mission_table_
@property @property
def OPEN_SERVER_TABLE(self) -> OpenServerTable: def OPEN_SERVER_TABLE(self) -> OpenServerTable:
if not self.open_server_table_: if not self.open_server_table_:
if hasattr(OpenServerTable, 'model_validate'): if hasattr(OpenServerTable, 'model_validate'):
self.open_server_table_ = OpenServerTable.model_validate(CacheData.readExcel('open_server_table')) # type: ignore self.open_server_table_ = OpenServerTable.model_validate( # type: ignore
CacheData.readExcel('open_server_table')
)
else: else:
self.open_server_table_ = OpenServerTable.parse_obj(CacheData.readExcel('open_server_table')) self.open_server_table_ = OpenServerTable.parse_obj(
CacheData.readExcel('open_server_table')
)
return self.open_server_table_ return self.open_server_table_
@property @property
def PLAYER_AVATAR_TABLE(self) -> PlayerAvatarTable: def PLAYER_AVATAR_TABLE(self) -> PlayerAvatarTable:
if not self.player_avatar_table_: if not self.player_avatar_table_:
if hasattr(PlayerAvatarTable, 'model_validate'): if hasattr(PlayerAvatarTable, 'model_validate'):
self.player_avatar_table_ = PlayerAvatarTable.model_validate(CacheData.readExcel('player_avatar_table')) # type: ignore self.player_avatar_table_ = PlayerAvatarTable.model_validate( # type: ignore
CacheData.readExcel('player_avatar_table')
)
else: else:
self.player_avatar_table_ = PlayerAvatarTable.parse_obj(CacheData.readExcel('player_avatar_table')) self.player_avatar_table_ = PlayerAvatarTable.parse_obj(
CacheData.readExcel('player_avatar_table')
)
return self.player_avatar_table_ return self.player_avatar_table_
@property @property
def RANGE_TABLE(self) -> RangeTable: def RANGE_TABLE(self) -> RangeTable:
if not self.range_table_: if not self.range_table_:
if hasattr(RangeTable, 'model_validate'): if hasattr(RangeTable, 'model_validate'):
self.range_table_ = RangeTable.model_validate(CacheData.readExcel('range_table')) # type: ignore self.range_table_ = RangeTable.model_validate( # type: ignore
CacheData.readExcel('range_table')
)
else: else:
self.range_table_ = RangeTable.parse_obj(CacheData.readExcel('range_table')) self.range_table_ = RangeTable.parse_obj(
CacheData.readExcel('range_table')
)
return self.range_table_ return self.range_table_
@property @property
def REPLICATE_TABLE(self) -> ReplicateTable: def REPLICATE_TABLE(self) -> ReplicateTable:
if not self.replicate_table_: if not self.replicate_table_:
if hasattr(ReplicateTable, 'model_validate'): if hasattr(ReplicateTable, 'model_validate'):
self.replicate_table_ = ReplicateTable.model_validate(CacheData.readExcel('replicate_table')) # type: ignore self.replicate_table_ = ReplicateTable.model_validate( # type: ignore
CacheData.readExcel('replicate_table')
)
else: else:
self.replicate_table_ = ReplicateTable.parse_obj(CacheData.readExcel('replicate_table')) self.replicate_table_ = ReplicateTable.parse_obj(
CacheData.readExcel('replicate_table')
)
return self.replicate_table_ return self.replicate_table_
@property @property
def RETRO_TABLE(self) -> RetroTable: def RETRO_TABLE(self) -> RetroTable:
if not self.retro_table_: if not self.retro_table_:
if hasattr(RetroTable, 'model_validate'): if hasattr(RetroTable, 'model_validate'):
self.retro_table_ = RetroTable.model_validate(CacheData.readExcel('retro_table')) # type: ignore self.retro_table_ = RetroTable.model_validate( # type: ignore
CacheData.readExcel('retro_table')
)
else: else:
self.retro_table_ = RetroTable.parse_obj(CacheData.readExcel('retro_table')) self.retro_table_ = RetroTable.parse_obj(
CacheData.readExcel('retro_table')
)
return self.retro_table_ return self.retro_table_
@property @property
def ROGUELIKE_TABLE(self) -> RoguelikeTable: def ROGUELIKE_TABLE(self) -> RoguelikeTable:
if not self.roguelike_table_: if not self.roguelike_table_:
if hasattr(RoguelikeTable, 'model_validate'): if hasattr(RoguelikeTable, 'model_validate'):
self.roguelike_table_ = RoguelikeTable.model_validate(CacheData.readExcel('roguelike_table')) # type: ignore self.roguelike_table_ = RoguelikeTable.model_validate( # type: ignore
CacheData.readExcel('roguelike_table')
)
else: else:
self.roguelike_table_ = RoguelikeTable.parse_obj(CacheData.readExcel('roguelike_table')) self.roguelike_table_ = RoguelikeTable.parse_obj(
CacheData.readExcel('roguelike_table')
)
return self.roguelike_table_ return self.roguelike_table_
@property @property
def ROGUELIKE_TOPIC_TABLE(self) -> RoguelikeTopicTable: def ROGUELIKE_TOPIC_TABLE(self) -> RoguelikeTopicTable:
if not self.roguelike_topic_table_: if not self.roguelike_topic_table_:
if hasattr(RoguelikeTopicTable, 'model_validate'): if hasattr(RoguelikeTopicTable, 'model_validate'):
self.roguelike_topic_table_ = RoguelikeTopicTable.model_validate(CacheData.readExcel('roguelike_topic_table')) # type: ignore self.roguelike_topic_table_ = RoguelikeTopicTable.model_validate( # type: ignore
CacheData.readExcel('roguelike_topic_table')
)
else: else:
self.roguelike_topic_table_ = RoguelikeTopicTable.parse_obj(CacheData.readExcel('roguelike_topic_table')) self.roguelike_topic_table_ = RoguelikeTopicTable.parse_obj(
CacheData.readExcel('roguelike_topic_table')
)
return self.roguelike_topic_table_ return self.roguelike_topic_table_
@property @property
def SANDBOX_TABLE(self) -> SandboxTable: def SANDBOX_TABLE(self) -> SandboxTable:
if not self.sandbox_table_: if not self.sandbox_table_:
if hasattr(SandboxTable, 'model_validate'): if hasattr(SandboxTable, 'model_validate'):
self.sandbox_table_ = SandboxTable.model_validate(CacheData.readExcel('sandbox_table')) # type: ignore self.sandbox_table_ = SandboxTable.model_validate( # type: ignore
CacheData.readExcel('sandbox_table')
)
else: else:
self.sandbox_table_ = SandboxTable.parse_obj(CacheData.readExcel('sandbox_table')) self.sandbox_table_ = SandboxTable.parse_obj(
CacheData.readExcel('sandbox_table')
)
return self.sandbox_table_ return self.sandbox_table_
@property @property
def SHOP_CLIENT_TABLE(self) -> ShopClientTable: def SHOP_CLIENT_TABLE(self) -> ShopClientTable:
if not self.shop_client_table_: if not self.shop_client_table_:
if hasattr(ShopClientTable, 'model_validate'): if hasattr(ShopClientTable, 'model_validate'):
self.shop_client_table_ = ShopClientTable.model_validate(CacheData.readExcel('shop_client_table')) # type: ignore self.shop_client_table_ = ShopClientTable.model_validate( # type: ignore
CacheData.readExcel('shop_client_table')
)
else: else:
self.shop_client_table_ = ShopClientTable.parse_obj(CacheData.readExcel('shop_client_table')) self.shop_client_table_ = ShopClientTable.parse_obj(
CacheData.readExcel('shop_client_table')
)
return self.shop_client_table_ return self.shop_client_table_
@property @property
@ -418,33 +552,47 @@ class ExcelTableManager:
def SKIN_TABLE(self) -> SkinTable: def SKIN_TABLE(self) -> SkinTable:
if not self.skin_table_: if not self.skin_table_:
if hasattr(SkinTable, 'model_validate'): if hasattr(SkinTable, 'model_validate'):
self.skin_table_ = SkinTable.model_validate(CacheData.readExcel('skin_table')) # type: ignore self.skin_table_ = SkinTable.model_validate( # type: ignore
CacheData.readExcel('skin_table')
)
else: else:
self.skin_table_ = SkinTable.parse_obj(CacheData.readExcel('skin_table')) self.skin_table_ = SkinTable.parse_obj(
CacheData.readExcel('skin_table')
)
return self.skin_table_ return self.skin_table_
@property @property
def STAGE_TABLE(self) -> StageTable: def STAGE_TABLE(self) -> StageTable:
if not self.stage_table_: if not self.stage_table_:
if hasattr(StageTable, 'model_validate'): if hasattr(StageTable, 'model_validate'):
self.stage_table_ = StageTable.model_validate(CacheData.readExcel('stage_table')) # type: ignore self.stage_table_ = StageTable.model_validate( # type: ignore
CacheData.readExcel('stage_table')
)
else: else:
self.stage_table_ = StageTable.parse_obj(CacheData.readExcel('stage_table')) self.stage_table_ = StageTable.parse_obj(
CacheData.readExcel('stage_table')
)
return self.stage_table_ return self.stage_table_
@property @property
def STORY_REVIEW_META_TABLE(self) -> StoryReviewMetaTable: def STORY_REVIEW_META_TABLE(self) -> StoryReviewMetaTable:
if not self.story_review_meta_table_: if not self.story_review_meta_table_:
if hasattr(StoryReviewMetaTable, 'model_validate'): if hasattr(StoryReviewMetaTable, 'model_validate'):
self.story_review_meta_table_ = StoryReviewMetaTable.model_validate(CacheData.readExcel('story_review_meta_table')) # type: ignore self.story_review_meta_table_ = StoryReviewMetaTable.model_validate( # type: ignore
CacheData.readExcel('story_review_meta_table')
)
else: else:
self.story_review_meta_table_ = StoryReviewMetaTable.parse_obj(CacheData.readExcel('story_review_meta_table')) self.story_review_meta_table_ = StoryReviewMetaTable.parse_obj(
CacheData.readExcel('story_review_meta_table')
)
return self.story_review_meta_table_ return self.story_review_meta_table_
@property @property
def STORY_REVIEW_TABLE(self) -> StoryReviewTable: def STORY_REVIEW_TABLE(self) -> StoryReviewTable:
if not self.story_review_table_: if not self.story_review_table_:
self.story_review_table_ = StoryReviewTable(CacheData.readExcel('story_review_table')) self.story_review_table_ = StoryReviewTable(
CacheData.readExcel('story_review_table')
)
return self.story_review_table_ return self.story_review_table_
@property @property
@ -457,18 +605,26 @@ class ExcelTableManager:
def TECH_BUFF_TABLE(self) -> TechBuffTable: def TECH_BUFF_TABLE(self) -> TechBuffTable:
if not self.tech_buff_table_: if not self.tech_buff_table_:
if hasattr(TechBuffTable, 'model_validate'): if hasattr(TechBuffTable, 'model_validate'):
self.tech_buff_table_ = TechBuffTable.model_validate(CacheData.readExcel('tech_buff_table')) # type: ignore self.tech_buff_table_ = TechBuffTable.model_validate( # type: ignore
CacheData.readExcel('tech_buff_table')
)
else: else:
self.tech_buff_table_ = TechBuffTable.parse_obj(CacheData.readExcel('tech_buff_table')) self.tech_buff_table_ = TechBuffTable.parse_obj(
CacheData.readExcel('tech_buff_table')
)
return self.tech_buff_table_ return self.tech_buff_table_
@property @property
def TIP_TABLE(self) -> TipTable: def TIP_TABLE(self) -> TipTable:
if not self.tip_table_: if not self.tip_table_:
if hasattr(TipTable, 'model_validate'): if hasattr(TipTable, 'model_validate'):
self.tip_table_ = TipTable.model_validate(CacheData.readExcel('tip_table')) # type: ignore self.tip_table_ = TipTable.model_validate( # type: ignore
CacheData.readExcel('tip_table')
)
else: else:
self.tip_table_ = TipTable.parse_obj(CacheData.readExcel('tip_table')) self.tip_table_ = TipTable.parse_obj(
CacheData.readExcel('tip_table')
)
return self.tip_table_ return self.tip_table_
@property @property
@ -481,32 +637,45 @@ class ExcelTableManager:
def UNIEQUIP_DATA(self) -> UniequipData: def UNIEQUIP_DATA(self) -> UniequipData:
if not self.uniequip_data_: if not self.uniequip_data_:
if hasattr(UniequipData, 'model_validate'): if hasattr(UniequipData, 'model_validate'):
self.uniequip_data_ = UniequipData.model_validate(CacheData.readExcel('uniequip_data')) # type: ignore self.uniequip_data_ = UniequipData.model_validate( # type: ignore
CacheData.readExcel('uniequip_data')
)
else: else:
self.uniequip_data_ = UniequipData.parse_obj(CacheData.readExcel('uniequip_data')) self.uniequip_data_ = UniequipData.parse_obj(
CacheData.readExcel('uniequip_data')
)
return self.uniequip_data_ return self.uniequip_data_
@property @property
def UNIEQUIP_TABLE(self) -> UniEquipTable: def UNIEQUIP_TABLE(self) -> UniEquipTable:
if not self.uniequip_table_: if not self.uniequip_table_:
if hasattr(UniEquipTable, 'model_validate'): if hasattr(UniEquipTable, 'model_validate'):
self.uniequip_table_ = UniEquipTable.model_validate(CacheData.readExcel('uniequip_table')) # type: ignore self.uniequip_table_ = UniEquipTable.model_validate( # type: ignore
CacheData.readExcel('uniequip_table')
)
else: else:
self.uniequip_table_ = UniEquipTable.parse_obj(CacheData.readExcel('uniequip_table')) self.uniequip_table_ = UniEquipTable.parse_obj(
CacheData.readExcel('uniequip_table')
)
return self.uniequip_table_ return self.uniequip_table_
@property @property
def ZONE_TABLE(self) -> ZoneTable: def ZONE_TABLE(self) -> ZoneTable:
if not self.zone_table_: if not self.zone_table_:
if hasattr(ZoneTable, 'model_validate'): if hasattr(ZoneTable, 'model_validate'):
self.zone_table_ = ZoneTable.model_validate(CacheData.readExcel('zone_table')) # type: ignore self.zone_table_ = ZoneTable.model_validate( # type: ignore
CacheData.readExcel('zone_table')
)
else: else:
self.zone_table_ = ZoneTable.parse_obj(CacheData.readExcel('zone_table')) self.zone_table_ = ZoneTable.parse_obj(
CacheData.readExcel('zone_table')
)
return self.zone_table_ return self.zone_table_
def preload_table(self) -> None: def preload_table(self) -> None:
for name, method in inspect.getmembers(self, predicate=inspect.ismethod): for name, method in inspect.getmembers(self, predicate=inspect.ismethod):
if callable(method) and not name.startswith('__') and name != 'preload_table': if callable(method) and not name.startswith('__') \
and name != 'preload_table':
method() method()

2
ArknightsUID/utils/resource/RESOURCE_PATH.py
View File

@ -9,6 +9,7 @@ CU_BG_PATH = MAIN_PATH / 'bg'
CONFIG_PATH = MAIN_PATH / 'config.json' CONFIG_PATH = MAIN_PATH / 'config.json'
PLAYER_PATH = MAIN_PATH / 'players' PLAYER_PATH = MAIN_PATH / 'players'
RESOURCE_PATH = MAIN_PATH / 'resource' RESOURCE_PATH = MAIN_PATH / 'resource'
GAMEDATA_PATH = RESOURCE_PATH / 'gamedata'
def init_dir(): def init_dir():
for i in [ for i in [
@ -16,6 +17,7 @@ def init_dir():
CU_BG_PATH, CU_BG_PATH,
PLAYER_PATH, PLAYER_PATH,
RESOURCE_PATH, RESOURCE_PATH,
GAMEDATA_PATH
]: ]:
i.mkdir(parents=True, exist_ok=True) i.mkdir(parents=True, exist_ok=True)

6
pyproject.toml
View File

@ -33,7 +33,7 @@ build-backend = "pdm.backend"
[tool.black] [tool.black]
line-length = 88 line-length = 108
target-version = ["py311"] target-version = ["py311"]
include = '\.pyi?$' include = '\.pyi?$'
skip-string-normalization = true skip-string-normalization = true
@ -42,7 +42,7 @@ extend-exclude = '''
[tool.isort] [tool.isort]
profile = "black" profile = "black"
line_length = 88 line_length = 108
length_sort = true length_sort = true
skip_gitignore = true skip_gitignore = true
force_sort_within_sections = true force_sort_within_sections = true
@ -55,5 +55,5 @@ asyncio_mode = "auto"
select = ["E", "W", "F", "UP", "C", "T", "PYI", "PT", "Q"] select = ["E", "W", "F", "UP", "C", "T", "PYI", "PT", "Q"]
ignore = ["E402", "C901", "UP037", "Q000"] ignore = ["E402", "C901", "UP037", "Q000"]
line-length = 88 line-length = 108
target-version = "py311" target-version = "py311"