let black do it's magic

titles/chuni/air.py

@@ -5,12 +5,13 @@ from titles.chuni.base import ChuniBase
 from titles.chuni.const import ChuniConstants
 from titles.chuni.config import ChuniConfig
 
+
 class ChuniAir(ChuniBase):
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         super().__init__(core_cfg, game_cfg)
         self.version = ChuniConstants.VER_CHUNITHM_AIR
-    
+
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        ret =  super().handle_get_game_setting_api_request(data)
+        ret = super().handle_get_game_setting_api_request(data)
         ret["gameSetting"]["dataVersion"] = "1.10.00"
-        return ret
+        return ret

titles/chuni/airplus.py

@@ -5,12 +5,13 @@ from titles.chuni.base import ChuniBase
 from titles.chuni.const import ChuniConstants
 from titles.chuni.config import ChuniConfig
 
+
 class ChuniAirPlus(ChuniBase):
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         super().__init__(core_cfg, game_cfg)
         self.version = ChuniConstants.VER_CHUNITHM_AIR_PLUS
-    
+
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        ret =  super().handle_get_game_setting_api_request(data)
+        ret = super().handle_get_game_setting_api_request(data)
         ret["gameSetting"]["dataVersion"] = "1.15.00"
-        return ret
+        return ret

titles/chuni/amazon.py

@@ -7,12 +7,13 @@ from titles.chuni.base import ChuniBase
 from titles.chuni.const import ChuniConstants
 from titles.chuni.config import ChuniConfig
 
+
 class ChuniAmazon(ChuniBase):
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         super().__init__(core_cfg, game_cfg)
         self.version = ChuniConstants.VER_CHUNITHM_AMAZON
-    
+
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        ret =  super().handle_get_game_setting_api_request(data)
+        ret = super().handle_get_game_setting_api_request(data)
         ret["gameSetting"]["dataVersion"] = "1.30.00"
         return ret

titles/chuni/amazonplus.py

@@ -7,12 +7,13 @@ from titles.chuni.base import ChuniBase
 from titles.chuni.const import ChuniConstants
 from titles.chuni.config import ChuniConfig
 
+
 class ChuniAmazonPlus(ChuniBase):
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         super().__init__(core_cfg, game_cfg)
         self.version = ChuniConstants.VER_CHUNITHM_AMAZON_PLUS
-    
+
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        ret =  super().handle_get_game_setting_api_request(data)
+        ret = super().handle_get_game_setting_api_request(data)
         ret["gameSetting"]["dataVersion"] = "1.35.00"
         return ret

titles/chuni/base.py

@@ -11,7 +11,8 @@ from titles.chuni.const import ChuniConstants
 from titles.chuni.database import ChuniData
 from titles.chuni.config import ChuniConfig
 
-class ChuniBase():
+
+class ChuniBase:
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         self.core_cfg = core_cfg
         self.game_cfg = game_cfg
@@ -22,32 +23,31 @@ class ChuniBase():
         self.version = ChuniConstants.VER_CHUNITHM
 
     def handle_game_login_api_request(self, data: Dict) -> Dict:
-        #self.data.base.log_event("chuni", "login", logging.INFO, {"version": self.version, "user": data["userId"]})
-        return { "returnCode": 1 }
-    
+        # self.data.base.log_event("chuni", "login", logging.INFO, {"version": self.version, "user": data["userId"]})
+        return {"returnCode": 1}
+
     def handle_game_logout_api_request(self, data: Dict) -> Dict:
-        #self.data.base.log_event("chuni", "logout", logging.INFO, {"version": self.version, "user": data["userId"]})
-        return { "returnCode": 1 }
+        # self.data.base.log_event("chuni", "logout", logging.INFO, {"version": self.version, "user": data["userId"]})
+        return {"returnCode": 1}
 
     def handle_get_game_charge_api_request(self, data: Dict) -> Dict:
         game_charge_list = self.data.static.get_enabled_charges(self.version)
 
         charges = []
-        for x in range(len(game_charge_list)):            
-            charges.append({
-                "orderId": x,
-                "chargeId": game_charge_list[x]["chargeId"],
-                "price": 1,
-                "startDate": "2017-12-05 07:00:00.0", 
-                "endDate": "2099-12-31 00:00:00.0", 
-                "salePrice": 1, 
-                "saleStartDate": "2017-12-05 07:00:00.0", 
-                "saleEndDate": "2099-12-31 00:00:00.0"
-            })
-        return {
-            "length": len(charges), 
-            "gameChargeList": charges
-        }
+        for x in range(len(game_charge_list)):
+            charges.append(
+                {
+                    "orderId": x,
+                    "chargeId": game_charge_list[x]["chargeId"],
+                    "price": 1,
+                    "startDate": "2017-12-05 07:00:00.0",
+                    "endDate": "2099-12-31 00:00:00.0",
+                    "salePrice": 1,
+                    "saleStartDate": "2017-12-05 07:00:00.0",
+                    "saleEndDate": "2099-12-31 00:00:00.0",
+                }
+            )
+        return {"length": len(charges), "gameChargeList": charges}
 
     def handle_get_game_event_api_request(self, data: Dict) -> Dict:
         game_events = self.data.static.get_enabled_events(self.version)
@@ -62,26 +62,30 @@ class ChuniBase():
             event_list.append(tmp)
 
         return {
-            "type": data["type"], 
-            "length": len(event_list), 
-            "gameEventList": event_list
+            "type": data["type"],
+            "length": len(event_list),
+            "gameEventList": event_list,
         }
 
     def handle_get_game_idlist_api_request(self, data: Dict) -> Dict:
-        return { "type": data["type"], "length": 0, "gameIdlistList": [] }
+        return {"type": data["type"], "length": 0, "gameIdlistList": []}
 
     def handle_get_game_message_api_request(self, data: Dict) -> Dict:
-        return { "type": data["type"], "length": "0", "gameMessageList": [] }
+        return {"type": data["type"], "length": "0", "gameMessageList": []}
 
     def handle_get_game_ranking_api_request(self, data: Dict) -> Dict:
-        return { "type": data["type"], "gameRankingList": [] }
+        return {"type": data["type"], "gameRankingList": []}
 
     def handle_get_game_sale_api_request(self, data: Dict) -> Dict:
-        return { "type": data["type"], "length": 0, "gameSaleList": [] }
+        return {"type": data["type"], "length": 0, "gameSaleList": []}
 
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        reboot_start = datetime.strftime(datetime.now() - timedelta(hours=4), self.date_time_format)
-        reboot_end = datetime.strftime(datetime.now() - timedelta(hours=3), self.date_time_format)
+        reboot_start = datetime.strftime(
+            datetime.now() - timedelta(hours=4), self.date_time_format
+        )
+        reboot_end = datetime.strftime(
+            datetime.now() - timedelta(hours=3), self.date_time_format
+        )
         return {
             "gameSetting": {
                 "dataVersion": "1.00.00",
@@ -94,15 +98,17 @@ class ChuniBase():
                 "maxCountItem": 300,
                 "maxCountMusic": 300,
             },
-                "isDumpUpload": "false",
-                "isAou": "false",
+            "isDumpUpload": "false",
+            "isAou": "false",
         }
 
     def handle_get_user_activity_api_request(self, data: Dict) -> Dict:
-        user_activity_list = self.data.profile.get_profile_activity(data["userId"], data["kind"])
-        
+        user_activity_list = self.data.profile.get_profile_activity(
+            data["userId"], data["kind"]
+        )
+
         activity_list = []
-        
+
         for activity in user_activity_list:
             tmp = activity._asdict()
             tmp.pop("user")
@@ -111,15 +117,16 @@ class ChuniBase():
             activity_list.append(tmp)
 
         return {
-          "userId": data["userId"], 
-          "length": len(activity_list),
-          "kind": data["kind"],
-          "userActivityList": activity_list
+            "userId": data["userId"],
+            "length": len(activity_list),
+            "kind": data["kind"],
+            "userActivityList": activity_list,
         }
 
     def handle_get_user_character_api_request(self, data: Dict) -> Dict:
         characters = self.data.item.get_characters(data["userId"])
-        if characters is None: return {}
+        if characters is None:
+            return {}
         next_idx = -1
 
         characterList = []
@@ -131,15 +138,17 @@ class ChuniBase():
 
             if len(characterList) >= int(data["maxCount"]):
                 break
-        
-        if len(characterList) >= int(data["maxCount"]) and len(characters) > int(data["maxCount"]) + int(data["nextIndex"]):
+
+        if len(characterList) >= int(data["maxCount"]) and len(characters) > int(
+            data["maxCount"]
+        ) + int(data["nextIndex"]):
             next_idx = int(data["maxCount"]) + int(data["nextIndex"]) + 1
-        
+
         return {
-            "userId": data["userId"], 
+            "userId": data["userId"],
             "length": len(characterList),
-            "nextIndex": next_idx, 
-            "userCharacterList": characterList
+            "nextIndex": next_idx,
+            "userCharacterList": characterList,
         }
 
     def handle_get_user_charge_api_request(self, data: Dict) -> Dict:
@@ -153,21 +162,21 @@ class ChuniBase():
             charge_list.append(tmp)
 
         return {
-            "userId": data["userId"], 
+            "userId": data["userId"],
             "length": len(charge_list),
-            "userChargeList": charge_list
+            "userChargeList": charge_list,
         }
 
     def handle_get_user_course_api_request(self, data: Dict) -> Dict:
         user_course_list = self.data.score.get_courses(data["userId"])
-        if user_course_list is None: 
+        if user_course_list is None:
             return {
-                "userId": data["userId"], 
+                "userId": data["userId"],
                 "length": 0,
-                "nextIndex": -1, 
-                "userCourseList": []
+                "nextIndex": -1,
+                "userCourseList": [],
             }
-        
+
         course_list = []
         next_idx = int(data["nextIndex"])
         max_ct = int(data["maxCount"])
@@ -180,51 +189,48 @@ class ChuniBase():
 
             if len(user_course_list) >= max_ct:
                 break
-        
+
         if len(user_course_list) >= max_ct:
             next_idx = next_idx + max_ct
         else:
             next_idx = -1
-                
+
         return {
-            "userId": data["userId"], 
+            "userId": data["userId"],
             "length": len(course_list),
-            "nextIndex": next_idx, 
-            "userCourseList": course_list
+            "nextIndex": next_idx,
+            "userCourseList": course_list,
         }
 
     def handle_get_user_data_api_request(self, data: Dict) -> Dict:
         p = self.data.profile.get_profile_data(data["userId"], self.version)
-        if p is None: return {}
+        if p is None:
+            return {}
 
         profile = p._asdict()
         profile.pop("id")
         profile.pop("user")
         profile.pop("version")
 
-        return {
-            "userId": data["userId"], 
-            "userData": profile
-        }
+        return {"userId": data["userId"], "userData": profile}
 
     def handle_get_user_data_ex_api_request(self, data: Dict) -> Dict:
         p = self.data.profile.get_profile_data_ex(data["userId"], self.version)
-        if p is None: return {}
+        if p is None:
+            return {}
 
         profile = p._asdict()
         profile.pop("id")
         profile.pop("user")
         profile.pop("version")
 
-        return {
-            "userId": data["userId"], 
-            "userDataEx": profile
-        }
+        return {"userId": data["userId"], "userDataEx": profile}
 
     def handle_get_user_duel_api_request(self, data: Dict) -> Dict:
         user_duel_list = self.data.item.get_duels(data["userId"])
-        if user_duel_list is None: return {}
-        
+        if user_duel_list is None:
+            return {}
+
         duel_list = []
         for duel in user_duel_list:
             tmp = duel._asdict()
@@ -233,18 +239,18 @@ class ChuniBase():
             duel_list.append(tmp)
 
         return {
-            "userId": data["userId"], 
+            "userId": data["userId"],
             "length": len(duel_list),
-            "userDuelList": duel_list
+            "userDuelList": duel_list,
         }
 
     def handle_get_user_favorite_item_api_request(self, data: Dict) -> Dict:
         return {
-            "userId": data["userId"], 
+            "userId": data["userId"],
             "length": 0,
-            "kind": data["kind"], 
-            "nextIndex": -1, 
-            "userFavoriteItemList": []
+            "kind": data["kind"],
+            "nextIndex": -1,
+            "userFavoriteItemList": [],
         }
 
     def handle_get_user_favorite_music_api_request(self, data: Dict) -> Dict:
@@ -252,22 +258,23 @@ class ChuniBase():
         This is handled via the webui, which we don't have right now
         """
 
-        return {
-            "userId": data["userId"], 
-            "length": 0,
-            "userFavoriteMusicList": []
-        }
+        return {"userId": data["userId"], "length": 0, "userFavoriteMusicList": []}
 
     def handle_get_user_item_api_request(self, data: Dict) -> Dict:
         kind = int(int(data["nextIndex"]) / 10000000000)
         next_idx = int(int(data["nextIndex"]) % 10000000000)
         user_item_list = self.data.item.get_items(data["userId"], kind)
 
-        if user_item_list is None or len(user_item_list) == 0: 
-            return {"userId": data["userId"], "nextIndex": -1, "itemKind": kind, "userItemList": []}
+        if user_item_list is None or len(user_item_list) == 0:
+            return {
+                "userId": data["userId"],
+                "nextIndex": -1,
+                "itemKind": kind,
+                "userItemList": [],
+            }
 
         items: list[Dict[str, Any]] = []
-        for i in range(next_idx, len(user_item_list)):            
+        for i in range(next_idx, len(user_item_list)):
             tmp = user_item_list[i]._asdict()
             tmp.pop("user")
             tmp.pop("id")
@@ -277,38 +284,47 @@ class ChuniBase():
 
         xout = kind * 10000000000 + next_idx + len(items)
 
-        if len(items) < int(data["maxCount"]): nextIndex = 0
-        else: nextIndex = xout
+        if len(items) < int(data["maxCount"]):
+            nextIndex = 0
+        else:
+            nextIndex = xout
 
-        return {"userId": data["userId"], "nextIndex": nextIndex, "itemKind": kind, "length": len(items), "userItemList": items}
+        return {
+            "userId": data["userId"],
+            "nextIndex": nextIndex,
+            "itemKind": kind,
+            "length": len(items),
+            "userItemList": items,
+        }
 
     def handle_get_user_login_bonus_api_request(self, data: Dict) -> Dict:
         """
         Unsure how to get this to trigger...
         """
         return {
-            "userId": data["userId"], 
+            "userId": data["userId"],
             "length": 2,
             "userLoginBonusList": [
                 {
-                "presetId": '10',
-                "bonusCount": '0',
-                "lastUpdateDate": "1970-01-01 09:00:00",
-                "isWatched": "true"
+                    "presetId": "10",
+                    "bonusCount": "0",
+                    "lastUpdateDate": "1970-01-01 09:00:00",
+                    "isWatched": "true",
                 },
                 {
-                "presetId": '20',
-                "bonusCount": '0',
-                "lastUpdateDate": "1970-01-01 09:00:00",
-                "isWatched": "true"
+                    "presetId": "20",
+                    "bonusCount": "0",
+                    "lastUpdateDate": "1970-01-01 09:00:00",
+                    "isWatched": "true",
                 },
-            ]
+            ],
         }
 
     def handle_get_user_map_api_request(self, data: Dict) -> Dict:
         user_map_list = self.data.item.get_maps(data["userId"])
-        if user_map_list is None: return {}
-        
+        if user_map_list is None:
+            return {}
+
         map_list = []
         for map in user_map_list:
             tmp = map._asdict()
@@ -317,19 +333,19 @@ class ChuniBase():
             map_list.append(tmp)
 
         return {
-            "userId": data["userId"], 
+            "userId": data["userId"],
             "length": len(map_list),
-            "userMapList": map_list
+            "userMapList": map_list,
         }
 
     def handle_get_user_music_api_request(self, data: Dict) -> Dict:
         music_detail = self.data.score.get_scores(data["userId"])
-        if music_detail is None: 
+        if music_detail is None:
             return {
-                "userId": data["userId"], 
-                "length": 0, 
+                "userId": data["userId"],
+                "length": 0,
                 "nextIndex": -1,
-                "userMusicList": [] #240
+                "userMusicList": [],  # 240
             }
         song_list = []
         next_idx = int(data["nextIndex"])
@@ -340,66 +356,60 @@ class ChuniBase():
             tmp = music_detail[x]._asdict()
             tmp.pop("user")
             tmp.pop("id")
-            
+
             for song in song_list:
                 if song["userMusicDetailList"][0]["musicId"] == tmp["musicId"]:
                     found = True
                     song["userMusicDetailList"].append(tmp)
                     song["length"] = len(song["userMusicDetailList"])
-            
+
             if not found:
-                song_list.append({
-                    "length": 1,
-                    "userMusicDetailList": [tmp]
-                })
-            
+                song_list.append({"length": 1, "userMusicDetailList": [tmp]})
+
             if len(song_list) >= max_ct:
                 break
-        
+
         if len(song_list) >= max_ct:
             next_idx += max_ct
         else:
             next_idx = 0
 
         return {
-            "userId": data["userId"], 
-            "length": len(song_list), 
+            "userId": data["userId"],
+            "length": len(song_list),
             "nextIndex": next_idx,
-            "userMusicList": song_list #240
+            "userMusicList": song_list,  # 240
         }
 
     def handle_get_user_option_api_request(self, data: Dict) -> Dict:
         p = self.data.profile.get_profile_option(data["userId"])
-        
+
         option = p._asdict()
         option.pop("id")
         option.pop("user")
 
-        return {
-            "userId": data["userId"], 
-            "userGameOption": option
-        }
+        return {"userId": data["userId"], "userGameOption": option}
 
     def handle_get_user_option_ex_api_request(self, data: Dict) -> Dict:
         p = self.data.profile.get_profile_option_ex(data["userId"])
-        
+
         option = p._asdict()
         option.pop("id")
         option.pop("user")
 
-        return {
-            "userId": data["userId"], 
-            "userGameOptionEx": option
-        }
+        return {"userId": data["userId"], "userGameOptionEx": option}
 
     def read_wtf8(self, src):
         return bytes([ord(c) for c in src]).decode("utf-8")
 
     def handle_get_user_preview_api_request(self, data: Dict) -> Dict:
         profile = self.data.profile.get_profile_preview(data["userId"], self.version)
-        if profile is None: return None
-        profile_character = self.data.item.get_character(data["userId"], profile["characterId"])
-        
+        if profile is None:
+            return None
+        profile_character = self.data.item.get_character(
+            data["userId"], profile["characterId"]
+        )
+
         if profile_character is None:
             chara = {}
         else:
@@ -408,8 +418,8 @@ class ChuniBase():
             chara.pop("user")
 
         return {
-            "userId": data["userId"],    
-            # Current Login State            
+            "userId": data["userId"],
+            # Current Login State
             "isLogin": False,
             "lastLoginDate": profile["lastPlayDate"],
             # User Profile
@@ -421,14 +431,14 @@ class ChuniBase():
             "lastGameId": profile["lastGameId"],
             "lastRomVersion": profile["lastRomVersion"],
             "lastDataVersion": profile["lastDataVersion"],
-            "lastPlayDate": profile["lastPlayDate"],            
-            "trophyId": profile["trophyId"],  
+            "lastPlayDate": profile["lastPlayDate"],
+            "trophyId": profile["trophyId"],
             "nameplateId": profile["nameplateId"],
             # Current Selected Character
             "userCharacter": chara,
             # User Game Options
-            "playerLevel": profile["playerLevel"], 
-            "rating": profile["rating"], 
+            "playerLevel": profile["playerLevel"],
+            "rating": profile["rating"],
             "headphone": profile["headphone"],
             "chargeState": "1",
             "userNameEx": profile["userName"],
@@ -436,7 +446,7 @@ class ChuniBase():
 
     def handle_get_user_recent_rating_api_request(self, data: Dict) -> Dict:
         recet_rating_list = self.data.profile.get_profile_recent_rating(data["userId"])
-        if recet_rating_list is None: 
+        if recet_rating_list is None:
             return {
                 "userId": data["userId"],
                 "length": 0,
@@ -459,11 +469,8 @@ class ChuniBase():
 
     def handle_get_user_team_api_request(self, data: Dict) -> Dict:
         # TODO: Team
-        return {
-            "userId": data["userId"],
-            "teamId": 0
-        }
-    
+        return {"userId": data["userId"], "teamId": 0}
+
     def handle_get_team_course_setting_api_request(self, data: Dict) -> Dict:
         return {
             "userId": data["userId"],
@@ -486,19 +493,30 @@ class ChuniBase():
 
         if "userData" in upsert:
             try:
-                upsert["userData"][0]["userName"] = self.read_wtf8(upsert["userData"][0]["userName"])
-            except: pass
+                upsert["userData"][0]["userName"] = self.read_wtf8(
+                    upsert["userData"][0]["userName"]
+                )
+            except:
+                pass
 
-            self.data.profile.put_profile_data(user_id, self.version, upsert["userData"][0])
+            self.data.profile.put_profile_data(
+                user_id, self.version, upsert["userData"][0]
+            )
         if "userDataEx" in upsert:
-            self.data.profile.put_profile_data_ex(user_id, self.version, upsert["userDataEx"][0])
+            self.data.profile.put_profile_data_ex(
+                user_id, self.version, upsert["userDataEx"][0]
+            )
         if "userGameOption" in upsert:
             self.data.profile.put_profile_option(user_id, upsert["userGameOption"][0])
         if "userGameOptionEx" in upsert:
-            self.data.profile.put_profile_option_ex(user_id, upsert["userGameOptionEx"][0])
+            self.data.profile.put_profile_option_ex(
+                user_id, upsert["userGameOptionEx"][0]
+            )
         if "userRecentRatingList" in upsert:
-            self.data.profile.put_profile_recent_rating(user_id, upsert["userRecentRatingList"])
-        
+            self.data.profile.put_profile_recent_rating(
+                user_id, upsert["userRecentRatingList"]
+            )
+
         if "userCharacterList" in upsert:
             for character in upsert["userCharacterList"]:
                 self.data.item.put_character(user_id, character)
@@ -514,7 +532,7 @@ class ChuniBase():
         if "userDuelList" in upsert:
             for duel in upsert["userDuelList"]:
                 self.data.item.put_duel(user_id, duel)
-        
+
         if "userItemList" in upsert:
             for item in upsert["userItemList"]:
                 self.data.item.put_item(user_id, item)
@@ -522,23 +540,23 @@ class ChuniBase():
         if "userActivityList" in upsert:
             for activity in upsert["userActivityList"]:
                 self.data.profile.put_profile_activity(user_id, activity)
-        
+
         if "userChargeList" in upsert:
             for charge in upsert["userChargeList"]:
                 self.data.profile.put_profile_charge(user_id, charge)
-        
+
         if "userMusicDetailList" in upsert:
             for song in upsert["userMusicDetailList"]:
                 self.data.score.put_score(user_id, song)
-        
+
         if "userPlaylogList" in upsert:
             for playlog in upsert["userPlaylogList"]:
                 self.data.score.put_playlog(user_id, playlog)
-        
+
         if "userTeamPoint" in upsert:
             # TODO: team stuff
             pass
-        
+
         if "userMapAreaList" in upsert:
             for map_area in upsert["userMapAreaList"]:
                 self.data.item.put_map_area(user_id, map_area)
@@ -551,22 +569,22 @@ class ChuniBase():
             for emoney in upsert["userEmoneyList"]:
                 self.data.profile.put_profile_emoney(user_id, emoney)
 
-        return { "returnCode": "1" }
+        return {"returnCode": "1"}
 
     def handle_upsert_user_chargelog_api_request(self, data: Dict) -> Dict:
-        return { "returnCode": "1" }
+        return {"returnCode": "1"}
 
     def handle_upsert_client_bookkeeping_api_request(self, data: Dict) -> Dict:
-        return { "returnCode": "1" }
+        return {"returnCode": "1"}
 
     def handle_upsert_client_develop_api_request(self, data: Dict) -> Dict:
-        return { "returnCode": "1" }
+        return {"returnCode": "1"}
 
     def handle_upsert_client_error_api_request(self, data: Dict) -> Dict:
-        return { "returnCode": "1" }
+        return {"returnCode": "1"}
 
     def handle_upsert_client_setting_api_request(self, data: Dict) -> Dict:
-        return { "returnCode": "1" }
+        return {"returnCode": "1"}
 
     def handle_upsert_client_testmode_api_request(self, data: Dict) -> Dict:
-        return { "returnCode": "1" }
+        return {"returnCode": "1"}

titles/chuni/config.py

@@ -1,36 +1,49 @@
 from core.config import CoreConfig
 from typing import Dict
 
-class ChuniServerConfig():
+
+class ChuniServerConfig:
     def __init__(self, parent_config: "ChuniConfig") -> None:
         self.__config = parent_config
-    
+
     @property
     def enable(self) -> bool:
-        return CoreConfig.get_config_field(self.__config, 'chuni', 'server', 'enable', default=True)
-    
+        return CoreConfig.get_config_field(
+            self.__config, "chuni", "server", "enable", default=True
+        )
+
     @property
     def loglevel(self) -> int:
-        return CoreConfig.str_to_loglevel(CoreConfig.get_config_field(self.__config, 'chuni', 'server', 'loglevel', default="info"))
+        return CoreConfig.str_to_loglevel(
+            CoreConfig.get_config_field(
+                self.__config, "chuni", "server", "loglevel", default="info"
+            )
+        )
 
-class ChuniCryptoConfig():
+
+class ChuniCryptoConfig:
     def __init__(self, parent_config: "ChuniConfig") -> None:
         self.__config = parent_config
-    
+
     @property
     def keys(self) -> Dict:
         """
         in the form of:
-        internal_version: [key, iv]        
+        internal_version: [key, iv]
         all values are hex strings
         """
-        return CoreConfig.get_config_field(self.__config, 'chuni', 'crypto', 'keys', default={})
+        return CoreConfig.get_config_field(
+            self.__config, "chuni", "crypto", "keys", default={}
+        )
 
     @property
     def encrypted_only(self) -> bool:
-        return CoreConfig.get_config_field(self.__config, 'chuni', 'crypto', 'encrypted_only', default=False)
+        return CoreConfig.get_config_field(
+            self.__config, "chuni", "crypto", "encrypted_only", default=False
+        )
+
 
 class ChuniConfig(dict):
     def __init__(self) -> None:
         self.server = ChuniServerConfig(self)
-        self.crypto = ChuniCryptoConfig(self)
+        self.crypto = ChuniCryptoConfig(self)

titles/chuni/const.py

@@ -1,4 +1,4 @@
-class ChuniConstants():
+class ChuniConstants:
     GAME_CODE = "SDBT"
     GAME_CODE_NEW = "SDHD"
 
@@ -8,7 +8,7 @@ class ChuniConstants():
     VER_CHUNITHM_PLUS = 1
     VER_CHUNITHM_AIR = 2
     VER_CHUNITHM_AIR_PLUS = 3
-    VER_CHUNITHM_STAR = 4 
+    VER_CHUNITHM_STAR = 4
     VER_CHUNITHM_STAR_PLUS = 5
     VER_CHUNITHM_AMAZON = 6
     VER_CHUNITHM_AMAZON_PLUS = 7
@@ -18,8 +18,21 @@ class ChuniConstants():
     VER_CHUNITHM_NEW = 11
     VER_CHUNITHM_NEW_PLUS = 12
 
-    VERSION_NAMES = ["Chunithm", "Chunithm+", "Chunithm Air", "Chunithm Air+", "Chunithm Star", "Chunithm Star+", "Chunithm Amazon",
-    "Chunithm Amazon+", "Chunithm Crystal", "Chunithm Crystal+", "Chunithm Paradise", "Chunithm New!!", "Chunithm New!!+"]
+    VERSION_NAMES = [
+        "Chunithm",
+        "Chunithm+",
+        "Chunithm Air",
+        "Chunithm Air+",
+        "Chunithm Star",
+        "Chunithm Star+",
+        "Chunithm Amazon",
+        "Chunithm Amazon+",
+        "Chunithm Crystal",
+        "Chunithm Crystal+",
+        "Chunithm Paradise",
+        "Chunithm New!!",
+        "Chunithm New!!+",
+    ]
 
     @classmethod
     def game_ver_to_string(cls, ver: int):

titles/chuni/crystal.py

@@ -7,12 +7,13 @@ from titles.chuni.base import ChuniBase
 from titles.chuni.const import ChuniConstants
 from titles.chuni.config import ChuniConfig
 
+
 class ChuniCrystal(ChuniBase):
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         super().__init__(core_cfg, game_cfg)
         self.version = ChuniConstants.VER_CHUNITHM_CRYSTAL
-    
+
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        ret =  super().handle_get_game_setting_api_request(data)
+        ret = super().handle_get_game_setting_api_request(data)
         ret["gameSetting"]["dataVersion"] = "1.40.00"
         return ret

titles/chuni/crystalplus.py

@@ -7,12 +7,13 @@ from titles.chuni.base import ChuniBase
 from titles.chuni.const import ChuniConstants
 from titles.chuni.config import ChuniConfig
 
+
 class ChuniCrystalPlus(ChuniBase):
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         super().__init__(core_cfg, game_cfg)
         self.version = ChuniConstants.VER_CHUNITHM_CRYSTAL_PLUS
-    
+
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        ret =  super().handle_get_game_setting_api_request(data)
+        ret = super().handle_get_game_setting_api_request(data)
         ret["gameSetting"]["dataVersion"] = "1.45.00"
         return ret

titles/chuni/database.py

@@ -2,6 +2,7 @@ from core.data import Data
 from core.config import CoreConfig
 from titles.chuni.schema import *
 
+
 class ChuniData(Data):
     def __init__(self, cfg: CoreConfig) -> None:
         super().__init__(cfg)
@@ -9,4 +10,4 @@ class ChuniData(Data):
         self.item = ChuniItemData(cfg, self.session)
         self.profile = ChuniProfileData(cfg, self.session)
         self.score = ChuniScoreData(cfg, self.session)
-        self.static = ChuniStaticData(cfg, self.session)
+        self.static = ChuniStaticData(cfg, self.session)

titles/chuni/index.py

@@ -28,12 +28,15 @@ from titles.chuni.paradise import ChuniParadise
 from titles.chuni.new import ChuniNew
 from titles.chuni.newplus import ChuniNewPlus
 
-class ChuniServlet():
+
+class ChuniServlet:
     def __init__(self, core_cfg: CoreConfig, cfg_dir: str) -> None:
         self.core_cfg = core_cfg
         self.game_cfg = ChuniConfig()
         if path.exists(f"{cfg_dir}/{ChuniConstants.CONFIG_NAME}"):
-            self.game_cfg.update(yaml.safe_load(open(f"{cfg_dir}/{ChuniConstants.CONFIG_NAME}")))
+            self.game_cfg.update(
+                yaml.safe_load(open(f"{cfg_dir}/{ChuniConstants.CONFIG_NAME}"))
+            )
 
         self.versions = [
             ChuniBase(core_cfg, self.game_cfg),
@@ -56,33 +59,47 @@ class ChuniServlet():
         if not hasattr(self.logger, "inited"):
             log_fmt_str = "[%(asctime)s] Chunithm | %(levelname)s | %(message)s"
             log_fmt = logging.Formatter(log_fmt_str)
-            fileHandler = TimedRotatingFileHandler("{0}/{1}.log".format(self.core_cfg.server.log_dir, "chuni"), encoding='utf8', 
-                when="d", backupCount=10)
+            fileHandler = TimedRotatingFileHandler(
+                "{0}/{1}.log".format(self.core_cfg.server.log_dir, "chuni"),
+                encoding="utf8",
+                when="d",
+                backupCount=10,
+            )
 
             fileHandler.setFormatter(log_fmt)
-            
+
             consoleHandler = logging.StreamHandler()
             consoleHandler.setFormatter(log_fmt)
 
             self.logger.addHandler(fileHandler)
             self.logger.addHandler(consoleHandler)
-            
+
             self.logger.setLevel(self.game_cfg.server.loglevel)
-            coloredlogs.install(level=self.game_cfg.server.loglevel, logger=self.logger, fmt=log_fmt_str)
+            coloredlogs.install(
+                level=self.game_cfg.server.loglevel, logger=self.logger, fmt=log_fmt_str
+            )
             self.logger.inited = True
 
     @classmethod
-    def get_allnet_info(cls, game_code: str, core_cfg: CoreConfig, cfg_dir: str) -> Tuple[bool, str, str]:
+    def get_allnet_info(
+        cls, game_code: str, core_cfg: CoreConfig, cfg_dir: str
+    ) -> Tuple[bool, str, str]:
         game_cfg = ChuniConfig()
         if path.exists(f"{cfg_dir}/{ChuniConstants.CONFIG_NAME}"):
-            game_cfg.update(yaml.safe_load(open(f"{cfg_dir}/{ChuniConstants.CONFIG_NAME}")))
+            game_cfg.update(
+                yaml.safe_load(open(f"{cfg_dir}/{ChuniConstants.CONFIG_NAME}"))
+            )
 
         if not game_cfg.server.enable:
             return (False, "", "")
-        
+
         if core_cfg.server.is_develop:
-            return (True, f"http://{core_cfg.title.hostname}:{core_cfg.title.port}/{game_code}/$v/", "")
-        
+            return (
+                True,
+                f"http://{core_cfg.title.hostname}:{core_cfg.title.port}/{game_code}/$v/",
+                "",
+            )
+
         return (True, f"http://{core_cfg.title.hostname}/{game_code}/$v/", "")
 
     def render_POST(self, request: Request, version: int, url_path: str) -> bytes:
@@ -95,67 +112,75 @@ class ChuniServlet():
         internal_ver = 0
         endpoint = url_split[len(url_split) - 1]
 
-        if version < 105: # 1.0
+        if version < 105:  # 1.0
             internal_ver = ChuniConstants.VER_CHUNITHM
-        elif version >= 105 and version < 110: # Plus
+        elif version >= 105 and version < 110:  # Plus
             internal_ver = ChuniConstants.VER_CHUNITHM_PLUS
-        elif version >= 110 and version < 115: # Air
+        elif version >= 110 and version < 115:  # Air
             internal_ver = ChuniConstants.VER_CHUNITHM_AIR
-        elif version >= 115 and version < 120: # Air Plus
+        elif version >= 115 and version < 120:  # Air Plus
             internal_ver = ChuniConstants.VER_CHUNITHM_AIR_PLUS
-        elif version >= 120 and version < 125: # Star
+        elif version >= 120 and version < 125:  # Star
             internal_ver = ChuniConstants.VER_CHUNITHM_STAR
-        elif version >= 125 and version < 130: # Star Plus
+        elif version >= 125 and version < 130:  # Star Plus
             internal_ver = ChuniConstants.VER_CHUNITHM_STAR_PLUS
-        elif version >= 130 and version < 135: # Amazon
+        elif version >= 130 and version < 135:  # Amazon
             internal_ver = ChuniConstants.VER_CHUNITHM_AMAZON
-        elif version >= 135 and version < 140: # Amazon Plus
+        elif version >= 135 and version < 140:  # Amazon Plus
             internal_ver = ChuniConstants.VER_CHUNITHM_AMAZON_PLUS
-        elif version >= 140 and version < 145: # Crystal
+        elif version >= 140 and version < 145:  # Crystal
             internal_ver = ChuniConstants.VER_CHUNITHM_CRYSTAL
-        elif version >= 145 and version < 150: # Crystal Plus
+        elif version >= 145 and version < 150:  # Crystal Plus
             internal_ver = ChuniConstants.VER_CHUNITHM_CRYSTAL_PLUS
-        elif version >= 150 and version < 200: # Paradise
+        elif version >= 150 and version < 200:  # Paradise
             internal_ver = ChuniConstants.VER_CHUNITHM_PARADISE
-        elif version >= 200 and version < 205: # New
+        elif version >= 200 and version < 205:  # New
             internal_ver = ChuniConstants.VER_CHUNITHM_NEW
-        elif version >= 205 and version < 210: # New Plus
+        elif version >= 205 and version < 210:  # New Plus
             internal_ver = ChuniConstants.VER_CHUNITHM_NEW_PLUS
 
         if all(c in string.hexdigits for c in endpoint) and len(endpoint) == 32:
-            # If we get a 32 character long hex string, it's a hash and we're 
-            # doing encrypted. The likelyhood of false positives is low but 
+            # If we get a 32 character long hex string, it's a hash and we're
+            # doing encrypted. The likelyhood of false positives is low but
             # technically not 0
             endpoint = request.getHeader("User-Agent").split("#")[0]
             try:
                 crypt = AES.new(
-                    bytes.fromhex(self.game_cfg.crypto.keys[str(internal_ver)][0]), 
-                    AES.MODE_CBC, 
-                    bytes.fromhex(self.game_cfg.crypto.keys[str(internal_ver)][1])
+                    bytes.fromhex(self.game_cfg.crypto.keys[str(internal_ver)][0]),
+                    AES.MODE_CBC,
+                    bytes.fromhex(self.game_cfg.crypto.keys[str(internal_ver)][1]),
                 )
 
                 req_raw = crypt.decrypt(req_raw)
 
             except:
-                self.logger.error(f"Failed to decrypt v{version} request to {endpoint} -> {req_raw}")
+                self.logger.error(
+                    f"Failed to decrypt v{version} request to {endpoint} -> {req_raw}"
+                )
                 return zlib.compress(b'{"stat": "0"}')
 
             encrtped = True
-        
+
         if not encrtped and self.game_cfg.crypto.encrypted_only:
-            self.logger.error(f"Unencrypted v{version} {endpoint} request, but config is set to encrypted only: {req_raw}")
+            self.logger.error(
+                f"Unencrypted v{version} {endpoint} request, but config is set to encrypted only: {req_raw}"
+            )
             return zlib.compress(b'{"stat": "0"}')
 
-        try:            
+        try:
             unzip = zlib.decompress(req_raw)
-            
+
         except zlib.error as e:
-            self.logger.error(f"Failed to decompress v{version} {endpoint} request -> {e}")
+            self.logger.error(
+                f"Failed to decompress v{version} {endpoint} request -> {e}"
+            )
             return b""
-        
+
         req_data = json.loads(unzip)
-        
-        self.logger.info(f"v{version} {endpoint} request from {request.getClientAddress().host}")
+
+        self.logger.info(
+            f"v{version} {endpoint} request from {request.getClientAddress().host}"
+        )
         self.logger.debug(req_data)
 
         func_to_find = "handle_" + inflection.underscore(endpoint) + "_request"
@@ -163,9 +188,8 @@ class ChuniServlet():
         if not hasattr(self.versions[internal_ver], func_to_find):
             self.logger.warning(f"Unhandled v{version} request {endpoint}")
             resp = {"returnCode": 1}
-        
-        else:
 
+        else:
             try:
                 handler = getattr(self.versions[internal_ver], func_to_find)
                 resp = handler(req_data)
@@ -173,23 +197,23 @@ class ChuniServlet():
             except Exception as e:
                 self.logger.error(f"Error handling v{version} method {endpoint} - {e}")
                 return zlib.compress(b'{"stat": "0"}')
-        
+
         if resp == None:
-            resp = {'returnCode': 1}
-        
+            resp = {"returnCode": 1}
+
         self.logger.debug(f"Response {resp}")
-        
+
         zipped = zlib.compress(json.dumps(resp, ensure_ascii=False).encode("utf-8"))
-        
+
         if not encrtped:
             return zipped
 
         padded = pad(zipped, 16)
 
         crypt = AES.new(
-            bytes.fromhex(self.game_cfg.crypto.keys[str(internal_ver)][0]), 
-            AES.MODE_CBC, 
-            bytes.fromhex(self.game_cfg.crypto.keys[str(internal_ver)][1])
+            bytes.fromhex(self.game_cfg.crypto.keys[str(internal_ver)][0]),
+            AES.MODE_CBC,
+            bytes.fromhex(self.game_cfg.crypto.keys[str(internal_ver)][1]),
         )
 
         return crypt.encrypt(padded)

titles/chuni/new.py

@@ -9,13 +9,9 @@ from titles.chuni.database import ChuniData
 from titles.chuni.base import ChuniBase
 from titles.chuni.config import ChuniConfig
 
-class ChuniNew(ChuniBase):
 
-    ITEM_TYPE = {
-        "character": 20,
-        "story": 21,
-        "card": 22
-    }
+class ChuniNew(ChuniBase):
+    ITEM_TYPE = {"character": 20, "story": 21, "card": 22}
 
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         self.core_cfg = core_cfg
@@ -25,12 +21,20 @@ class ChuniNew(ChuniBase):
         self.logger = logging.getLogger("chuni")
         self.game = ChuniConstants.GAME_CODE
         self.version = ChuniConstants.VER_CHUNITHM_NEW
-    
+
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        match_start = datetime.strftime(datetime.now() - timedelta(hours=10), self.date_time_format)
-        match_end = datetime.strftime(datetime.now() + timedelta(hours=10), self.date_time_format)
-        reboot_start = datetime.strftime(datetime.now() - timedelta(hours=11), self.date_time_format)
-        reboot_end = datetime.strftime(datetime.now() - timedelta(hours=10), self.date_time_format)
+        match_start = datetime.strftime(
+            datetime.now() - timedelta(hours=10), self.date_time_format
+        )
+        match_end = datetime.strftime(
+            datetime.now() + timedelta(hours=10), self.date_time_format
+        )
+        reboot_start = datetime.strftime(
+            datetime.now() - timedelta(hours=11), self.date_time_format
+        )
+        reboot_end = datetime.strftime(
+            datetime.now() - timedelta(hours=10), self.date_time_format
+        )
         return {
             "gameSetting": {
                 "isMaintenance": "false",
@@ -52,16 +56,16 @@ class ChuniNew(ChuniBase):
                 "udpHolePunchUri": f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/200/ChuniServlet/",
                 "reflectorUri": f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/200/ChuniServlet/",
             },
-                "isDumpUpload": "false",
-                "isAou": "false",
+            "isDumpUpload": "false",
+            "isAou": "false",
         }
-        
+
     def handle_delete_token_api_request(self, data: Dict) -> Dict:
-        return { "returnCode": "1" }
-    
+        return {"returnCode": "1"}
+
     def handle_create_token_api_request(self, data: Dict) -> Dict:
-        return { "returnCode": "1" }
-        
+        return {"returnCode": "1"}
+
     def handle_get_user_map_area_api_request(self, data: Dict) -> Dict:
         user_map_areas = self.data.item.get_map_areas(data["userId"])
 
@@ -72,32 +76,29 @@ class ChuniNew(ChuniBase):
             tmp.pop("user")
             map_areas.append(tmp)
 
-        return {
-            "userId": data["userId"], 
-            "userMapAreaList": map_areas
-        }
-    
+        return {"userId": data["userId"], "userMapAreaList": map_areas}
+
     def handle_get_user_symbol_chat_setting_api_request(self, data: Dict) -> Dict:
-        return {
-            "userId": data["userId"], 
-            "symbolCharInfoList": []
-        }
+        return {"userId": data["userId"], "symbolCharInfoList": []}
 
     def handle_get_user_preview_api_request(self, data: Dict) -> Dict:
         profile = self.data.profile.get_profile_preview(data["userId"], self.version)
-        if profile is None: return None
-        profile_character = self.data.item.get_character(data["userId"], profile["characterId"])
-        
+        if profile is None:
+            return None
+        profile_character = self.data.item.get_character(
+            data["userId"], profile["characterId"]
+        )
+
         if profile_character is None:
             chara = {}
         else:
             chara = profile_character._asdict()
             chara.pop("id")
             chara.pop("user")
-        
+
         data1 = {
-            "userId": data["userId"],    
-            # Current Login State            
+            "userId": data["userId"],
+            # Current Login State
             "isLogin": False,
             "lastLoginDate": profile["lastPlayDate"],
             # User Profile
@@ -109,14 +110,14 @@ class ChuniNew(ChuniBase):
             "lastGameId": profile["lastGameId"],
             "lastRomVersion": profile["lastRomVersion"],
             "lastDataVersion": profile["lastDataVersion"],
-            "lastPlayDate": profile["lastPlayDate"],          
+            "lastPlayDate": profile["lastPlayDate"],
             "emoneyBrandId": 0,
-            "trophyId": profile["trophyId"],            
+            "trophyId": profile["trophyId"],
             # Current Selected Character
             "userCharacter": chara,
             # User Game Options
-            "playerLevel": profile["playerLevel"], 
-            "rating": profile["rating"], 
+            "playerLevel": profile["playerLevel"],
+            "rating": profile["rating"],
             "headphone": profile["headphone"],
             "chargeState": 0,
             "userNameEx": "0",

titles/chuni/newplus.py

@@ -7,17 +7,26 @@ from titles.chuni.new import ChuniNew
 from titles.chuni.const import ChuniConstants
 from titles.chuni.config import ChuniConfig
 
+
 class ChuniNewPlus(ChuniNew):
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         super().__init__(core_cfg, game_cfg)
         self.version = ChuniConstants.VER_CHUNITHM_NEW_PLUS
-    
+
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
         ret = super().handle_get_game_setting_api_request(data)
         ret["gameSetting"]["romVersion"] = "2.05.00"
         ret["gameSetting"]["dataVersion"] = "2.05.00"
-        ret["gameSetting"]["matchingUri"] = f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/205/ChuniServlet/"
-        ret["gameSetting"]["matchingUriX"] = f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/205/ChuniServlet/"
-        ret["gameSetting"]["udpHolePunchUri"] = f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/205/ChuniServlet/"
-        ret["gameSetting"]["reflectorUri"] = f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/205/ChuniServlet/"
+        ret["gameSetting"][
+            "matchingUri"
+        ] = f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/205/ChuniServlet/"
+        ret["gameSetting"][
+            "matchingUriX"
+        ] = f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/205/ChuniServlet/"
+        ret["gameSetting"][
+            "udpHolePunchUri"
+        ] = f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/205/ChuniServlet/"
+        ret["gameSetting"][
+            "reflectorUri"
+        ] = f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/205/ChuniServlet/"
         return ret

titles/chuni/paradise.py

@@ -7,12 +7,13 @@ from titles.chuni.base import ChuniBase
 from titles.chuni.const import ChuniConstants
 from titles.chuni.config import ChuniConfig
 
+
 class ChuniParadise(ChuniBase):
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         super().__init__(core_cfg, game_cfg)
         self.version = ChuniConstants.VER_CHUNITHM_PARADISE
-    
+
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        ret =  super().handle_get_game_setting_api_request(data)
+        ret = super().handle_get_game_setting_api_request(data)
         ret["gameSetting"]["dataVersion"] = "1.50.00"
         return ret

titles/chuni/plus.py

@@ -5,12 +5,13 @@ from titles.chuni.base import ChuniBase
 from titles.chuni.const import ChuniConstants
 from titles.chuni.config import ChuniConfig
 
+
 class ChuniPlus(ChuniBase):
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         super().__init__(core_cfg, game_cfg)
         self.version = ChuniConstants.VER_CHUNITHM_PLUS
-    
+
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        ret =  super().handle_get_game_setting_api_request(data)
+        ret = super().handle_get_game_setting_api_request(data)
         ret["gameSetting"]["dataVersion"] = "1.05.00"
-        return ret
+        return ret

titles/chuni/read.py

@@ -7,48 +7,60 @@ from core.config import CoreConfig
 from titles.chuni.database import ChuniData
 from titles.chuni.const import ChuniConstants
 
+
 class ChuniReader(BaseReader):
-    def __init__(self, config: CoreConfig, version: int, bin_dir: Optional[str], opt_dir: Optional[str], extra: Optional[str]) -> None:
+    def __init__(
+        self,
+        config: CoreConfig,
+        version: int,
+        bin_dir: Optional[str],
+        opt_dir: Optional[str],
+        extra: Optional[str],
+    ) -> None:
         super().__init__(config, version, bin_dir, opt_dir, extra)
         self.data = ChuniData(config)
 
         try:
-            self.logger.info(f"Start importer for {ChuniConstants.game_ver_to_string(version)}")
+            self.logger.info(
+                f"Start importer for {ChuniConstants.game_ver_to_string(version)}"
+            )
         except IndexError:
             self.logger.error(f"Invalid chunithm version {version}")
             exit(1)
-        
+
     def read(self) -> None:
         data_dirs = []
         if self.bin_dir is not None:
             data_dirs += self.get_data_directories(self.bin_dir)
-        
+
         if self.opt_dir is not None:
-           data_dirs += self.get_data_directories(self.opt_dir)
-        
+            data_dirs += self.get_data_directories(self.opt_dir)
+
         for dir in data_dirs:
             self.logger.info(f"Read from {dir}")
             self.read_events(f"{dir}/event")
             self.read_music(f"{dir}/music")
             self.read_charges(f"{dir}/chargeItem")
             self.read_avatar(f"{dir}/avatarAccessory")
-                        
+
     def read_events(self, evt_dir: str) -> None:
         for root, dirs, files in walk(evt_dir):
             for dir in dirs:
                 if path.exists(f"{root}/{dir}/Event.xml"):
-                    with open(f"{root}/{dir}/Event.xml", 'rb') as fp:
+                    with open(f"{root}/{dir}/Event.xml", "rb") as fp:
                         bytedata = fp.read()
-                        strdata = bytedata.decode('UTF-8')
+                        strdata = bytedata.decode("UTF-8")
 
                     xml_root = ET.fromstring(strdata)
-                    for name in xml_root.findall('name'):
-                        id = name.find('id').text
-                        name = name.find('str').text
-                    for substances in xml_root.findall('substances'):
-                        event_type = substances.find('type').text
-                    
-                    result = self.data.static.put_event(self.version, id, event_type, name)
+                    for name in xml_root.findall("name"):
+                        id = name.find("id").text
+                        name = name.find("str").text
+                    for substances in xml_root.findall("substances"):
+                        event_type = substances.find("type").text
+
+                    result = self.data.static.put_event(
+                        self.version, id, event_type, name
+                    )
                     if result is not None:
                         self.logger.info(f"Inserted event {id}")
                     else:
@@ -58,73 +70,90 @@ class ChuniReader(BaseReader):
         for root, dirs, files in walk(music_dir):
             for dir in dirs:
                 if path.exists(f"{root}/{dir}/Music.xml"):
-                    with open(f"{root}/{dir}/Music.xml", 'rb') as fp:
+                    with open(f"{root}/{dir}/Music.xml", "rb") as fp:
                         bytedata = fp.read()
-                        strdata = bytedata.decode('UTF-8')
+                        strdata = bytedata.decode("UTF-8")
 
                     xml_root = ET.fromstring(strdata)
-                    for name in xml_root.findall('name'):
-                        song_id = name.find('id').text
-                        title = name.find('str').text
+                    for name in xml_root.findall("name"):
+                        song_id = name.find("id").text
+                        title = name.find("str").text
 
-                    for artistName in xml_root.findall('artistName'):
-                        artist = artistName.find('str').text
+                    for artistName in xml_root.findall("artistName"):
+                        artist = artistName.find("str").text
 
-                    for genreNames in xml_root.findall('genreNames'):
-                        for list_ in genreNames.findall('list'):
-                            for StringID in list_.findall('StringID'):
-                                genre = StringID.find('str').text
+                    for genreNames in xml_root.findall("genreNames"):
+                        for list_ in genreNames.findall("list"):
+                            for StringID in list_.findall("StringID"):
+                                genre = StringID.find("str").text
 
-                    for jaketFile in xml_root.findall('jaketFile'): #nice typo, SEGA
-                        jacket_path = jaketFile.find('path').text
+                    for jaketFile in xml_root.findall("jaketFile"):  # nice typo, SEGA
+                        jacket_path = jaketFile.find("path").text
+
+                    for fumens in xml_root.findall("fumens"):
+                        for MusicFumenData in fumens.findall("MusicFumenData"):
+                            fumen_path = MusicFumenData.find("file").find("path")
 
-                    for fumens in xml_root.findall('fumens'):
-                        for MusicFumenData in fumens.findall('MusicFumenData'):
-                            fumen_path = MusicFumenData.find('file').find("path")
-                            
                             if fumen_path is not None:
-                                chart_id = MusicFumenData.find('type').find('id').text
+                                chart_id = MusicFumenData.find("type").find("id").text
                                 if chart_id == "4":
                                     level = float(xml_root.find("starDifType").text)
-                                    we_chara = xml_root.find("worldsEndTagName").find("str").text
+                                    we_chara = (
+                                        xml_root.find("worldsEndTagName")
+                                        .find("str")
+                                        .text
+                                    )
                                 else:
-                                    level = float(f"{MusicFumenData.find('level').text}.{MusicFumenData.find('levelDecimal').text}")
+                                    level = float(
+                                        f"{MusicFumenData.find('level').text}.{MusicFumenData.find('levelDecimal').text}"
+                                    )
                                     we_chara = None
-                                
+
                                 result = self.data.static.put_music(
                                     self.version,
                                     song_id,
-                                    chart_id, 
+                                    chart_id,
                                     title,
                                     artist,
                                     level,
                                     genre,
                                     jacket_path,
-                                    we_chara
+                                    we_chara,
                                 )
 
                                 if result is not None:
-                                    self.logger.info(f"Inserted music {song_id} chart {chart_id}")
+                                    self.logger.info(
+                                        f"Inserted music {song_id} chart {chart_id}"
+                                    )
                                 else:
-                                    self.logger.warn(f"Failed to insert music {song_id} chart {chart_id}")
+                                    self.logger.warn(
+                                        f"Failed to insert music {song_id} chart {chart_id}"
+                                    )
 
     def read_charges(self, charge_dir: str) -> None:
         for root, dirs, files in walk(charge_dir):
             for dir in dirs:
                 if path.exists(f"{root}/{dir}/ChargeItem.xml"):
-                    with open(f"{root}/{dir}/ChargeItem.xml", 'rb') as fp:
+                    with open(f"{root}/{dir}/ChargeItem.xml", "rb") as fp:
                         bytedata = fp.read()
-                        strdata = bytedata.decode('UTF-8')
+                        strdata = bytedata.decode("UTF-8")
 
                     xml_root = ET.fromstring(strdata)
-                    for name in xml_root.findall('name'):
-                        id = name.find('id').text
-                        name = name.find('str').text
-                    expirationDays = xml_root.find('expirationDays').text
-                    consumeType = xml_root.find('consumeType').text
-                    sellingAppeal = bool(xml_root.find('sellingAppeal').text)
+                    for name in xml_root.findall("name"):
+                        id = name.find("id").text
+                        name = name.find("str").text
+                    expirationDays = xml_root.find("expirationDays").text
+                    consumeType = xml_root.find("consumeType").text
+                    sellingAppeal = bool(xml_root.find("sellingAppeal").text)
 
-                    result = self.data.static.put_charge(self.version, id, name, expirationDays, consumeType, sellingAppeal)
+                    result = self.data.static.put_charge(
+                        self.version,
+                        id,
+                        name,
+                        expirationDays,
+                        consumeType,
+                        sellingAppeal,
+                    )
 
                     if result is not None:
                         self.logger.info(f"Inserted charge {id}")
@@ -135,21 +164,23 @@ class ChuniReader(BaseReader):
         for root, dirs, files in walk(avatar_dir):
             for dir in dirs:
                 if path.exists(f"{root}/{dir}/AvatarAccessory.xml"):
-                    with open(f"{root}/{dir}/AvatarAccessory.xml", 'rb') as fp:
+                    with open(f"{root}/{dir}/AvatarAccessory.xml", "rb") as fp:
                         bytedata = fp.read()
-                        strdata = bytedata.decode('UTF-8')
+                        strdata = bytedata.decode("UTF-8")
 
                     xml_root = ET.fromstring(strdata)
-                    for name in xml_root.findall('name'):
-                        id = name.find('id').text
-                        name = name.find('str').text
-                    category = xml_root.find('category').text
-                    for image in xml_root.findall('image'):
-                        iconPath = image.find('path').text
-                    for texture in xml_root.findall('texture'):
-                        texturePath = texture.find('path').text
+                    for name in xml_root.findall("name"):
+                        id = name.find("id").text
+                        name = name.find("str").text
+                    category = xml_root.find("category").text
+                    for image in xml_root.findall("image"):
+                        iconPath = image.find("path").text
+                    for texture in xml_root.findall("texture"):
+                        texturePath = texture.find("path").text
 
-                    result = self.data.static.put_avatar(self.version, id, name, category, iconPath, texturePath)
+                    result = self.data.static.put_avatar(
+                        self.version, id, name, category, iconPath, texturePath
+                    )
 
                     if result is not None:
                         self.logger.info(f"Inserted avatarAccessory {id}")

titles/chuni/schema/__init__.py

@@ -3,4 +3,4 @@ from titles.chuni.schema.score import ChuniScoreData
 from titles.chuni.schema.item import ChuniItemData
 from titles.chuni.schema.static import ChuniStaticData
 
-__all__ = ["ChuniProfileData", "ChuniScoreData", "ChuniItemData", "ChuniStaticData"]
+__all__ = ["ChuniProfileData", "ChuniScoreData", "ChuniItemData", "ChuniStaticData"]

titles/chuni/schema/item.py

@@ -13,7 +13,11 @@ character = Table(
     "chuni_item_character",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("characterId", Integer),
     Column("level", Integer),
     Column("param1", Integer),
@@ -26,27 +30,35 @@ character = Table(
     Column("assignIllust", Integer),
     Column("exMaxLv", Integer),
     UniqueConstraint("user", "characterId", name="chuni_item_character_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 item = Table(
     "chuni_item_item",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("itemId", Integer),
     Column("itemKind", Integer),
     Column("stock", Integer),
     Column("isValid", Boolean),
     UniqueConstraint("user", "itemId", "itemKind", name="chuni_item_item_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 duel = Table(
     "chuni_item_duel",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("duelId", Integer),
     Column("progress", Integer),
     Column("point", Integer),
@@ -57,14 +69,18 @@ duel = Table(
     Column("param3", Integer),
     Column("param4", Integer),
     UniqueConstraint("user", "duelId", name="chuni_item_duel_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 map = Table(
     "chuni_item_map",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("mapId", Integer),
     Column("position", Integer),
     Column("isClear", Boolean),
@@ -72,17 +88,21 @@ map = Table(
     Column("routeNumber", Integer),
     Column("eventId", Integer),
     Column("rate", Integer),
-    Column("statusCount", Integer),    
+    Column("statusCount", Integer),
     Column("isValid", Boolean),
     UniqueConstraint("user", "mapId", name="chuni_item_map_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 map_area = Table(
     "chuni_item_map_area",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("mapAreaId", Integer),
     Column("rate", Integer),
     Column("isClear", Boolean),
@@ -91,9 +111,10 @@ map_area = Table(
     Column("statusCount", Integer),
     Column("remainGridCount", Integer),
     UniqueConstraint("user", "mapAreaId", name="chuni_item_map_area_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
+
 class ChuniItemData(BaseData):
     def put_character(self, user_id: int, character_data: Dict) -> Optional[int]:
         character_data["user"] = user_id
@@ -104,24 +125,26 @@ class ChuniItemData(BaseData):
         conflict = sql.on_duplicate_key_update(**character_data)
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
 
     def get_character(self, user_id: int, character_id: int) -> Optional[Dict]:
-        sql = select(character).where(and_(
-            character.c.user == user_id,
-            character.c.characterId == character_id
-        ))
-        
+        sql = select(character).where(
+            and_(character.c.user == user_id, character.c.characterId == character_id)
+        )
+
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchone()
-    
+
     def get_characters(self, user_id: int) -> Optional[List[Row]]:
         sql = select(character).where(character.c.user == user_id)
-        
+
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
 
     def put_item(self, user_id: int, item_data: Dict) -> Optional[int]:
@@ -133,22 +156,23 @@ class ChuniItemData(BaseData):
         conflict = sql.on_duplicate_key_update(**item_data)
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
 
     def get_items(self, user_id: int, kind: int = None) -> Optional[List[Row]]:
         if kind is None:
             sql = select(item).where(item.c.user == user_id)
         else:
-            sql = select(item).where(and_(
-                item.c.user == user_id,
-                item.c.itemKind == kind
-            ))
-        
+            sql = select(item).where(
+                and_(item.c.user == user_id, item.c.itemKind == kind)
+            )
+
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
-    
+
     def put_duel(self, user_id: int, duel_data: Dict) -> Optional[int]:
         duel_data["user"] = user_id
 
@@ -158,14 +182,16 @@ class ChuniItemData(BaseData):
         conflict = sql.on_duplicate_key_update(**duel_data)
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
 
     def get_duels(self, user_id: int) -> Optional[List[Row]]:
         sql = select(duel).where(duel.c.user == user_id)
-        
+
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
 
     def put_map(self, user_id: int, map_data: Dict) -> Optional[int]:
@@ -177,16 +203,18 @@ class ChuniItemData(BaseData):
         conflict = sql.on_duplicate_key_update(**map_data)
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
 
     def get_maps(self, user_id: int) -> Optional[List[Row]]:
         sql = select(map).where(map.c.user == user_id)
-        
+
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
-    
+
     def put_map_area(self, user_id: int, map_area_data: Dict) -> Optional[int]:
         map_area_data["user"] = user_id
 
@@ -196,12 +224,14 @@ class ChuniItemData(BaseData):
         conflict = sql.on_duplicate_key_update(**map_area_data)
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
-    
+
     def get_map_areas(self, user_id: int) -> Optional[List[Row]]:
         sql = select(map_area).where(map_area.c.user == user_id)
-        
+
         result = self.execute(sql)
-        if result is None: return None
-        return result.fetchall()
+        if result is None:
+            return None
+        return result.fetchall()

titles/chuni/schema/profile.py

@@ -13,7 +13,11 @@ profile = Table(
     "chuni_profile_data",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("version", Integer, nullable=False),
     Column("exp", Integer),
     Column("level", Integer),
@@ -62,7 +66,7 @@ profile = Table(
     Column("firstTutorialCancelNum", Integer),
     Column("totalAdvancedHighScore", Integer),
     Column("masterTutorialCancelNum", Integer),
-    Column("ext1", Integer), # Added in chunew
+    Column("ext1", Integer),  # Added in chunew
     Column("ext2", Integer),
     Column("ext3", Integer),
     Column("ext4", Integer),
@@ -71,16 +75,20 @@ profile = Table(
     Column("ext7", Integer),
     Column("ext8", Integer),
     Column("ext9", Integer),
-    Column("ext10", Integer),    
+    Column("ext10", Integer),
     Column("extStr1", String(255)),
     Column("extStr2", String(255)),
     Column("extLong1", Integer),
     Column("extLong2", Integer),
     Column("mapIconId", Integer),
     Column("compatibleCmVersion", String(25)),
-    Column("medal", Integer),    
+    Column("medal", Integer),
     Column("voiceId", Integer),
-    Column("teamId", Integer, ForeignKey("chuni_profile_team.id", ondelete="SET NULL", onupdate="SET NULL")),
+    Column(
+        "teamId",
+        Integer,
+        ForeignKey("chuni_profile_team.id", ondelete="SET NULL", onupdate="SET NULL"),
+    ),
     Column("avatarBack", Integer, server_default="0"),
     Column("avatarFace", Integer, server_default="0"),
     Column("eliteRankPoint", Integer, server_default="0"),
@@ -121,14 +129,18 @@ profile = Table(
     Column("netBattleEndState", Integer, server_default="0"),
     Column("avatarHead", Integer, server_default="0"),
     UniqueConstraint("user", "version", name="chuni_profile_profile_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 profile_ex = Table(
     "chuni_profile_data_ex",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("version", Integer, nullable=False),
     Column("ext1", Integer),
     Column("ext2", Integer),
@@ -165,14 +177,18 @@ profile_ex = Table(
     Column("mapIconId", Integer),
     Column("compatibleCmVersion", String(25)),
     UniqueConstraint("user", "version", name="chuni_profile_data_ex_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 option = Table(
     "chuni_profile_option",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("speed", Integer),
     Column("bgInfo", Integer),
     Column("rating", Integer),
@@ -195,7 +211,7 @@ option = Table(
     Column("successSkill", Integer),
     Column("successSlideHold", Integer),
     Column("successTapTimbre", Integer),
-    Column("ext1", Integer), # Added in chunew
+    Column("ext1", Integer),  # Added in chunew
     Column("ext2", Integer),
     Column("ext3", Integer),
     Column("ext4", Integer),
@@ -224,14 +240,18 @@ option = Table(
     Column("playTimingOffset", Integer, server_default="0"),
     Column("fieldWallPosition_120", Integer, server_default="0"),
     UniqueConstraint("user", name="chuni_profile_option_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 option_ex = Table(
     "chuni_profile_option_ex",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("ext1", Integer),
     Column("ext2", Integer),
     Column("ext3", Integer),
@@ -253,51 +273,69 @@ option_ex = Table(
     Column("ext19", Integer),
     Column("ext20", Integer),
     UniqueConstraint("user", name="chuni_profile_option_ex_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 recent_rating = Table(
     "chuni_profile_recent_rating",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("recentRating", JSON),
     UniqueConstraint("user", name="chuni_profile_recent_rating_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 region = Table(
     "chuni_profile_region",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("regionId", Integer),
     Column("playCount", Integer),
     UniqueConstraint("user", "regionId", name="chuni_profile_region_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 activity = Table(
     "chuni_profile_activity",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("kind", Integer),
-    Column("activityId", Integer), # Reminder: Change this to ID in base.py or the game will be sad
+    Column(
+        "activityId", Integer
+    ),  # Reminder: Change this to ID in base.py or the game will be sad
     Column("sortNumber", Integer),
     Column("param1", Integer),
     Column("param2", Integer),
     Column("param3", Integer),
     Column("param4", Integer),
     UniqueConstraint("user", "kind", "activityId", name="chuni_profile_activity_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 charge = Table(
     "chuni_profile_charge",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("chargeId", Integer),
     Column("stock", Integer),
     Column("purchaseDate", String(25)),
@@ -306,14 +344,18 @@ charge = Table(
     Column("param2", Integer),
     Column("paramDate", String(25)),
     UniqueConstraint("user", "chargeId", name="chuni_profile_charge_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 emoney = Table(
     "chuni_profile_emoney",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("ext1", Integer),
     Column("ext2", Integer),
     Column("ext3", Integer),
@@ -321,20 +363,24 @@ emoney = Table(
     Column("emoneyBrand", Integer),
     Column("emoneyCredit", Integer),
     UniqueConstraint("user", "emoneyBrand", name="chuni_profile_emoney_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 overpower = Table(
     "chuni_profile_overpower",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("genreId", Integer),
     Column("difficulty", Integer),
     Column("rate", Integer),
     Column("point", Integer),
     UniqueConstraint("user", "genreId", "difficulty", name="chuni_profile_emoney_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 team = Table(
@@ -343,18 +389,21 @@ team = Table(
     Column("id", Integer, primary_key=True, nullable=False),
     Column("teamName", String(255)),
     Column("teamPoint", Integer),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
+
 class ChuniProfileData(BaseData):
-    def put_profile_data(self, aime_id: int, version: int, profile_data: Dict) -> Optional[int]:
+    def put_profile_data(
+        self, aime_id: int, version: int, profile_data: Dict
+    ) -> Optional[int]:
         profile_data["user"] = aime_id
         profile_data["version"] = version
         if "accessCode" in profile_data:
             profile_data.pop("accessCode")
-        
+
         profile_data = self.fix_bools(profile_data)
-        
+
         sql = insert(profile).values(**profile_data)
         conflict = sql.on_duplicate_key_update(**profile_data)
         result = self.execute(conflict)
@@ -363,51 +412,64 @@ class ChuniProfileData(BaseData):
             self.logger.warn(f"put_profile_data: Failed to update! aime_id: {aime_id}")
             return None
         return result.lastrowid
-        
+
     def get_profile_preview(self, aime_id: int, version: int) -> Optional[Row]:
-        sql = select([profile, option]).join(option, profile.c.user == option.c.user).filter(
-            and_(profile.c.user == aime_id, profile.c.version == version)
+        sql = (
+            select([profile, option])
+            .join(option, profile.c.user == option.c.user)
+            .filter(and_(profile.c.user == aime_id, profile.c.version == version))
         )
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchone()
 
     def get_profile_data(self, aime_id: int, version: int) -> Optional[Row]:
-        sql = select(profile).where(and_(
-            profile.c.user == aime_id,
-            profile.c.version == version,
-        ))
+        sql = select(profile).where(
+            and_(
+                profile.c.user == aime_id,
+                profile.c.version == version,
+            )
+        )
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchone()
-    
-    def put_profile_data_ex(self, aime_id: int, version: int, profile_ex_data: Dict) -> Optional[int]:
+
+    def put_profile_data_ex(
+        self, aime_id: int, version: int, profile_ex_data: Dict
+    ) -> Optional[int]:
         profile_ex_data["user"] = aime_id
         profile_ex_data["version"] = version
         if "accessCode" in profile_ex_data:
             profile_ex_data.pop("accessCode")
-        
+
         sql = insert(profile_ex).values(**profile_ex_data)
         conflict = sql.on_duplicate_key_update(**profile_ex_data)
         result = self.execute(conflict)
 
         if result is None:
-            self.logger.warn(f"put_profile_data_ex: Failed to update! aime_id: {aime_id}")
+            self.logger.warn(
+                f"put_profile_data_ex: Failed to update! aime_id: {aime_id}"
+            )
             return None
         return result.lastrowid
-    
+
     def get_profile_data_ex(self, aime_id: int, version: int) -> Optional[Row]:
-        sql = select(profile_ex).where(and_(
-            profile_ex.c.user == aime_id,
-            profile_ex.c.version == version,
-        ))
+        sql = select(profile_ex).where(
+            and_(
+                profile_ex.c.user == aime_id,
+                profile_ex.c.version == version,
+            )
+        )
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchone()
-    
+
     def put_profile_option(self, aime_id: int, option_data: Dict) -> Optional[int]:
         option_data["user"] = aime_id
 
@@ -416,7 +478,9 @@ class ChuniProfileData(BaseData):
         result = self.execute(conflict)
 
         if result is None:
-            self.logger.warn(f"put_profile_option: Failed to update! aime_id: {aime_id}")
+            self.logger.warn(
+                f"put_profile_option: Failed to update! aime_id: {aime_id}"
+            )
             return None
         return result.lastrowid
 
@@ -424,18 +488,23 @@ class ChuniProfileData(BaseData):
         sql = select(option).where(option.c.user == aime_id)
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchone()
-    
-    def put_profile_option_ex(self, aime_id: int, option_ex_data: Dict) -> Optional[int]:
+
+    def put_profile_option_ex(
+        self, aime_id: int, option_ex_data: Dict
+    ) -> Optional[int]:
         option_ex_data["user"] = aime_id
-        
+
         sql = insert(option_ex).values(**option_ex_data)
         conflict = sql.on_duplicate_key_update(**option_ex_data)
         result = self.execute(conflict)
 
         if result is None:
-            self.logger.warn(f"put_profile_option_ex: Failed to update! aime_id: {aime_id}")
+            self.logger.warn(
+                f"put_profile_option_ex: Failed to update! aime_id: {aime_id}"
+            )
             return None
         return result.lastrowid
 
@@ -443,27 +512,32 @@ class ChuniProfileData(BaseData):
         sql = select(option_ex).where(option_ex.c.user == aime_id)
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchone()
 
-    def put_profile_recent_rating(self, aime_id: int, recent_rating_data: List[Dict]) -> Optional[int]:
+    def put_profile_recent_rating(
+        self, aime_id: int, recent_rating_data: List[Dict]
+    ) -> Optional[int]:
         sql = insert(recent_rating).values(
-            user = aime_id,
-            recentRating = recent_rating_data
+            user=aime_id, recentRating=recent_rating_data
         )
-        conflict = sql.on_duplicate_key_update(recentRating = recent_rating_data)
+        conflict = sql.on_duplicate_key_update(recentRating=recent_rating_data)
 
         result = self.execute(conflict)
         if result is None:
-            self.logger.warn(f"put_profile_recent_rating: Failed to update! aime_id: {aime_id}")
+            self.logger.warn(
+                f"put_profile_recent_rating: Failed to update! aime_id: {aime_id}"
+            )
             return None
         return result.lastrowid
-    
+
     def get_profile_recent_rating(self, aime_id: int) -> Optional[Row]:
         sql = select(recent_rating).where(recent_rating.c.user == aime_id)
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchone()
 
     def put_profile_activity(self, aime_id: int, activity_data: Dict) -> Optional[int]:
@@ -471,35 +545,39 @@ class ChuniProfileData(BaseData):
         activity_data["user"] = aime_id
         activity_data["activityId"] = activity_data["id"]
         activity_data.pop("id")
-        
+
         sql = insert(activity).values(**activity_data)
         conflict = sql.on_duplicate_key_update(**activity_data)
         result = self.execute(conflict)
 
         if result is None:
-            self.logger.warn(f"put_profile_activity: Failed to update! aime_id: {aime_id}")
+            self.logger.warn(
+                f"put_profile_activity: Failed to update! aime_id: {aime_id}"
+            )
             return None
         return result.lastrowid
 
     def get_profile_activity(self, aime_id: int, kind: int) -> Optional[List[Row]]:
-        sql = select(activity).where(and_(
-            activity.c.user == aime_id,
-            activity.c.kind == kind
-        ))
+        sql = select(activity).where(
+            and_(activity.c.user == aime_id, activity.c.kind == kind)
+        )
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
 
     def put_profile_charge(self, aime_id: int, charge_data: Dict) -> Optional[int]:
         charge_data["user"] = aime_id
-        
+
         sql = insert(charge).values(**charge_data)
         conflict = sql.on_duplicate_key_update(**charge_data)
         result = self.execute(conflict)
 
         if result is None:
-            self.logger.warn(f"put_profile_charge: Failed to update! aime_id: {aime_id}")
+            self.logger.warn(
+                f"put_profile_charge: Failed to update! aime_id: {aime_id}"
+            )
             return None
         return result.lastrowid
 
@@ -507,9 +585,10 @@ class ChuniProfileData(BaseData):
         sql = select(charge).where(charge.c.user == aime_id)
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
-    
+
     def add_profile_region(self, aime_id: int, region_id: int) -> Optional[int]:
         pass
 
@@ -523,29 +602,35 @@ class ChuniProfileData(BaseData):
         conflict = sql.on_duplicate_key_update(**emoney_data)
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
-    
+
     def get_profile_emoney(self, aime_id: int) -> Optional[List[Row]]:
         sql = select(emoney).where(emoney.c.user == aime_id)
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
 
-    def put_profile_overpower(self, aime_id: int, overpower_data: Dict) -> Optional[int]:
+    def put_profile_overpower(
+        self, aime_id: int, overpower_data: Dict
+    ) -> Optional[int]:
         overpower_data["user"] = aime_id
 
         sql = insert(overpower).values(**overpower_data)
         conflict = sql.on_duplicate_key_update(**overpower_data)
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
-    
+
     def get_profile_overpower(self, aime_id: int) -> Optional[List[Row]]:
         sql = select(overpower).where(overpower.c.user == aime_id)
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()

titles/chuni/schema/score.py

@@ -13,7 +13,11 @@ course = Table(
     "chuni_score_course",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("courseId", Integer),
     Column("classId", Integer),
     Column("playCount", Integer),
@@ -33,14 +37,18 @@ course = Table(
     Column("orderId", Integer),
     Column("playerRating", Integer),
     UniqueConstraint("user", "courseId", name="chuni_score_course_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 best_score = Table(
     "chuni_score_best",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("musicId", Integer),
     Column("level", Integer),
     Column("playCount", Integer),
@@ -60,14 +68,18 @@ best_score = Table(
     Column("ext1", Integer),
     Column("theoryCount", Integer),
     UniqueConstraint("user", "musicId", "level", name="chuni_score_best_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 playlog = Table(
     "chuni_score_playlog",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("orderId", Integer),
     Column("sortNumber", Integer),
     Column("placeId", Integer),
@@ -122,15 +134,17 @@ playlog = Table(
     Column("charaIllustId", Integer),
     Column("romVersion", String(255)),
     Column("judgeHeaven", Integer),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
+
 class ChuniScoreData(BaseData):
     def get_courses(self, aime_id: int) -> Optional[Row]:
         sql = select(course).where(course.c.user == aime_id)
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
 
     def put_course(self, aime_id: int, course_data: Dict) -> Optional[int]:
@@ -141,16 +155,18 @@ class ChuniScoreData(BaseData):
         conflict = sql.on_duplicate_key_update(**course_data)
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
-    
+
     def get_scores(self, aime_id: int) -> Optional[Row]:
         sql = select(best_score).where(best_score.c.user == aime_id)
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
-    
+
     def put_score(self, aime_id: int, score_data: Dict) -> Optional[int]:
         score_data["user"] = aime_id
         score_data = self.fix_bools(score_data)
@@ -159,16 +175,18 @@ class ChuniScoreData(BaseData):
         conflict = sql.on_duplicate_key_update(**score_data)
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
 
     def get_playlogs(self, aime_id: int) -> Optional[Row]:
         sql = select(playlog).where(playlog.c.user == aime_id)
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
-    
+
     def put_playlog(self, aime_id: int, playlog_data: Dict) -> Optional[int]:
         playlog_data["user"] = aime_id
         playlog_data = self.fix_bools(playlog_data)
@@ -177,5 +195,6 @@ class ChuniScoreData(BaseData):
         conflict = sql.on_duplicate_key_update(**playlog_data)
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid

titles/chuni/schema/static.py

@@ -19,7 +19,7 @@ events = Table(
     Column("name", String(255)),
     Column("enabled", Boolean, server_default="1"),
     UniqueConstraint("version", "eventId", name="chuni_static_events_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 music = Table(
@@ -30,13 +30,13 @@ music = Table(
     Column("songId", Integer),
     Column("chartId", Integer),
     Column("title", String(255)),
-    Column("artist", String(255)),    
+    Column("artist", String(255)),
     Column("level", Float),
     Column("genre", String(255)),
     Column("jacketPath", String(255)),
     Column("worldsEndTag", String(7)),
     UniqueConstraint("version", "songId", "chartId", name="chuni_static_music_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 charge = Table(
@@ -51,7 +51,7 @@ charge = Table(
     Column("sellingAppeal", Boolean),
     Column("enabled", Boolean, server_default="1"),
     UniqueConstraint("version", "chargeId", name="chuni_static_charge_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 avatar = Table(
@@ -65,159 +65,203 @@ avatar = Table(
     Column("iconPath", String(255)),
     Column("texturePath", String(255)),
     UniqueConstraint("version", "avatarAccessoryId", name="chuni_static_avatar_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
+
 class ChuniStaticData(BaseData):
-    def put_event(self, version: int, event_id: int, type: int, name: str) -> Optional[int]:
+    def put_event(
+        self, version: int, event_id: int, type: int, name: str
+    ) -> Optional[int]:
         sql = insert(events).values(
-            version = version,
-            eventId = event_id,
-            type = type,
-            name = name
+            version=version, eventId=event_id, type=type, name=name
         )
 
-        conflict = sql.on_duplicate_key_update(
-            name = name
-        )
+        conflict = sql.on_duplicate_key_update(name=name)
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
-    
-    def update_event(self, version: int, event_id: int, enabled: bool) -> Optional[bool]:
-        sql = events.update(and_(events.c.version == version, events.c.eventId == event_id)).values(
-            enabled = enabled
-        )
+
+    def update_event(
+        self, version: int, event_id: int, enabled: bool
+    ) -> Optional[bool]:
+        sql = events.update(
+            and_(events.c.version == version, events.c.eventId == event_id)
+        ).values(enabled=enabled)
 
         result = self.execute(sql)
-        if result is None: 
-            self.logger.warn(f"update_event: failed to update event! version: {version}, event_id: {event_id}, enabled: {enabled}")
+        if result is None:
+            self.logger.warn(
+                f"update_event: failed to update event! version: {version}, event_id: {event_id}, enabled: {enabled}"
+            )
             return None
 
         event = self.get_event(version, event_id)
         if event is None:
-            self.logger.warn(f"update_event: failed to fetch event {event_id} after updating")
+            self.logger.warn(
+                f"update_event: failed to fetch event {event_id} after updating"
+            )
             return None
         return event["enabled"]
 
     def get_event(self, version: int, event_id: int) -> Optional[Row]:
-        sql = select(events).where(and_(events.c.version == version, events.c.eventId == event_id))
-        
+        sql = select(events).where(
+            and_(events.c.version == version, events.c.eventId == event_id)
+        )
+
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchone()
 
     def get_enabled_events(self, version: int) -> Optional[List[Row]]:
-        sql = select(events).where(and_(events.c.version == version, events.c.enabled == True))
+        sql = select(events).where(
+            and_(events.c.version == version, events.c.enabled == True)
+        )
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
 
     def get_events(self, version: int) -> Optional[List[Row]]:
         sql = select(events).where(events.c.version == version)
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
-    
-    def put_music(self, version: int, song_id: int, chart_id: int, title: int, artist: str, 
-        level: float, genre: str, jacketPath: str, we_tag: str) -> Optional[int]:
 
+    def put_music(
+        self,
+        version: int,
+        song_id: int,
+        chart_id: int,
+        title: int,
+        artist: str,
+        level: float,
+        genre: str,
+        jacketPath: str,
+        we_tag: str,
+    ) -> Optional[int]:
         sql = insert(music).values(
-            version = version,
-            songId = song_id,
-            chartId = chart_id,
-            title = title,
-            artist = artist,
-            level = level,
-            genre = genre,
-            jacketPath = jacketPath,
-            worldsEndTag = we_tag,
+            version=version,
+            songId=song_id,
+            chartId=chart_id,
+            title=title,
+            artist=artist,
+            level=level,
+            genre=genre,
+            jacketPath=jacketPath,
+            worldsEndTag=we_tag,
         )
 
         conflict = sql.on_duplicate_key_update(
-            title = title,
-            artist = artist,
-            level = level,
-            genre = genre,
-            jacketPath = jacketPath,
-            worldsEndTag = we_tag,
+            title=title,
+            artist=artist,
+            level=level,
+            genre=genre,
+            jacketPath=jacketPath,
+            worldsEndTag=we_tag,
         )
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
-    
-    def put_charge(self, version: int, charge_id: int, name: str, expiration_days: int, 
-        consume_type: int, selling_appeal: bool) -> Optional[int]:
+
+    def put_charge(
+        self,
+        version: int,
+        charge_id: int,
+        name: str,
+        expiration_days: int,
+        consume_type: int,
+        selling_appeal: bool,
+    ) -> Optional[int]:
         sql = insert(charge).values(
-            version = version,
-            chargeId = charge_id,
-            name = name,
-            expirationDays = expiration_days,
-            consumeType = consume_type,
-            sellingAppeal = selling_appeal,
+            version=version,
+            chargeId=charge_id,
+            name=name,
+            expirationDays=expiration_days,
+            consumeType=consume_type,
+            sellingAppeal=selling_appeal,
         )
 
         conflict = sql.on_duplicate_key_update(
-            name = name,
-            expirationDays = expiration_days,
-            consumeType = consume_type,
-            sellingAppeal = selling_appeal,
+            name=name,
+            expirationDays=expiration_days,
+            consumeType=consume_type,
+            sellingAppeal=selling_appeal,
         )
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
-    
+
     def get_enabled_charges(self, version: int) -> Optional[List[Row]]:
-        sql = select(charge).where(and_(
-            charge.c.version == version,
-            charge.c.enabled == True
-        ))
+        sql = select(charge).where(
+            and_(charge.c.version == version, charge.c.enabled == True)
+        )
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
-    
+
     def get_charges(self, version: int) -> Optional[List[Row]]:
         sql = select(charge).where(charge.c.version == version)
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
 
-    def get_music_chart(self, version: int, song_id: int, chart_id: int) -> Optional[List[Row]]:
-        sql = select(music).where(and_(
-            music.c.version == version,
-            music.c.songId == song_id,
-            music.c.chartId == chart_id
-            ))
+    def get_music_chart(
+        self, version: int, song_id: int, chart_id: int
+    ) -> Optional[List[Row]]:
+        sql = select(music).where(
+            and_(
+                music.c.version == version,
+                music.c.songId == song_id,
+                music.c.chartId == chart_id,
+            )
+        )
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchone()
 
-    def put_avatar(self, version: int, avatarAccessoryId: int, name: str, category: int, iconPath: str, texturePath: str) -> Optional[int]:
+    def put_avatar(
+        self,
+        version: int,
+        avatarAccessoryId: int,
+        name: str,
+        category: int,
+        iconPath: str,
+        texturePath: str,
+    ) -> Optional[int]:
         sql = insert(avatar).values(
-            version = version,
-            avatarAccessoryId = avatarAccessoryId,
-            name = name,
-            category = category,
-            iconPath = iconPath,
-            texturePath = texturePath,
+            version=version,
+            avatarAccessoryId=avatarAccessoryId,
+            name=name,
+            category=category,
+            iconPath=iconPath,
+            texturePath=texturePath,
         )
 
         conflict = sql.on_duplicate_key_update(
-            name = name,
-            category = category,
-            iconPath = iconPath,
-            texturePath = texturePath,
+            name=name,
+            category=category,
+            iconPath=iconPath,
+            texturePath=texturePath,
         )
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
-    

titles/chuni/star.py

@@ -5,12 +5,13 @@ from titles.chuni.base import ChuniBase
 from titles.chuni.const import ChuniConstants
 from titles.chuni.config import ChuniConfig
 
+
 class ChuniStar(ChuniBase):
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         super().__init__(core_cfg, game_cfg)
         self.version = ChuniConstants.VER_CHUNITHM_STAR
-    
+
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        ret =  super().handle_get_game_setting_api_request(data)
+        ret = super().handle_get_game_setting_api_request(data)
         ret["gameSetting"]["dataVersion"] = "1.20.00"
-        return ret
+        return ret

titles/chuni/starplus.py

@@ -5,12 +5,13 @@ from titles.chuni.base import ChuniBase
 from titles.chuni.const import ChuniConstants
 from titles.chuni.config import ChuniConfig
 
+
 class ChuniStarPlus(ChuniBase):
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         super().__init__(core_cfg, game_cfg)
         self.version = ChuniConstants.VER_CHUNITHM_STAR_PLUS
-    
+
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        ret =  super().handle_get_game_setting_api_request(data)
+        ret = super().handle_get_game_setting_api_request(data)
         ret["gameSetting"]["dataVersion"] = "1.25.00"
-        return ret
+        return ret

titles/cm/base.py

@@ -10,12 +10,14 @@ from titles.cm.const import CardMakerConstants
 from titles.cm.config import CardMakerConfig
 
 
-class CardMakerBase():
+class CardMakerBase:
     def __init__(self, core_cfg: CoreConfig, game_cfg: CardMakerConfig) -> None:
         self.core_cfg = core_cfg
         self.game_cfg = game_cfg
         self.date_time_format = "%Y-%m-%d %H:%M:%S"
-        self.date_time_format_ext = "%Y-%m-%d %H:%M:%S.%f"  # needs to be lopped off at [:-5]
+        self.date_time_format_ext = (
+            "%Y-%m-%d %H:%M:%S.%f"  # needs to be lopped off at [:-5]
+        )
         self.date_time_format_short = "%Y-%m-%d"
         self.logger = logging.getLogger("cardmaker")
         self.game = CardMakerConstants.GAME_CODE
@@ -31,27 +33,19 @@ class CardMakerBase():
         return {
             "length": 3,
             "gameConnectList": [
-                {
-                    "modelKind": 0,
-                    "type": 1,
-                    "titleUri": f"{uri}/SDHD/200/"
-                },
-                {
-                    "modelKind": 1,
-                    "type": 1,
-                    "titleUri": f"{uri}/SDEZ/120/"
-                },
-                {
-                    "modelKind": 2,
-                    "type": 1,
-                    "titleUri": f"{uri}/SDDT/130/"
-                }
-            ]
+                {"modelKind": 0, "type": 1, "titleUri": f"{uri}/SDHD/200/"},
+                {"modelKind": 1, "type": 1, "titleUri": f"{uri}/SDEZ/120/"},
+                {"modelKind": 2, "type": 1, "titleUri": f"{uri}/SDDT/130/"},
+            ],
         }
 
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        reboot_start = date.strftime(datetime.now() + timedelta(hours=3), self.date_time_format)
-        reboot_end = date.strftime(datetime.now() + timedelta(hours=4), self.date_time_format)
+        reboot_start = date.strftime(
+            datetime.now() + timedelta(hours=3), self.date_time_format
+        )
+        reboot_end = date.strftime(
+            datetime.now() + timedelta(hours=4), self.date_time_format
+        )
 
         return {
             "gameSetting": {
@@ -67,18 +61,14 @@ class CardMakerBase():
                 "maxCountCard": 100,
                 "watermark": False,
                 "isMaintenance": False,
-                "isBackgroundDistribute": False
+                "isBackgroundDistribute": False,
             },
             "isDumpUpload": False,
-            "isAou": False
+            "isAou": False,
         }
 
     def handle_get_client_bookkeeping_api_request(self, data: Dict) -> Dict:
-        return {
-            "placeId": data["placeId"],
-            "length": 0,
-            "clientBookkeepingList": []
-        }
+        return {"placeId": data["placeId"], "length": 0, "clientBookkeepingList": []}
 
     def handle_upsert_client_setting_api_request(self, data: Dict) -> Dict:
         return {"returnCode": 1, "apiName": "UpsertClientSettingApi"}

titles/cm/cm136.py

@@ -22,7 +22,7 @@ class CardMaker136(CardMakerBase):
             uri = f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}"
         else:
             uri = f"http://{self.core_cfg.title.hostname}"
-        
+
         ret["gameConnectList"][0]["titleUri"] = f"{uri}/SDHD/205/"
         ret["gameConnectList"][1]["titleUri"] = f"{uri}/SDEZ/125/"
         ret["gameConnectList"][2]["titleUri"] = f"{uri}/SDDT/135/"

titles/cm/config.py

@@ -1,17 +1,23 @@
 from core.config import CoreConfig
 
 
-class CardMakerServerConfig():
+class CardMakerServerConfig:
     def __init__(self, parent_config: "CardMakerConfig") -> None:
         self.__config = parent_config
 
     @property
     def enable(self) -> bool:
-        return CoreConfig.get_config_field(self.__config, 'cardmaker', 'server', 'enable', default=True)
+        return CoreConfig.get_config_field(
+            self.__config, "cardmaker", "server", "enable", default=True
+        )
 
     @property
     def loglevel(self) -> int:
-        return CoreConfig.str_to_loglevel(CoreConfig.get_config_field(self.__config, 'cardmaker', 'server', 'loglevel', default="info"))
+        return CoreConfig.str_to_loglevel(
+            CoreConfig.get_config_field(
+                self.__config, "cardmaker", "server", "loglevel", default="info"
+            )
+        )
 
 
 class CardMakerConfig(dict):

titles/cm/const.py

@@ -1,4 +1,4 @@
-class CardMakerConstants():
+class CardMakerConstants:
     GAME_CODE = "SDED"
 
     CONFIG_NAME = "cardmaker.yaml"

titles/cm/index.py

@@ -18,23 +18,29 @@ from titles.cm.base import CardMakerBase
 from titles.cm.cm136 import CardMaker136
 
 
-class CardMakerServlet():
+class CardMakerServlet:
     def __init__(self, core_cfg: CoreConfig, cfg_dir: str) -> None:
         self.core_cfg = core_cfg
         self.game_cfg = CardMakerConfig()
         if path.exists(f"{cfg_dir}/{CardMakerConstants.CONFIG_NAME}"):
-            self.game_cfg.update(yaml.safe_load(open(f"{cfg_dir}/{CardMakerConstants.CONFIG_NAME}")))
+            self.game_cfg.update(
+                yaml.safe_load(open(f"{cfg_dir}/{CardMakerConstants.CONFIG_NAME}"))
+            )
 
         self.versions = [
             CardMakerBase(core_cfg, self.game_cfg),
-            CardMaker136(core_cfg, self.game_cfg)
+            CardMaker136(core_cfg, self.game_cfg),
         ]
 
         self.logger = logging.getLogger("cardmaker")
         log_fmt_str = "[%(asctime)s] Card Maker | %(levelname)s | %(message)s"
         log_fmt = logging.Formatter(log_fmt_str)
-        fileHandler = TimedRotatingFileHandler("{0}/{1}.log".format(self.core_cfg.server.log_dir, "cardmaker"), encoding='utf8',
-                                               when="d", backupCount=10)
+        fileHandler = TimedRotatingFileHandler(
+            "{0}/{1}.log".format(self.core_cfg.server.log_dir, "cardmaker"),
+            encoding="utf8",
+            when="d",
+            backupCount=10,
+        )
 
         fileHandler.setFormatter(log_fmt)
 
@@ -45,20 +51,29 @@ class CardMakerServlet():
         self.logger.addHandler(consoleHandler)
 
         self.logger.setLevel(self.game_cfg.server.loglevel)
-        coloredlogs.install(level=self.game_cfg.server.loglevel,
-                            logger=self.logger, fmt=log_fmt_str)
+        coloredlogs.install(
+            level=self.game_cfg.server.loglevel, logger=self.logger, fmt=log_fmt_str
+        )
 
     @classmethod
-    def get_allnet_info(cls, game_code: str, core_cfg: CoreConfig, cfg_dir: str) -> Tuple[bool, str, str]:
+    def get_allnet_info(
+        cls, game_code: str, core_cfg: CoreConfig, cfg_dir: str
+    ) -> Tuple[bool, str, str]:
         game_cfg = CardMakerConfig()
         if path.exists(f"{cfg_dir}/{CardMakerConstants.CONFIG_NAME}"):
-            game_cfg.update(yaml.safe_load(open(f"{cfg_dir}/{CardMakerConstants.CONFIG_NAME}")))
+            game_cfg.update(
+                yaml.safe_load(open(f"{cfg_dir}/{CardMakerConstants.CONFIG_NAME}"))
+            )
 
         if not game_cfg.server.enable:
             return (False, "", "")
 
         if core_cfg.server.is_develop:
-            return (True, f"http://{core_cfg.title.hostname}:{core_cfg.title.port}/{game_code}/$v/", "")
+            return (
+                True,
+                f"http://{core_cfg.title.hostname}:{core_cfg.title.port}/{game_code}/$v/",
+                "",
+            )
 
         return (True, f"http://{core_cfg.title.hostname}/{game_code}/$v/", "")
 
@@ -86,7 +101,8 @@ class CardMakerServlet():
 
         except zlib.error as e:
             self.logger.error(
-                f"Failed to decompress v{version} {endpoint} request -> {e}")
+                f"Failed to decompress v{version} {endpoint} request -> {e}"
+            )
             return zlib.compress(b'{"stat": "0"}')
 
         req_data = json.loads(unzip)
@@ -104,12 +120,11 @@ class CardMakerServlet():
             resp = handler(req_data)
 
         except Exception as e:
-            self.logger.error(
-                f"Error handling v{version} method {endpoint} - {e}")
+            self.logger.error(f"Error handling v{version} method {endpoint} - {e}")
             return zlib.compress(b'{"stat": "0"}')
 
         if resp is None:
-            resp = {'returnCode': 1}
+            resp = {"returnCode": 1}
 
         self.logger.info(f"Response {resp}")
 

titles/cm/read.py

@@ -15,14 +15,21 @@ from titles.ongeki.config import OngekiConfig
 
 
 class CardMakerReader(BaseReader):
-    def __init__(self, config: CoreConfig, version: int, bin_dir: Optional[str],
-                 opt_dir: Optional[str], extra: Optional[str]) -> None:
+    def __init__(
+        self,
+        config: CoreConfig,
+        version: int,
+        bin_dir: Optional[str],
+        opt_dir: Optional[str],
+        extra: Optional[str],
+    ) -> None:
         super().__init__(config, version, bin_dir, opt_dir, extra)
         self.ongeki_data = OngekiData(config)
 
         try:
             self.logger.info(
-                f"Start importer for {CardMakerConstants.game_ver_to_string(version)}")
+                f"Start importer for {CardMakerConstants.game_ver_to_string(version)}"
+            )
         except IndexError:
             self.logger.error(f"Invalid Card Maker version {version}")
             exit(1)
@@ -30,7 +37,7 @@ class CardMakerReader(BaseReader):
     def read(self) -> None:
         static_datas = {
             "static_gachas.csv": "read_ongeki_gacha_csv",
-            "static_gacha_cards.csv": "read_ongeki_gacha_card_csv"
+            "static_gacha_cards.csv": "read_ongeki_gacha_card_csv",
         }
 
         data_dirs = []
@@ -41,7 +48,9 @@ class CardMakerReader(BaseReader):
                     read_csv = getattr(CardMakerReader, func)
                     read_csv(self, f"{self.bin_dir}/MU3/{file}")
                 else:
-                    self.logger.warn(f"Couldn't find {file} file in {self.bin_dir}, skipping")
+                    self.logger.warn(
+                        f"Couldn't find {file} file in {self.bin_dir}, skipping"
+                    )
 
         if self.opt_dir is not None:
             data_dirs += self.get_data_directories(self.opt_dir)
@@ -64,7 +73,7 @@ class CardMakerReader(BaseReader):
                     row["kind"],
                     type=row["type"],
                     isCeiling=True if row["isCeiling"] == "1" else False,
-                    maxSelectPoint=row["maxSelectPoint"]
+                    maxSelectPoint=row["maxSelectPoint"],
                 )
 
                 self.logger.info(f"Added gacha {row['gachaId']}")
@@ -81,7 +90,7 @@ class CardMakerReader(BaseReader):
                     rarity=row["rarity"],
                     weight=row["weight"],
                     isPickup=True if row["isPickup"] == "1" else False,
-                    isSelect=True if row["isSelect"] == "1" else False
+                    isSelect=True if row["isSelect"] == "1" else False,
                 )
 
                 self.logger.info(f"Added card {row['cardId']} to gacha")
@@ -95,7 +104,7 @@ class CardMakerReader(BaseReader):
             "Pickup": "Pickup",
             "RecoverFiveShotFlag": "BonusRestored",
             "Free": "Free",
-            "FreeSR": "Free"
+            "FreeSR": "Free",
         }
 
         for root, dirs, files in os.walk(base_dir):
@@ -104,13 +113,19 @@ class CardMakerReader(BaseReader):
                     with open(f"{root}/{dir}/Gacha.xml", "r", encoding="utf-8") as f:
                         troot = ET.fromstring(f.read())
 
-                        name = troot.find('Name').find('str').text
-                        gacha_id = int(troot.find('Name').find('id').text)
+                        name = troot.find("Name").find("str").text
+                        gacha_id = int(troot.find("Name").find("id").text)
 
                         # skip already existing gachas
-                        if self.ongeki_data.static.get_gacha(
-                            OngekiConstants.VER_ONGEKI_BRIGHT_MEMORY, gacha_id) is not None:
-                            self.logger.info(f"Gacha {gacha_id} already added, skipping")
+                        if (
+                            self.ongeki_data.static.get_gacha(
+                                OngekiConstants.VER_ONGEKI_BRIGHT_MEMORY, gacha_id
+                            )
+                            is not None
+                        ):
+                            self.logger.info(
+                                f"Gacha {gacha_id} already added, skipping"
+                            )
                             continue
 
                         # 1140 is the first bright memory gacha
@@ -120,7 +135,8 @@ class CardMakerReader(BaseReader):
                             version = OngekiConstants.VER_ONGEKI_BRIGHT_MEMORY
 
                         gacha_kind = OngekiConstants.CM_GACHA_KINDS[
-                            type_to_kind[troot.find('Type').text]].value
+                            type_to_kind[troot.find("Type").text]
+                        ].value
 
                         # hardcode which gachas get "Select Gacha" with 33 points
                         is_ceiling, max_select_point = 0, 0
@@ -134,5 +150,6 @@ class CardMakerReader(BaseReader):
                             name,
                             gacha_kind,
                             isCeiling=is_ceiling,
-                            maxSelectPoint=max_select_point)
+                            maxSelectPoint=max_select_point,
+                        )
                         self.logger.info(f"Added gacha {gacha_id}")

titles/cxb/__init__.py

@@ -7,4 +7,4 @@ index = CxbServlet
 database = CxbData
 reader = CxbReader
 game_codes = [CxbConstants.GAME_CODE]
-current_schema_version = 1
+current_schema_version = 1

titles/cxb/base.py

@@ -11,82 +11,91 @@ from titles.cxb.config import CxbConfig
 from titles.cxb.const import CxbConstants
 from titles.cxb.database import CxbData
 
-class CxbBase():
+
+class CxbBase:
     def __init__(self, cfg: CoreConfig, game_cfg: CxbConfig) -> None:
-        self.config = cfg # Config file
+        self.config = cfg  # Config file
         self.game_config = game_cfg
-        self.data = CxbData(cfg) # Database
+        self.data = CxbData(cfg)  # Database
         self.game = CxbConstants.GAME_CODE
         self.logger = logging.getLogger("cxb")
         self.version = CxbConstants.VER_CROSSBEATS_REV
-        
+
     def handle_action_rpreq_request(self, data: Dict) -> Dict:
-        return({})
-    
+        return {}
+
     def handle_action_hitreq_request(self, data: Dict) -> Dict:
-        return({"data":[]})
+        return {"data": []}
 
     def handle_auth_usercheck_request(self, data: Dict) -> Dict:
-        profile = self.data.profile.get_profile_index(0, data["usercheck"]["authid"], self.version)
+        profile = self.data.profile.get_profile_index(
+            0, data["usercheck"]["authid"], self.version
+        )
         if profile is not None:
             self.logger.info(f"User {data['usercheck']['authid']} has CXB profile")
-            return({"exist": "true", "logout": "true"})
+            return {"exist": "true", "logout": "true"}
 
         self.logger.info(f"No profile for aime id {data['usercheck']['authid']}")
-        return({"exist": "false", "logout": "true"})
+        return {"exist": "false", "logout": "true"}
 
     def handle_auth_entry_request(self, data: Dict) -> Dict:
         self.logger.info(f"New profile for {data['entry']['authid']}")
-        return({"token": data["entry"]["authid"], "uid": data["entry"]["authid"]})
+        return {"token": data["entry"]["authid"], "uid": data["entry"]["authid"]}
 
     def handle_auth_login_request(self, data: Dict) -> Dict:
-        profile = self.data.profile.get_profile_index(0, data["login"]["authid"], self.version)
-            
+        profile = self.data.profile.get_profile_index(
+            0, data["login"]["authid"], self.version
+        )
+
         if profile is not None:
             self.logger.info(f"Login user {data['login']['authid']}")
-            return({"token": data["login"]["authid"], "uid": data["login"]["authid"]})
-        
+            return {"token": data["login"]["authid"], "uid": data["login"]["authid"]}
+
         self.logger.warn(f"User {data['login']['authid']} does not have a profile")
-        return({})
-    
+        return {}
+
     def handle_action_loadrange_request(self, data: Dict) -> Dict:
-        range_start = data['loadrange']['range'][0]
-        range_end = data['loadrange']['range'][1]
-        uid = data['loadrange']['uid']
+        range_start = data["loadrange"]["range"][0]
+        range_end = data["loadrange"]["range"][1]
+        uid = data["loadrange"]["uid"]
 
         self.logger.info(f"Load data for {uid}")
         profile = self.data.profile.get_profile(uid, self.version)
-        songs = self.data.score.get_best_scores(uid)      
+        songs = self.data.score.get_best_scores(uid)
 
         data1 = []
         index = []
         versionindex = []
-        
+
         for profile_index in profile:
             profile_data = profile_index["data"]
 
             if int(range_start) == 800000:
-                return({"index":range_start, "data":[], "version":10400})
-            
-            if not ( int(range_start) <= int(profile_index[3]) <=  int(range_end) ):
+                return {"index": range_start, "data": [], "version": 10400}
+
+            if not (int(range_start) <= int(profile_index[3]) <= int(range_end)):
                 continue
-            #Prevent loading of the coupons within the profile to use the force unlock instead
+            # Prevent loading of the coupons within the profile to use the force unlock instead
             elif 500 <= int(profile_index[3]) <= 510:
                 continue
-            #Prevent loading of songs saved in the profile
+            # Prevent loading of songs saved in the profile
             elif 100000 <= int(profile_index[3]) <= 110000:
                 continue
-            #Prevent loading of the shop list / unlocked titles & icons saved in the profile
+            # Prevent loading of the shop list / unlocked titles & icons saved in the profile
             elif 200000 <= int(profile_index[3]) <= 210000:
                 continue
-            #Prevent loading of stories in the profile
+            # Prevent loading of stories in the profile
             elif 900000 <= int(profile_index[3]) <= 900200:
                 continue
             else:
                 index.append(profile_index[3])
-                data1.append(b64encode(bytes(json.dumps(profile_data, separators=(',', ':')), 'utf-8')).decode('utf-8'))
+                data1.append(
+                    b64encode(
+                        bytes(json.dumps(profile_data, separators=(",", ":")), "utf-8")
+                    ).decode("utf-8")
+                )
 
-        '''
+        """
         100000 = Songs
         200000 = Shop
         300000 = Courses
@@ -96,101 +105,140 @@ class CxbBase():
         700000 = rcLog
         800000 = Partners
         900000 = Stories
-        '''
+        """
 
         # Coupons
-        for i in range(500,510):
+        for i in range(500, 510):
             index.append(str(i))
             couponid = int(i) - 500
-            dataValue = [{
-                "couponId":str(couponid),
-                "couponNum":"1",
-                "couponLog":[],
-            }]
-            data1.append(b64encode(bytes(json.dumps(dataValue[0], separators=(',', ':')), 'utf-8')).decode('utf-8'))
-        
+            dataValue = [
+                {
+                    "couponId": str(couponid),
+                    "couponNum": "1",
+                    "couponLog": [],
+                }
+            ]
+            data1.append(
+                b64encode(
+                    bytes(json.dumps(dataValue[0], separators=(",", ":")), "utf-8")
+                ).decode("utf-8")
+            )
 
         # ShopList_Title
-        for i in range(200000,201451):
+        for i in range(200000, 201451):
             index.append(str(i))
             shopid = int(i) - 200000
-            dataValue = [{
-                "shopId":shopid,
-                "shopState":"2",
-                "isDisable":"t",
-                "isDeleted":"f",
-                "isSpecialFlag":"f"
-            }]
-            data1.append(b64encode(bytes(json.dumps(dataValue[0], separators=(',', ':')), 'utf-8')).decode('utf-8'))
+            dataValue = [
+                {
+                    "shopId": shopid,
+                    "shopState": "2",
+                    "isDisable": "t",
+                    "isDeleted": "f",
+                    "isSpecialFlag": "f",
+                }
+            ]
+            data1.append(
+                b64encode(
+                    bytes(json.dumps(dataValue[0], separators=(",", ":")), "utf-8")
+                ).decode("utf-8")
+            )
 
-        #ShopList_Icon
-        for i in range(202000,202264):
+        # ShopList_Icon
+        for i in range(202000, 202264):
             index.append(str(i))
             shopid = int(i) - 200000
-            dataValue = [{
-                "shopId":shopid,
-                "shopState":"2",
-                "isDisable":"t",
-                "isDeleted":"f",
-                "isSpecialFlag":"f"
-            }]
-            data1.append(b64encode(bytes(json.dumps(dataValue[0], separators=(',', ':')), 'utf-8')).decode('utf-8'))
+            dataValue = [
+                {
+                    "shopId": shopid,
+                    "shopState": "2",
+                    "isDisable": "t",
+                    "isDeleted": "f",
+                    "isSpecialFlag": "f",
+                }
+            ]
+            data1.append(
+                b64encode(
+                    bytes(json.dumps(dataValue[0], separators=(",", ":")), "utf-8")
+                ).decode("utf-8")
+            )
 
-        #Stories
-        for i in range(900000,900003):
+        # Stories
+        for i in range(900000, 900003):
             index.append(str(i))
             storyid = int(i) - 900000
-            dataValue = [{
-                "storyId":storyid,
-                "unlockState1":["t"] * 10,
-                "unlockState2":["t"] * 10,
-                "unlockState3":["t"] * 10,
-                "unlockState4":["t"] * 10,
-                "unlockState5":["t"] * 10,
-                "unlockState6":["t"] * 10,
-                "unlockState7":["t"] * 10,
-                "unlockState8":["t"] * 10,
-                "unlockState9":["t"] * 10,
-                "unlockState10":["t"] * 10,
-                "unlockState11":["t"] * 10,
-                "unlockState12":["t"] * 10,
-                "unlockState13":["t"] * 10,
-                "unlockState14":["t"] * 10,
-                "unlockState15":["t"] * 10,
-                "unlockState16":["t"] * 10
-            }]
-            data1.append(b64encode(bytes(json.dumps(dataValue[0], separators=(',', ':')), 'utf-8')).decode('utf-8'))
+            dataValue = [
+                {
+                    "storyId": storyid,
+                    "unlockState1": ["t"] * 10,
+                    "unlockState2": ["t"] * 10,
+                    "unlockState3": ["t"] * 10,
+                    "unlockState4": ["t"] * 10,
+                    "unlockState5": ["t"] * 10,
+                    "unlockState6": ["t"] * 10,
+                    "unlockState7": ["t"] * 10,
+                    "unlockState8": ["t"] * 10,
+                    "unlockState9": ["t"] * 10,
+                    "unlockState10": ["t"] * 10,
+                    "unlockState11": ["t"] * 10,
+                    "unlockState12": ["t"] * 10,
+                    "unlockState13": ["t"] * 10,
+                    "unlockState14": ["t"] * 10,
+                    "unlockState15": ["t"] * 10,
+                    "unlockState16": ["t"] * 10,
+                }
+            ]
+            data1.append(
+                b64encode(
+                    bytes(json.dumps(dataValue[0], separators=(",", ":")), "utf-8")
+                ).decode("utf-8")
+            )
 
         for song in songs:
             song_data = song["data"]
             songCode = []
 
-            songCode.append({
-                    "mcode": song_data['mcode'],
-                    "musicState": song_data['musicState'],
-                    "playCount": song_data['playCount'],
-                    "totalScore": song_data['totalScore'],
-                    "highScore": song_data['highScore'],
-                    "everHighScore": song_data['everHighScore'] if 'everHighScore' in song_data else ["0","0","0","0","0"],
-                    "clearRate": song_data['clearRate'],
-                    "rankPoint": song_data['rankPoint'],
-                    "normalCR": song_data['normalCR'] if 'normalCR' in song_data else ["0","0","0","0","0"],
-                    "survivalCR": song_data['survivalCR'] if 'survivalCR' in song_data else ["0","0","0","0","0"],
-                    "ultimateCR": song_data['ultimateCR'] if 'ultimateCR' in song_data else ["0","0","0","0","0"],
-                    "nohopeCR": song_data['nohopeCR'] if 'nohopeCR' in song_data else ["0","0","0","0","0"],
-                    "combo": song_data['combo'],
-                    "coupleUserId": song_data['coupleUserId'],
-                    "difficulty": song_data['difficulty'],
-                    "isFullCombo": song_data['isFullCombo'],
-                    "clearGaugeType": song_data['clearGaugeType'],
-                    "fieldType": song_data['fieldType'],
-                    "gameType": song_data['gameType'],
-                    "grade": song_data['grade'],
-                    "unlockState": song_data['unlockState'],
-                    "extraState": song_data['extraState']
-                })
-            index.append(song_data['index'])
-            data1.append(b64encode(bytes(json.dumps(songCode[0], separators=(',', ':')), 'utf-8')).decode('utf-8'))
+            songCode.append(
+                {
+                    "mcode": song_data["mcode"],
+                    "musicState": song_data["musicState"],
+                    "playCount": song_data["playCount"],
+                    "totalScore": song_data["totalScore"],
+                    "highScore": song_data["highScore"],
+                    "everHighScore": song_data["everHighScore"]
+                    if "everHighScore" in song_data
+                    else ["0", "0", "0", "0", "0"],
+                    "clearRate": song_data["clearRate"],
+                    "rankPoint": song_data["rankPoint"],
+                    "normalCR": song_data["normalCR"]
+                    if "normalCR" in song_data
+                    else ["0", "0", "0", "0", "0"],
+                    "survivalCR": song_data["survivalCR"]
+                    if "survivalCR" in song_data
+                    else ["0", "0", "0", "0", "0"],
+                    "ultimateCR": song_data["ultimateCR"]
+                    if "ultimateCR" in song_data
+                    else ["0", "0", "0", "0", "0"],
+                    "nohopeCR": song_data["nohopeCR"]
+                    if "nohopeCR" in song_data
+                    else ["0", "0", "0", "0", "0"],
+                    "combo": song_data["combo"],
+                    "coupleUserId": song_data["coupleUserId"],
+                    "difficulty": song_data["difficulty"],
+                    "isFullCombo": song_data["isFullCombo"],
+                    "clearGaugeType": song_data["clearGaugeType"],
+                    "fieldType": song_data["fieldType"],
+                    "gameType": song_data["gameType"],
+                    "grade": song_data["grade"],
+                    "unlockState": song_data["unlockState"],
+                    "extraState": song_data["extraState"],
+                }
+            )
+            index.append(song_data["index"])
+            data1.append(
+                b64encode(
+                    bytes(json.dumps(songCode[0], separators=(",", ":")), "utf-8")
+                ).decode("utf-8")
+            )
 
         for v in index:
             try:
@@ -198,66 +246,81 @@ class CxbBase():
                 v_profile_data = v_profile["data"]
                 versionindex.append(int(v_profile_data["appVersion"]))
             except:
-                versionindex.append('10400')
+                versionindex.append("10400")
 
-        return({"index":index, "data":data1, "version":versionindex})
+        return {"index": index, "data": data1, "version": versionindex}
 
     def handle_action_saveindex_request(self, data: Dict) -> Dict:
-        save_data = data['saveindex']
-        
+        save_data = data["saveindex"]
+
         try:
-            #REV Omnimix Version Fetcher
-            gameversion = data['saveindex']['data'][0][2]
+            # REV Omnimix Version Fetcher
+            gameversion = data["saveindex"]["data"][0][2]
             self.logger.warning(f"Game Version is {gameversion}")
         except:
             pass
-            
-        if "10205" in gameversion:
-            self.logger.info(f"Saving CrossBeats REV profile for {data['saveindex']['uid']}")
-            #Alright.... time to bring the jank code
-            
-            for value in data['saveindex']['data']:
-                
-                if 'playedUserId' in value[1]:
-                    self.data.profile.put_profile(data['saveindex']['uid'], self.version, value[0], value[1])
-                if 'mcode' not in value[1]:
-                    self.data.profile.put_profile(data['saveindex']['uid'], self.version, value[0], value[1])
-                if 'shopId' in value:
-                    continue
-                if 'mcode' in value[1] and 'musicState' in value[1]:
-                    song_json = json.loads(value[1])
-                    
-                    songCode = []
-                    songCode.append({
-                        "mcode": song_json['mcode'],
-                        "musicState": song_json['musicState'],
-                        "playCount": song_json['playCount'],
-                        "totalScore": song_json['totalScore'],
-                        "highScore": song_json['highScore'],
-                        "clearRate": song_json['clearRate'],
-                        "rankPoint": song_json['rankPoint'],
-                        "combo": song_json['combo'],
-                        "coupleUserId": song_json['coupleUserId'],
-                        "difficulty": song_json['difficulty'],
-                        "isFullCombo": song_json['isFullCombo'],
-                        "clearGaugeType": song_json['clearGaugeType'],
-                        "fieldType": song_json['fieldType'],
-                        "gameType": song_json['gameType'],
-                        "grade": song_json['grade'],
-                        "unlockState": song_json['unlockState'],
-                        "extraState": song_json['extraState'],
-                        "index": value[0]
-                    })
-                    self.data.score.put_best_score(data['saveindex']['uid'], song_json['mcode'], self.version, value[0], songCode[0])
-            return({})
-        else:
-            self.logger.info(f"Saving CrossBeats REV Sunrise profile for {data['saveindex']['uid']}")
 
-        #Sunrise
+        if "10205" in gameversion:
+            self.logger.info(
+                f"Saving CrossBeats REV profile for {data['saveindex']['uid']}"
+            )
+            # Alright.... time to bring the jank code
+
+            for value in data["saveindex"]["data"]:
+                if "playedUserId" in value[1]:
+                    self.data.profile.put_profile(
+                        data["saveindex"]["uid"], self.version, value[0], value[1]
+                    )
+                if "mcode" not in value[1]:
+                    self.data.profile.put_profile(
+                        data["saveindex"]["uid"], self.version, value[0], value[1]
+                    )
+                if "shopId" in value:
+                    continue
+                if "mcode" in value[1] and "musicState" in value[1]:
+                    song_json = json.loads(value[1])
+
+                    songCode = []
+                    songCode.append(
+                        {
+                            "mcode": song_json["mcode"],
+                            "musicState": song_json["musicState"],
+                            "playCount": song_json["playCount"],
+                            "totalScore": song_json["totalScore"],
+                            "highScore": song_json["highScore"],
+                            "clearRate": song_json["clearRate"],
+                            "rankPoint": song_json["rankPoint"],
+                            "combo": song_json["combo"],
+                            "coupleUserId": song_json["coupleUserId"],
+                            "difficulty": song_json["difficulty"],
+                            "isFullCombo": song_json["isFullCombo"],
+                            "clearGaugeType": song_json["clearGaugeType"],
+                            "fieldType": song_json["fieldType"],
+                            "gameType": song_json["gameType"],
+                            "grade": song_json["grade"],
+                            "unlockState": song_json["unlockState"],
+                            "extraState": song_json["extraState"],
+                            "index": value[0],
+                        }
+                    )
+                    self.data.score.put_best_score(
+                        data["saveindex"]["uid"],
+                        song_json["mcode"],
+                        self.version,
+                        value[0],
+                        songCode[0],
+                    )
+            return {}
+        else:
+            self.logger.info(
+                f"Saving CrossBeats REV Sunrise profile for {data['saveindex']['uid']}"
+            )
+
+        # Sunrise
         try:
-            profileIndex = save_data['index'].index('0')
+            profileIndex = save_data["index"].index("0")
         except:
-            return({"data":""}) #Maybe
+            return {"data": ""}  # Maybe
 
         profile = json.loads(save_data["data"][profileIndex])
         aimeId = profile["aimeId"]
@@ -265,65 +328,91 @@ class CxbBase():
 
         for index, value in enumerate(data["saveindex"]["data"]):
             if int(data["saveindex"]["index"][index]) == 101:
-                self.data.profile.put_profile(aimeId, self.version, data["saveindex"]["index"][index], value)
-            if int(data["saveindex"]["index"][index]) >= 700000 and int(data["saveindex"]["index"][index])<= 701000:
-                self.data.profile.put_profile(aimeId, self.version, data["saveindex"]["index"][index], value)
-            if int(data["saveindex"]["index"][index]) >= 500 and int(data["saveindex"]["index"][index]) <= 510:
-                self.data.profile.put_profile(aimeId, self.version, data["saveindex"]["index"][index], value)
-            if 'playedUserId' in value:
-                self.data.profile.put_profile(aimeId, self.version, data["saveindex"]["index"][index], json.loads(value))
-            if 'mcode' not in value and "normalCR" not in value:
-                self.data.profile.put_profile(aimeId, self.version, data["saveindex"]["index"][index], json.loads(value))
-            if 'shopId' in value:
+                self.data.profile.put_profile(
+                    aimeId, self.version, data["saveindex"]["index"][index], value
+                )
+            if (
+                int(data["saveindex"]["index"][index]) >= 700000
+                and int(data["saveindex"]["index"][index]) <= 701000
+            ):
+                self.data.profile.put_profile(
+                    aimeId, self.version, data["saveindex"]["index"][index], value
+                )
+            if (
+                int(data["saveindex"]["index"][index]) >= 500
+                and int(data["saveindex"]["index"][index]) <= 510
+            ):
+                self.data.profile.put_profile(
+                    aimeId, self.version, data["saveindex"]["index"][index], value
+                )
+            if "playedUserId" in value:
+                self.data.profile.put_profile(
+                    aimeId,
+                    self.version,
+                    data["saveindex"]["index"][index],
+                    json.loads(value),
+                )
+            if "mcode" not in value and "normalCR" not in value:
+                self.data.profile.put_profile(
+                    aimeId,
+                    self.version,
+                    data["saveindex"]["index"][index],
+                    json.loads(value),
+                )
+            if "shopId" in value:
                 continue
 
         # MusicList Index for the profile
         indexSongList = []
         for value in data["saveindex"]["index"]:
-            if int(value) in range(100000,110000):
+            if int(value) in range(100000, 110000):
                 indexSongList.append(value)
-        
+
         for index, value in enumerate(data["saveindex"]["data"]):
-            if 'mcode' not in value:
+            if "mcode" not in value:
                 continue
-            if 'playedUserId' in value:
+            if "playedUserId" in value:
                 continue
-            
+
             data1 = json.loads(value)
 
             songCode = []
-            songCode.append({
-                "mcode": data1['mcode'],
-                "musicState": data1['musicState'],
-                "playCount": data1['playCount'],
-                "totalScore": data1['totalScore'],
-                "highScore": data1['highScore'],
-                "everHighScore": data1['everHighScore'],
-                "clearRate": data1['clearRate'],
-                "rankPoint": data1['rankPoint'],
-                "normalCR": data1['normalCR'],
-                "survivalCR": data1['survivalCR'],
-                "ultimateCR": data1['ultimateCR'],
-                "nohopeCR": data1['nohopeCR'],
-                "combo": data1['combo'],
-                "coupleUserId": data1['coupleUserId'],
-                "difficulty": data1['difficulty'],
-                "isFullCombo": data1['isFullCombo'],
-                "clearGaugeType": data1['clearGaugeType'],
-                "fieldType": data1['fieldType'],
-                "gameType": data1['gameType'],
-                "grade": data1['grade'],
-                "unlockState": data1['unlockState'],
-                "extraState": data1['extraState'],
-                "index": indexSongList[i]
-            })
+            songCode.append(
+                {
+                    "mcode": data1["mcode"],
+                    "musicState": data1["musicState"],
+                    "playCount": data1["playCount"],
+                    "totalScore": data1["totalScore"],
+                    "highScore": data1["highScore"],
+                    "everHighScore": data1["everHighScore"],
+                    "clearRate": data1["clearRate"],
+                    "rankPoint": data1["rankPoint"],
+                    "normalCR": data1["normalCR"],
+                    "survivalCR": data1["survivalCR"],
+                    "ultimateCR": data1["ultimateCR"],
+                    "nohopeCR": data1["nohopeCR"],
+                    "combo": data1["combo"],
+                    "coupleUserId": data1["coupleUserId"],
+                    "difficulty": data1["difficulty"],
+                    "isFullCombo": data1["isFullCombo"],
+                    "clearGaugeType": data1["clearGaugeType"],
+                    "fieldType": data1["fieldType"],
+                    "gameType": data1["gameType"],
+                    "grade": data1["grade"],
+                    "unlockState": data1["unlockState"],
+                    "extraState": data1["extraState"],
+                    "index": indexSongList[i],
+                }
+            )
 
-            self.data.score.put_best_score(aimeId, data1['mcode'], self.version, indexSongList[i], songCode[0])
+            self.data.score.put_best_score(
+                aimeId, data1["mcode"], self.version, indexSongList[i], songCode[0]
+            )
             i += 1
-        return({})
-        
+        return {}
+
     def handle_action_sprankreq_request(self, data: Dict) -> Dict:
-        uid = data['sprankreq']['uid']
+        uid = data["sprankreq"]["uid"]
         self.logger.info(f"Get best rankings for {uid}")
         p = self.data.score.get_best_rankings(uid)
 
@@ -331,90 +420,122 @@ class CxbBase():
 
         for rank in p:
             if rank["song_id"] is not None:
-                rankList.append({
-                    "sc": [rank["score"],rank["song_id"]],
-                    "rid": rank["rev_id"],
-                    "clear": rank["clear"]
-                })
+                rankList.append(
+                    {
+                        "sc": [rank["score"], rank["song_id"]],
+                        "rid": rank["rev_id"],
+                        "clear": rank["clear"],
+                    }
+                )
             else:
-                rankList.append({
-                    "sc": [rank["score"]],
-                    "rid": rank["rev_id"],
-                    "clear": rank["clear"]
-                })
+                rankList.append(
+                    {
+                        "sc": [rank["score"]],
+                        "rid": rank["rev_id"],
+                        "clear": rank["clear"],
+                    }
+                )
 
-        return({
+        return {
             "uid": data["sprankreq"]["uid"],
             "aid": data["sprankreq"]["aid"],
             "rank": rankList,
-            "rankx":[1,1,1]
-        })
-    
+            "rankx": [1, 1, 1],
+        }
+
     def handle_action_getadv_request(self, data: Dict) -> Dict:
-        return({"data":[{"r":"1","i":"100300","c":"20"}]})
-        
+        return {"data": [{"r": "1", "i": "100300", "c": "20"}]}
+
     def handle_action_getmsg_request(self, data: Dict) -> Dict:
-        return({"msgs":[]})
-    
+        return {"msgs": []}
+
     def handle_auth_logout_request(self, data: Dict) -> Dict:
-        return({"auth":True})
-     
-    def handle_action_rankreg_request(self, data: Dict) -> Dict: 
-        uid = data['rankreg']['uid']
+        return {"auth": True}
+
+    def handle_action_rankreg_request(self, data: Dict) -> Dict:
+        uid = data["rankreg"]["uid"]
         self.logger.info(f"Put {len(data['rankreg']['data'])} rankings for {uid}")
 
-        for rid in data['rankreg']['data']:
-            #REV S2
+        for rid in data["rankreg"]["data"]:
+            # REV S2
             if "clear" in rid:
                 try:
-                    self.data.score.put_ranking(user_id=uid, rev_id=int(rid["rid"]), song_id=int(rid["sc"][1]), score=int(rid["sc"][0]), clear=rid["clear"])
+                    self.data.score.put_ranking(
+                        user_id=uid,
+                        rev_id=int(rid["rid"]),
+                        song_id=int(rid["sc"][1]),
+                        score=int(rid["sc"][0]),
+                        clear=rid["clear"],
+                    )
                 except:
-                    self.data.score.put_ranking(user_id=uid, rev_id=int(rid["rid"]), song_id=0, score=int(rid["sc"][0]), clear=rid["clear"])
-            #REV
+                    self.data.score.put_ranking(
+                        user_id=uid,
+                        rev_id=int(rid["rid"]),
+                        song_id=0,
+                        score=int(rid["sc"][0]),
+                        clear=rid["clear"],
+                    )
+            # REV
             else:
                 try:
-                    self.data.score.put_ranking(user_id=uid, rev_id=int(rid["rid"]), song_id=int(rid["sc"][1]), score=int(rid["sc"][0]), clear=0)
+                    self.data.score.put_ranking(
+                        user_id=uid,
+                        rev_id=int(rid["rid"]),
+                        song_id=int(rid["sc"][1]),
+                        score=int(rid["sc"][0]),
+                        clear=0,
+                    )
                 except:
-                    self.data.score.put_ranking(user_id=uid, rev_id=int(rid["rid"]), song_id=0, score=int(rid["sc"][0]), clear=0)
-        return({})
-        
+                    self.data.score.put_ranking(
+                        user_id=uid,
+                        rev_id=int(rid["rid"]),
+                        song_id=0,
+                        score=int(rid["sc"][0]),
+                        clear=0,
+                    )
+        return {}
+
     def handle_action_addenergy_request(self, data: Dict) -> Dict:
-        uid = data['addenergy']['uid']
+        uid = data["addenergy"]["uid"]
         self.logger.info(f"Add energy to user {uid}")
         profile = self.data.profile.get_profile_index(0, uid, self.version)
         data1 = profile["data"]
         p = self.data.item.get_energy(uid)
         energy = p["energy"]
-            
-        if not p: 
+
+        if not p:
             self.data.item.put_energy(uid, 5)
-            
-            return({
+
+            return {
                 "class": data1["myClass"],
                 "granted": "5",
                 "total": "5",
-                "threshold": "1000"
-            })
+                "threshold": "1000",
+            }
 
         array = []
-        
+
         newenergy = int(energy) + 5
         self.data.item.put_energy(uid, newenergy)
 
         if int(energy) <= 995:
-            array.append({
-                "class": data1["myClass"],
-                "granted": "5",
-                "total": str(energy),
-                "threshold": "1000"
-            })
+            array.append(
+                {
+                    "class": data1["myClass"],
+                    "granted": "5",
+                    "total": str(energy),
+                    "threshold": "1000",
+                }
+            )
         else:
-            array.append({
-                "class": data1["myClass"],
-                "granted": "0",
-                "total": str(energy),
-                "threshold": "1000"
-            })
+            array.append(
+                {
+                    "class": data1["myClass"],
+                    "granted": "0",
+                    "total": str(energy),
+                    "threshold": "1000",
+                }
+            )
         return array[0]
 
     def handle_action_eventreq_request(self, data: Dict) -> Dict:

titles/cxb/config.py

@@ -1,40 +1,60 @@
 from core.config import CoreConfig
 
-class CxbServerConfig():
+
+class CxbServerConfig:
     def __init__(self, parent_config: "CxbConfig"):
         self.__config = parent_config
-    
+
     @property
     def enable(self) -> bool:
-        return CoreConfig.get_config_field(self.__config, 'cxb', 'server', 'enable', default=True)
+        return CoreConfig.get_config_field(
+            self.__config, "cxb", "server", "enable", default=True
+        )
 
     @property
     def loglevel(self) -> int:
-        return CoreConfig.str_to_loglevel(CoreConfig.get_config_field(self.__config, 'cxb', 'server', 'loglevel', default="info"))
+        return CoreConfig.str_to_loglevel(
+            CoreConfig.get_config_field(
+                self.__config, "cxb", "server", "loglevel", default="info"
+            )
+        )
 
     @property
     def hostname(self) -> str:
-        return CoreConfig.get_config_field(self.__config, 'cxb', 'server', 'hostname', default="localhost")
+        return CoreConfig.get_config_field(
+            self.__config, "cxb", "server", "hostname", default="localhost"
+        )
 
     @property
     def ssl_enable(self) -> bool:
-        return CoreConfig.get_config_field(self.__config, 'cxb', 'server', 'ssl_enable', default=False)
+        return CoreConfig.get_config_field(
+            self.__config, "cxb", "server", "ssl_enable", default=False
+        )
 
     @property
     def port(self) -> int:
-        return CoreConfig.get_config_field(self.__config, 'cxb', 'server', 'port', default=8082)
+        return CoreConfig.get_config_field(
+            self.__config, "cxb", "server", "port", default=8082
+        )
 
     @property
     def port_secure(self) -> int:
-        return CoreConfig.get_config_field(self.__config, 'cxb', 'server', 'port_secure', default=443)
-    
+        return CoreConfig.get_config_field(
+            self.__config, "cxb", "server", "port_secure", default=443
+        )
+
     @property
     def ssl_cert(self) -> str:
-        return CoreConfig.get_config_field(self.__config, 'cxb', 'server', 'ssl_cert', default="cert/title.crt")
+        return CoreConfig.get_config_field(
+            self.__config, "cxb", "server", "ssl_cert", default="cert/title.crt"
+        )
 
     @property
     def ssl_key(self) -> str:
-        return CoreConfig.get_config_field(self.__config, 'cxb', 'server', 'ssl_key', default="cert/title.key")
+        return CoreConfig.get_config_field(
+            self.__config, "cxb", "server", "ssl_key", default="cert/title.key"
+        )
+
 
 class CxbConfig(dict):
     def __init__(self) -> None:

titles/cxb/const.py

@@ -1,4 +1,4 @@
-class CxbConstants():
+class CxbConstants:
     GAME_CODE = "SDCA"
 
     CONFIG_NAME = "cxb.yaml"
@@ -8,8 +8,13 @@ class CxbConstants():
     VER_CROSSBEATS_REV_SUNRISE_S2 = 2
     VER_CROSSBEATS_REV_SUNRISE_S2_OMNI = 3
 
-    VERSION_NAMES = ("crossbeats REV.", "crossbeats REV. SUNRISE", "crossbeats REV. SUNRISE S2", "crossbeats REV. SUNRISE S2 Omnimix")
+    VERSION_NAMES = (
+        "crossbeats REV.",
+        "crossbeats REV. SUNRISE",
+        "crossbeats REV. SUNRISE S2",
+        "crossbeats REV. SUNRISE S2 Omnimix",
+    )
 
     @classmethod
     def game_ver_to_string(cls, ver: int):
-        return cls.VERSION_NAMES[ver]
+        return cls.VERSION_NAMES[ver]

titles/cxb/database.py

@@ -1,8 +1,8 @@
-
 from core.data import Data
 from core.config import CoreConfig
 from titles.cxb.schema import CxbProfileData, CxbScoreData, CxbItemData, CxbStaticData
 
+
 class CxbData(Data):
     def __init__(self, cfg: CoreConfig) -> None:
         super().__init__(cfg)

titles/cxb/index.py

@@ -17,6 +17,7 @@ from titles.cxb.rev import CxbRev
 from titles.cxb.rss1 import CxbRevSunriseS1
 from titles.cxb.rss2 import CxbRevSunriseS2
 
+
 class CxbServlet(resource.Resource):
     def __init__(self, core_cfg: CoreConfig, cfg_dir: str) -> None:
         self.isLeaf = True
@@ -24,62 +25,85 @@ class CxbServlet(resource.Resource):
         self.core_cfg = core_cfg
         self.game_cfg = CxbConfig()
         if path.exists(f"{cfg_dir}/{CxbConstants.CONFIG_NAME}"):
-            self.game_cfg.update(yaml.safe_load(open(f"{cfg_dir}/{CxbConstants.CONFIG_NAME}")))
+            self.game_cfg.update(
+                yaml.safe_load(open(f"{cfg_dir}/{CxbConstants.CONFIG_NAME}"))
+            )
 
         self.logger = logging.getLogger("cxb")
         if not hasattr(self.logger, "inited"):
             log_fmt_str = "[%(asctime)s] CXB | %(levelname)s | %(message)s"
             log_fmt = logging.Formatter(log_fmt_str)
-            fileHandler = TimedRotatingFileHandler("{0}/{1}.log".format(self.core_cfg.server.log_dir, "cxb"), encoding='utf8',
-                when="d", backupCount=10)
+            fileHandler = TimedRotatingFileHandler(
+                "{0}/{1}.log".format(self.core_cfg.server.log_dir, "cxb"),
+                encoding="utf8",
+                when="d",
+                backupCount=10,
+            )
 
             fileHandler.setFormatter(log_fmt)
-            
+
             consoleHandler = logging.StreamHandler()
             consoleHandler.setFormatter(log_fmt)
 
             self.logger.addHandler(fileHandler)
             self.logger.addHandler(consoleHandler)
-            
+
             self.logger.setLevel(self.game_cfg.server.loglevel)
-            coloredlogs.install(level=self.game_cfg.server.loglevel, logger=self.logger, fmt=log_fmt_str)
+            coloredlogs.install(
+                level=self.game_cfg.server.loglevel, logger=self.logger, fmt=log_fmt_str
+            )
             self.logger.inited = True
-        
+
         self.versions = [
             CxbRev(core_cfg, self.game_cfg),
             CxbRevSunriseS1(core_cfg, self.game_cfg),
             CxbRevSunriseS2(core_cfg, self.game_cfg),
         ]
-    
+
     @classmethod
-    def get_allnet_info(cls, game_code: str, core_cfg: CoreConfig, cfg_dir: str) -> Tuple[bool, str, str]:
+    def get_allnet_info(
+        cls, game_code: str, core_cfg: CoreConfig, cfg_dir: str
+    ) -> Tuple[bool, str, str]:
         game_cfg = CxbConfig()
         if path.exists(f"{cfg_dir}/{CxbConstants.CONFIG_NAME}"):
-            game_cfg.update(yaml.safe_load(open(f"{cfg_dir}/{CxbConstants.CONFIG_NAME}")))
+            game_cfg.update(
+                yaml.safe_load(open(f"{cfg_dir}/{CxbConstants.CONFIG_NAME}"))
+            )
 
         if not game_cfg.server.enable:
             return (False, "", "")
-        
+
         if core_cfg.server.is_develop:
-            return (True, f"http://{core_cfg.title.hostname}:{core_cfg.title.port}/{game_code}/$v/", "")
-        
+            return (
+                True,
+                f"http://{core_cfg.title.hostname}:{core_cfg.title.port}/{game_code}/$v/",
+                "",
+            )
+
         return (True, f"http://{core_cfg.title.hostname}/{game_code}/$v/", "")
 
     def setup(self):
         if self.game_cfg.server.enable:
-            endpoints.serverFromString(reactor, f"tcp:{self.game_cfg.server.port}:interface={self.core_cfg.server.listen_address}")\
-                .listen(server.Site(CxbServlet(self.core_cfg, self.cfg_dir)))
-            
-            if self.core_cfg.server.is_develop and self.game_cfg.server.ssl_enable:
-                endpoints.serverFromString(reactor, f"ssl:{self.game_cfg.server.port_secure}"\
-                    f":interface={self.core_cfg.server.listen_address}:privateKey={self.game_cfg.server.ssl_key}:"\
-                        f"certKey={self.game_cfg.server.ssl_cert}")\
-                        .listen(server.Site(CxbServlet(self.core_cfg, self.cfg_dir)))
+            endpoints.serverFromString(
+                reactor,
+                f"tcp:{self.game_cfg.server.port}:interface={self.core_cfg.server.listen_address}",
+            ).listen(server.Site(CxbServlet(self.core_cfg, self.cfg_dir)))
 
-                self.logger.info(f"Crossbeats title server ready on port {self.game_cfg.server.port} & {self.game_cfg.server.port_secure}")
+            if self.core_cfg.server.is_develop and self.game_cfg.server.ssl_enable:
+                endpoints.serverFromString(
+                    reactor,
+                    f"ssl:{self.game_cfg.server.port_secure}"
+                    f":interface={self.core_cfg.server.listen_address}:privateKey={self.game_cfg.server.ssl_key}:"
+                    f"certKey={self.game_cfg.server.ssl_cert}",
+                ).listen(server.Site(CxbServlet(self.core_cfg, self.cfg_dir)))
+
+                self.logger.info(
+                    f"Crossbeats title server ready on port {self.game_cfg.server.port} & {self.game_cfg.server.port_secure}"
+                )
             else:
-                self.logger.info(f"Crossbeats title server ready on port {self.game_cfg.server.port}")
-    
+                self.logger.info(
+                    f"Crossbeats title server ready on port {self.game_cfg.server.port}"
+                )
 
     def render_POST(self, request: Request):
         version = 0
@@ -96,21 +120,28 @@ class CxbServlet(resource.Resource):
 
         except Exception as e:
             try:
-                req_json: Dict = json.loads(req_bytes.decode().replace('"', '\\"').replace("'", '"'))
+                req_json: Dict = json.loads(
+                    req_bytes.decode().replace('"', '\\"').replace("'", '"')
+                )
 
             except Exception as f:
-                self.logger.warn(f"Error decoding json: {e} / {f} - {req_url} - {req_bytes}")
+                self.logger.warn(
+                    f"Error decoding json: {e} / {f} - {req_url} - {req_bytes}"
+                )
                 return b""
-        
+
         if req_json == {}:
             self.logger.warn(f"Empty json request to {req_url}")
             return b""
-        
+
         cmd = url_split[len(url_split) - 1]
         subcmd = list(req_json.keys())[0]
 
         if subcmd == "dldate":
-            if not type(req_json["dldate"]) is dict or "filetype" not in req_json["dldate"]:
+            if (
+                not type(req_json["dldate"]) is dict
+                or "filetype" not in req_json["dldate"]
+            ):
                 self.logger.warn(f"Malformed dldate request: {req_url} {req_json}")
                 return b""
 
@@ -119,7 +150,9 @@ class CxbServlet(resource.Resource):
             version = int(filetype_split[0])
             filetype_inflect_split = inflection.underscore(filetype).split("/")
 
-            match = re.match("^([A-Za-z]*)(\d\d\d\d)$", filetype_split[len(filetype_split) - 1])
+            match = re.match(
+                "^([A-Za-z]*)(\d\d\d\d)$", filetype_split[len(filetype_split) - 1]
+            )
             if match:
                 subcmd = f"{inflection.underscore(match.group(1))}xxxx"
             else:
@@ -128,7 +161,7 @@ class CxbServlet(resource.Resource):
             filetype = subcmd
 
         func_to_find = f"handle_{cmd}_{subcmd}_request"
-        
+
         if version <= 10102:
             version_string = "Rev"
             internal_ver = CxbConstants.VER_CROSSBEATS_REV
@@ -136,28 +169,28 @@ class CxbServlet(resource.Resource):
         elif version == 10113 or version == 10103:
             version_string = "Rev SunriseS1"
             internal_ver = CxbConstants.VER_CROSSBEATS_REV_SUNRISE_S1
-            
+
         elif version >= 10114 or version == 10104:
             version_string = "Rev SunriseS2"
             internal_ver = CxbConstants.VER_CROSSBEATS_REV_SUNRISE_S2
-            
+
         else:
             version_string = "Base"
-            
+
         self.logger.info(f"{version_string} Request {req_url} -> {filetype}")
         self.logger.debug(req_json)
 
         try:
             handler = getattr(self.versions[internal_ver], func_to_find)
             resp = handler(req_json)
-        
-        except AttributeError as e: 
+
+        except AttributeError as e:
             self.logger.warning(f"Unhandled {version_string} request {req_url} - {e}")
             resp = {}
 
         except Exception as e:
             self.logger.error(f"Error handling {version_string} method {req_url} - {e}")
             raise
-        
-        self.logger.debug(f"{version_string} Response {resp}")        
+
+        self.logger.debug(f"{version_string} Response {resp}")
         return json.dumps(resp, ensure_ascii=False).encode("utf-8")

titles/cxb/read.py

@@ -8,13 +8,23 @@ from core.config import CoreConfig
 from titles.cxb.database import CxbData
 from titles.cxb.const import CxbConstants
 
+
 class CxbReader(BaseReader):
-    def __init__(self, config: CoreConfig, version: int, bin_arg: Optional[str], opt_arg: Optional[str], extra: Optional[str]) -> None:
+    def __init__(
+        self,
+        config: CoreConfig,
+        version: int,
+        bin_arg: Optional[str],
+        opt_arg: Optional[str],
+        extra: Optional[str],
+    ) -> None:
         super().__init__(config, version, bin_arg, opt_arg, extra)
         self.data = CxbData(config)
 
         try:
-            self.logger.info(f"Start importer for {CxbConstants.game_ver_to_string(version)}")
+            self.logger.info(
+                f"Start importer for {CxbConstants.game_ver_to_string(version)}"
+            )
         except IndexError:
             self.logger.error(f"Invalid project cxb version {version}")
             exit(1)
@@ -28,7 +38,7 @@ class CxbReader(BaseReader):
 
         if pull_bin_ram:
             self.read_csv(f"{self.bin_dir}")
-        
+
     def read_csv(self, bin_dir: str) -> None:
         self.logger.info(f"Read csv from {bin_dir}")
 
@@ -45,18 +55,73 @@ class CxbReader(BaseReader):
 
                     if not "N/A" in row["standard"]:
                         self.logger.info(f"Added song {song_id} chart 0")
-                        self.data.static.put_music(self.version, song_id, index, 0, title, artist, genre, int(row["standard"].replace("Standard ","").replace("N/A","0")))
+                        self.data.static.put_music(
+                            self.version,
+                            song_id,
+                            index,
+                            0,
+                            title,
+                            artist,
+                            genre,
+                            int(
+                                row["standard"]
+                                .replace("Standard ", "")
+                                .replace("N/A", "0")
+                            ),
+                        )
                     if not "N/A" in row["hard"]:
                         self.logger.info(f"Added song {song_id} chart 1")
-                        self.data.static.put_music(self.version, song_id, index, 1, title, artist, genre, int(row["hard"].replace("Hard ","").replace("N/A","0")))
+                        self.data.static.put_music(
+                            self.version,
+                            song_id,
+                            index,
+                            1,
+                            title,
+                            artist,
+                            genre,
+                            int(row["hard"].replace("Hard ", "").replace("N/A", "0")),
+                        )
                     if not "N/A" in row["master"]:
                         self.logger.info(f"Added song {song_id} chart 2")
-                        self.data.static.put_music(self.version, song_id, index, 2, title, artist, genre, int(row["master"].replace("Master ","").replace("N/A","0")))
+                        self.data.static.put_music(
+                            self.version,
+                            song_id,
+                            index,
+                            2,
+                            title,
+                            artist,
+                            genre,
+                            int(
+                                row["master"].replace("Master ", "").replace("N/A", "0")
+                            ),
+                        )
                     if not "N/A" in row["unlimited"]:
                         self.logger.info(f"Added song {song_id} chart 3")
-                        self.data.static.put_music(self.version, song_id, index, 3, title, artist, genre, int(row["unlimited"].replace("Unlimited ","").replace("N/A","0")))
+                        self.data.static.put_music(
+                            self.version,
+                            song_id,
+                            index,
+                            3,
+                            title,
+                            artist,
+                            genre,
+                            int(
+                                row["unlimited"]
+                                .replace("Unlimited ", "")
+                                .replace("N/A", "0")
+                            ),
+                        )
                     if not "N/A" in row["easy"]:
                         self.logger.info(f"Added song {song_id} chart 4")
-                        self.data.static.put_music(self.version, song_id, index, 4, title, artist, genre, int(row["easy"].replace("Easy ","").replace("N/A","0")))
+                        self.data.static.put_music(
+                            self.version,
+                            song_id,
+                            index,
+                            4,
+                            title,
+                            artist,
+                            genre,
+                            int(row["easy"].replace("Easy ", "").replace("N/A", "0")),
+                        )
         except:
             self.logger.warn(f"Couldn't read csv file in {self.bin_dir}, skipping")

titles/cxb/rev.py

@@ -11,155 +11,191 @@ from titles.cxb.config import CxbConfig
 from titles.cxb.base import CxbBase
 from titles.cxb.const import CxbConstants
 
+
 class CxbRev(CxbBase):
     def __init__(self, cfg: CoreConfig, game_cfg: CxbConfig) -> None:
         super().__init__(cfg, game_cfg)
         self.version = CxbConstants.VER_CROSSBEATS_REV
-        
+
     def handle_data_path_list_request(self, data: Dict) -> Dict:
-        return { "data": "" }
-        
+        return {"data": ""}
+
     def handle_data_putlog_request(self, data: Dict) -> Dict:
         if data["putlog"]["type"] == "ResultLog":
             score_data = json.loads(data["putlog"]["data"])
-            userid = score_data['usid']
+            userid = score_data["usid"]
 
-            self.data.score.put_playlog(userid, score_data['mcode'], score_data['difficulty'], score_data["score"], int(Decimal(score_data["clearrate"]) * 100), score_data["flawless"], score_data["super"], score_data["cool"], score_data["fast"], score_data["fast2"], score_data["slow"], score_data["slow2"], score_data["fail"], score_data["combo"])
-            return({"data":True})
-        return {"data": True }
+            self.data.score.put_playlog(
+                userid,
+                score_data["mcode"],
+                score_data["difficulty"],
+                score_data["score"],
+                int(Decimal(score_data["clearrate"]) * 100),
+                score_data["flawless"],
+                score_data["super"],
+                score_data["cool"],
+                score_data["fast"],
+                score_data["fast2"],
+                score_data["slow"],
+                score_data["slow2"],
+                score_data["fail"],
+                score_data["combo"],
+            )
+            return {"data": True}
+        return {"data": True}
 
-    @cached(lifetime=86400)    
+    @cached(lifetime=86400)
     def handle_data_music_list_request(self, data: Dict) -> Dict:
         ret_str = ""
         with open(r"titles/cxb/rev_data/MusicArchiveList.csv") as music:
             lines = music.readlines()
             for line in lines:
-                line_split = line.split(',')
+                line_split = line.split(",")
                 ret_str += f"{line_split[0]},{line_split[1]},{line_split[2]},{line_split[3]},{line_split[4]},{line_split[5]},{line_split[6]},{line_split[7]},{line_split[8]},{line_split[9]},{line_split[10]},{line_split[11]},{line_split[12]},{line_split[13]},{line_split[14]},\r\n"
-                
-        return({"data":ret_str})
-    
+
+        return {"data": ret_str}
+
     @cached(lifetime=86400)
     def handle_data_item_list_icon_request(self, data: Dict) -> Dict:
         ret_str = "\r\n#ItemListIcon\r\n"
-        with open(r"titles/cxb/rev_data/Item/ItemArchiveList_Icon.csv", encoding="utf-8") as item:
+        with open(
+            r"titles/cxb/rev_data/Item/ItemArchiveList_Icon.csv", encoding="utf-8"
+        ) as item:
             lines = item.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
+        return {"data": ret_str}
 
-    @cached(lifetime=86400)    
+    @cached(lifetime=86400)
     def handle_data_item_list_skin_notes_request(self, data: Dict) -> Dict:
         ret_str = "\r\n#ItemListSkinNotes\r\n"
-        with open(r"titles/cxb/rev_data/Item/ItemArchiveList_SkinNotes.csv", encoding="utf-8") as item:
+        with open(
+            r"titles/cxb/rev_data/Item/ItemArchiveList_SkinNotes.csv", encoding="utf-8"
+        ) as item:
             lines = item.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
+        return {"data": ret_str}
 
-    @cached(lifetime=86400)    
+    @cached(lifetime=86400)
     def handle_data_item_list_skin_effect_request(self, data: Dict) -> Dict:
         ret_str = "\r\n#ItemListSkinEffect\r\n"
-        with open(r"titles/cxb/rev_data/Item/ItemArchiveList_SkinEffect.csv", encoding="utf-8") as item:
+        with open(
+            r"titles/cxb/rev_data/Item/ItemArchiveList_SkinEffect.csv", encoding="utf-8"
+        ) as item:
             lines = item.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
+        return {"data": ret_str}
 
-    @cached(lifetime=86400)    
+    @cached(lifetime=86400)
     def handle_data_item_list_skin_bg_request(self, data: Dict) -> Dict:
         ret_str = "\r\n#ItemListSkinBg\r\n"
-        with open(r"titles/cxb/rev_data/Item/ItemArchiveList_SkinBg.csv", encoding="utf-8") as item:
+        with open(
+            r"titles/cxb/rev_data/Item/ItemArchiveList_SkinBg.csv", encoding="utf-8"
+        ) as item:
             lines = item.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
+        return {"data": ret_str}
 
-    @cached(lifetime=86400)    
+    @cached(lifetime=86400)
     def handle_data_item_list_title_request(self, data: Dict) -> Dict:
         ret_str = "\r\n#ItemListTitle\r\n"
-        with open(r"titles/cxb/rev_data/Item/ItemList_Title.csv", encoding="shift-jis") as item:
+        with open(
+            r"titles/cxb/rev_data/Item/ItemList_Title.csv", encoding="shift-jis"
+        ) as item:
             lines = item.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
+        return {"data": ret_str}
 
-    @cached(lifetime=86400)    
+    @cached(lifetime=86400)
     def handle_data_shop_list_music_request(self, data: Dict) -> Dict:
         ret_str = "\r\n#ShopListMusic\r\n"
-        with open(r"titles/cxb/rev_data/Shop/ShopList_Music.csv", encoding="shift-jis") as shop:
+        with open(
+            r"titles/cxb/rev_data/Shop/ShopList_Music.csv", encoding="shift-jis"
+        ) as shop:
             lines = shop.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
+        return {"data": ret_str}
 
-    @cached(lifetime=86400)    
+    @cached(lifetime=86400)
     def handle_data_shop_list_icon_request(self, data: Dict) -> Dict:
         ret_str = "\r\n#ShopListIcon\r\n"
-        with open(r"titles/cxb/rev_data/Shop/ShopList_Icon.csv", encoding="shift-jis") as shop:
+        with open(
+            r"titles/cxb/rev_data/Shop/ShopList_Icon.csv", encoding="shift-jis"
+        ) as shop:
             lines = shop.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
+        return {"data": ret_str}
 
-    @cached(lifetime=86400)    
+    @cached(lifetime=86400)
     def handle_data_shop_list_title_request(self, data: Dict) -> Dict:
         ret_str = "\r\n#ShopListTitle\r\n"
-        with open(r"titles/cxb/rev_data/Shop/ShopList_Title.csv", encoding="shift-jis") as shop:
+        with open(
+            r"titles/cxb/rev_data/Shop/ShopList_Title.csv", encoding="shift-jis"
+        ) as shop:
             lines = shop.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
-        
-    def handle_data_shop_list_skin_hud_request(self, data: Dict) -> Dict:
-        return({"data":""})
-        
-    def handle_data_shop_list_skin_arrow_request(self, data: Dict) -> Dict:
-        return({"data":""})
-        
-    def handle_data_shop_list_skin_hit_request(self, data: Dict) -> Dict:
-        return({"data":""})
+        return {"data": ret_str}
 
-    @cached(lifetime=86400)    
+    def handle_data_shop_list_skin_hud_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    def handle_data_shop_list_skin_arrow_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    def handle_data_shop_list_skin_hit_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    @cached(lifetime=86400)
     def handle_data_shop_list_sale_request(self, data: Dict) -> Dict:
         ret_str = "\r\n#ShopListSale\r\n"
-        with open(r"titles/cxb/rev_data/Shop/ShopList_Sale.csv", encoding="shift-jis") as shop:
+        with open(
+            r"titles/cxb/rev_data/Shop/ShopList_Sale.csv", encoding="shift-jis"
+        ) as shop:
             lines = shop.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
+        return {"data": ret_str}
 
     def handle_data_extra_stage_list_request(self, data: Dict) -> Dict:
-        return({"data":""})
+        return {"data": ""}
 
-    @cached(lifetime=86400)    
+    @cached(lifetime=86400)
     def handle_data_exxxxx_request(self, data: Dict) -> Dict:
         extra_num = int(data["dldate"]["filetype"][-4:])
         ret_str = ""
-        with open(fr"titles/cxb/rev_data/Ex000{extra_num}.csv", encoding="shift-jis") as stage:
+        with open(
+            rf"titles/cxb/rev_data/Ex000{extra_num}.csv", encoding="shift-jis"
+        ) as stage:
             lines = stage.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
-        
-    def handle_data_bonus_list10100_request(self, data: Dict) -> Dict:
-        return({"data": ""})
-        
-    def handle_data_free_coupon_request(self, data: Dict) -> Dict:
-        return({"data": ""})
+        return {"data": ret_str}
 
-    @cached(lifetime=86400)    
+    def handle_data_bonus_list10100_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    def handle_data_free_coupon_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    @cached(lifetime=86400)
     def handle_data_news_list_request(self, data: Dict) -> Dict:
         ret_str = ""
         with open(r"titles/cxb/rev_data/NewsList.csv", encoding="UTF-8") as news:
             lines = news.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
-        
+        return {"data": ret_str}
+
     def handle_data_tips_request(self, data: Dict) -> Dict:
-        return({"data":""})
-    
+        return {"data": ""}
+
     @cached(lifetime=86400)
     def handle_data_license_request(self, data: Dict) -> Dict:
         ret_str = ""
@@ -167,90 +203,104 @@ class CxbRev(CxbBase):
             lines = lic.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
+        return {"data": ret_str}
 
-    @cached(lifetime=86400)    
+    @cached(lifetime=86400)
     def handle_data_course_list_request(self, data: Dict) -> Dict:
         ret_str = ""
-        with open(r"titles/cxb/rev_data/Course/CourseList.csv", encoding="UTF-8") as course:
+        with open(
+            r"titles/cxb/rev_data/Course/CourseList.csv", encoding="UTF-8"
+        ) as course:
             lines = course.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
+        return {"data": ret_str}
 
-    @cached(lifetime=86400)    
+    @cached(lifetime=86400)
     def handle_data_csxxxx_request(self, data: Dict) -> Dict:
         # Removed the CSVs since the format isnt quite right
         extra_num = int(data["dldate"]["filetype"][-4:])
         ret_str = ""
-        with open(fr"titles/cxb/rev_data/Course/Cs000{extra_num}.csv", encoding="shift-jis") as course:
+        with open(
+            rf"titles/cxb/rev_data/Course/Cs000{extra_num}.csv", encoding="shift-jis"
+        ) as course:
             lines = course.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
+        return {"data": ret_str}
 
-    @cached(lifetime=86400)    
+    @cached(lifetime=86400)
     def handle_data_mission_list_request(self, data: Dict) -> Dict:
         ret_str = ""
-        with open(r"titles/cxb/rev_data/MissionList.csv", encoding="shift-jis") as mission:
+        with open(
+            r"titles/cxb/rev_data/MissionList.csv", encoding="shift-jis"
+        ) as mission:
             lines = mission.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
-        
-    def handle_data_mission_bonus_request(self, data: Dict) -> Dict:
-        return({"data": ""})
-        
-    def handle_data_unlimited_mission_request(self, data: Dict) -> Dict:
-        return({"data": ""})
+        return {"data": ret_str}
 
-    @cached(lifetime=86400)    
+    def handle_data_mission_bonus_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    def handle_data_unlimited_mission_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    @cached(lifetime=86400)
     def handle_data_event_list_request(self, data: Dict) -> Dict:
         ret_str = ""
-        with open(r"titles/cxb/rev_data/Event/EventArchiveList.csv", encoding="shift-jis") as mission:
+        with open(
+            r"titles/cxb/rev_data/Event/EventArchiveList.csv", encoding="shift-jis"
+        ) as mission:
             lines = mission.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
+        return {"data": ret_str}
 
     def handle_data_event_music_list_request(self, data: Dict) -> Dict:
-        return({"data": ""})
-        
-    def handle_data_event_mission_list_request(self, data: Dict) -> Dict:
-        return({"data": ""})
-        
-    def handle_data_event_achievement_single_high_score_list_request(self, data: Dict) -> Dict:
-        return({"data": ""})
-        
-    def handle_data_event_achievement_single_accumulation_request(self, data: Dict) -> Dict:
-        return({"data": ""})
-        
-    def handle_data_event_ranking_high_score_list_request(self, data: Dict) -> Dict:
-        return({"data": ""})
-        
-    def handle_data_event_ranking_accumulation_list_request(self, data: Dict) -> Dict:
-        return({"data": ""})
-        
-    def handle_data_event_ranking_stamp_list_request(self, data: Dict) -> Dict:
-        return({"data": ""})
-        
-    def handle_data_event_ranking_store_list_request(self, data: Dict) -> Dict:
-        return({"data": ""})
-        
-    def handle_data_event_ranking_area_list_request(self, data: Dict) -> Dict:
-        return({"data": ""})
+        return {"data": ""}
 
-    @cached(lifetime=86400)    
+    def handle_data_event_mission_list_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    def handle_data_event_achievement_single_high_score_list_request(
+        self, data: Dict
+    ) -> Dict:
+        return {"data": ""}
+
+    def handle_data_event_achievement_single_accumulation_request(
+        self, data: Dict
+    ) -> Dict:
+        return {"data": ""}
+
+    def handle_data_event_ranking_high_score_list_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    def handle_data_event_ranking_accumulation_list_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    def handle_data_event_ranking_stamp_list_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    def handle_data_event_ranking_store_list_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    def handle_data_event_ranking_area_list_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    @cached(lifetime=86400)
     def handle_data_event_stamp_list_request(self, data: Dict) -> Dict:
         ret_str = ""
-        with open(r"titles/cxb/rev_data/Event/EventStampList.csv", encoding="shift-jis") as event:
+        with open(
+            r"titles/cxb/rev_data/Event/EventStampList.csv", encoding="shift-jis"
+        ) as event:
             lines = event.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
-        
+        return {"data": ret_str}
+
     def handle_data_event_stamp_map_list_csxxxx_request(self, data: Dict) -> Dict:
-        return({"data": "1,2,1,1,2,3,9,5,6,7,8,9,10,\r\n"})
-        
+        return {"data": "1,2,1,1,2,3,9,5,6,7,8,9,10,\r\n"}
+
     def handle_data_server_state_request(self, data: Dict) -> Dict:
-        return({"data": True})
+        return {"data": True}

titles/cxb/rss1.py

@@ -11,128 +11,147 @@ from titles.cxb.config import CxbConfig
 from titles.cxb.base import CxbBase
 from titles.cxb.const import CxbConstants
 
+
 class CxbRevSunriseS1(CxbBase):
     def __init__(self, cfg: CoreConfig, game_cfg: CxbConfig) -> None:
         super().__init__(cfg, game_cfg)
         self.version = CxbConstants.VER_CROSSBEATS_REV_SUNRISE_S1
-        
-    def handle_data_path_list_request(self, data: Dict) -> Dict:
-        return { "data": "" }
 
-    @cached(lifetime=86400)    
+    def handle_data_path_list_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    @cached(lifetime=86400)
     def handle_data_music_list_request(self, data: Dict) -> Dict:
         ret_str = ""
         with open(r"titles/cxb/rss1_data/MusicArchiveList.csv") as music:
             lines = music.readlines()
             for line in lines:
-                line_split = line.split(',')
+                line_split = line.split(",")
                 ret_str += f"{line_split[0]},{line_split[1]},{line_split[2]},{line_split[3]},{line_split[4]},{line_split[5]},{line_split[6]},{line_split[7]},{line_split[8]},{line_split[9]},{line_split[10]},{line_split[11]},{line_split[12]},{line_split[13]},{line_split[14]},\r\n"
-                
-        return({"data":ret_str})
 
-    @cached(lifetime=86400)    
+        return {"data": ret_str}
+
+    @cached(lifetime=86400)
     def handle_data_item_list_detail_request(self, data: Dict) -> Dict:
-        #ItemListIcon load
+        # ItemListIcon load
         ret_str = "#ItemListIcon\r\n"
-        with open(r"titles/cxb/rss1_data/Item/ItemList_Icon.csv", encoding="shift-jis") as item:
+        with open(
+            r"titles/cxb/rss1_data/Item/ItemList_Icon.csv", encoding="shift-jis"
+        ) as item:
             lines = item.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
 
-        #ItemListTitle load
+        # ItemListTitle load
         ret_str += "\r\n#ItemListTitle\r\n"
-        with open(r"titles/cxb/rss1_data/Item/ItemList_Title.csv", encoding="shift-jis") as item:
+        with open(
+            r"titles/cxb/rss1_data/Item/ItemList_Title.csv", encoding="shift-jis"
+        ) as item:
             lines = item.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
 
-        return({"data":ret_str})
+        return {"data": ret_str}
 
-    @cached(lifetime=86400)    
+    @cached(lifetime=86400)
     def handle_data_shop_list_detail_request(self, data: Dict) -> Dict:
-        #ShopListIcon load
+        # ShopListIcon load
         ret_str = "#ShopListIcon\r\n"
-        with open(r"titles/cxb/rss1_data/Shop/ShopList_Icon.csv", encoding="utf-8") as shop:
+        with open(
+            r"titles/cxb/rss1_data/Shop/ShopList_Icon.csv", encoding="utf-8"
+        ) as shop:
             lines = shop.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-                            
-        #ShopListMusic load
-        ret_str += "\r\n#ShopListMusic\r\n"
-        with open(r"titles/cxb/rss1_data/Shop/ShopList_Music.csv", encoding="utf-8") as shop:
-            lines = shop.readlines()
-            for line in lines:
-                ret_str += f"{line[:-1]}\r\n"
-                        
-        #ShopListSale load
-        ret_str += "\r\n#ShopListSale\r\n"
-        with open(r"titles/cxb/rss1_data/Shop/ShopList_Sale.csv", encoding="shift-jis") as shop:
-            lines = shop.readlines()
-            for line in lines:
-                ret_str += f"{line[:-1]}\r\n"
-                            
-        #ShopListSkinBg load
-        ret_str += "\r\n#ShopListSkinBg\r\n"
-        with open(r"titles/cxb/rss1_data/Shop/ShopList_SkinBg.csv", encoding="shift-jis") as shop:
-            lines = shop.readlines()
-            for line in lines:
-                ret_str += f"{line[:-1]}\r\n"
-                            
-        #ShopListSkinEffect load
-        ret_str += "\r\n#ShopListSkinEffect\r\n"
-        with open(r"titles/cxb/rss1_data/Shop/ShopList_SkinEffect.csv", encoding="shift-jis") as shop:
-            lines = shop.readlines()
-            for line in lines:
-                ret_str += f"{line[:-1]}\r\n"
-                            
-        #ShopListSkinNotes load
-        ret_str += "\r\n#ShopListSkinNotes\r\n"
-        with open(r"titles/cxb/rss1_data/Shop/ShopList_SkinNotes.csv", encoding="shift-jis") as shop:
-            lines = shop.readlines()
-            for line in lines:
-                ret_str += f"{line[:-1]}\r\n"
-                            
-        #ShopListTitle load
-        ret_str += "\r\n#ShopListTitle\r\n"
-        with open(r"titles/cxb/rss1_data/Shop/ShopList_Title.csv", encoding="utf-8") as shop:
-            lines = shop.readlines()
-            for line in lines:
-                ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
-        
-    def handle_data_extra_stage_list_request(self, data: Dict) -> Dict:
-        return({"data":""})
-        
-    def handle_data_ex0001_request(self, data: Dict) -> Dict:
-        return({"data":""})
-        
-    def handle_data_one_more_extra_list_request(self, data: Dict) -> Dict:
-        return({"data":""})
-        
-    def handle_data_bonus_list10100_request(self, data: Dict) -> Dict:
-        return({"data":""})
-        
-    def handle_data_oe0001_request(self, data: Dict) -> Dict:
-        return({"data":""})
-        
-    def handle_data_free_coupon_request(self, data: Dict) -> Dict:
-        return({"data":""})
 
-    @cached(lifetime=86400)    
+        # ShopListMusic load
+        ret_str += "\r\n#ShopListMusic\r\n"
+        with open(
+            r"titles/cxb/rss1_data/Shop/ShopList_Music.csv", encoding="utf-8"
+        ) as shop:
+            lines = shop.readlines()
+            for line in lines:
+                ret_str += f"{line[:-1]}\r\n"
+
+        # ShopListSale load
+        ret_str += "\r\n#ShopListSale\r\n"
+        with open(
+            r"titles/cxb/rss1_data/Shop/ShopList_Sale.csv", encoding="shift-jis"
+        ) as shop:
+            lines = shop.readlines()
+            for line in lines:
+                ret_str += f"{line[:-1]}\r\n"
+
+        # ShopListSkinBg load
+        ret_str += "\r\n#ShopListSkinBg\r\n"
+        with open(
+            r"titles/cxb/rss1_data/Shop/ShopList_SkinBg.csv", encoding="shift-jis"
+        ) as shop:
+            lines = shop.readlines()
+            for line in lines:
+                ret_str += f"{line[:-1]}\r\n"
+
+        # ShopListSkinEffect load
+        ret_str += "\r\n#ShopListSkinEffect\r\n"
+        with open(
+            r"titles/cxb/rss1_data/Shop/ShopList_SkinEffect.csv", encoding="shift-jis"
+        ) as shop:
+            lines = shop.readlines()
+            for line in lines:
+                ret_str += f"{line[:-1]}\r\n"
+
+        # ShopListSkinNotes load
+        ret_str += "\r\n#ShopListSkinNotes\r\n"
+        with open(
+            r"titles/cxb/rss1_data/Shop/ShopList_SkinNotes.csv", encoding="shift-jis"
+        ) as shop:
+            lines = shop.readlines()
+            for line in lines:
+                ret_str += f"{line[:-1]}\r\n"
+
+        # ShopListTitle load
+        ret_str += "\r\n#ShopListTitle\r\n"
+        with open(
+            r"titles/cxb/rss1_data/Shop/ShopList_Title.csv", encoding="utf-8"
+        ) as shop:
+            lines = shop.readlines()
+            for line in lines:
+                ret_str += f"{line[:-1]}\r\n"
+        return {"data": ret_str}
+
+    def handle_data_extra_stage_list_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    def handle_data_ex0001_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    def handle_data_one_more_extra_list_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    def handle_data_bonus_list10100_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    def handle_data_oe0001_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    def handle_data_free_coupon_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    @cached(lifetime=86400)
     def handle_data_news_list_request(self, data: Dict) -> Dict:
         ret_str = ""
         with open(r"titles/cxb/rss1_data/NewsList.csv", encoding="UTF-8") as news:
             lines = news.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
+        return {"data": ret_str}
 
     def handle_data_tips_request(self, data: Dict) -> Dict:
-        return({"data":""})
-        
+        return {"data": ""}
+
     def handle_data_release_info_list_request(self, data: Dict) -> Dict:
-        return({"data":""})
-    
+        return {"data": ""}
+
     @cached(lifetime=86400)
     def handle_data_random_music_list_request(self, data: Dict) -> Dict:
         ret_str = ""
@@ -141,10 +160,12 @@ class CxbRevSunriseS1(CxbBase):
             count = 0
             for line in lines:
                 line_split = line.split(",")
-                ret_str += str(count) + "," + line_split[0] + "," + line_split[0] + ",\r\n"
+                ret_str += (
+                    str(count) + "," + line_split[0] + "," + line_split[0] + ",\r\n"
+                )
+
+        return {"data": ret_str}
 
-        return({"data":ret_str})
-    
     @cached(lifetime=86400)
     def handle_data_license_request(self, data: Dict) -> Dict:
         ret_str = ""
@@ -152,54 +173,58 @@ class CxbRevSunriseS1(CxbBase):
             lines = licenses.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
-    
+        return {"data": ret_str}
+
     @cached(lifetime=86400)
     def handle_data_course_list_request(self, data: Dict) -> Dict:
         ret_str = ""
-        with open(r"titles/cxb/rss1_data/Course/CourseList.csv", encoding="UTF-8") as course:
+        with open(
+            r"titles/cxb/rss1_data/Course/CourseList.csv", encoding="UTF-8"
+        ) as course:
             lines = course.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
+        return {"data": ret_str}
 
     @cached(lifetime=86400)
     def handle_data_csxxxx_request(self, data: Dict) -> Dict:
         extra_num = int(data["dldate"]["filetype"][-4:])
         ret_str = ""
-        with open(fr"titles/cxb/rss1_data/Course/Cs{extra_num}.csv", encoding="shift-jis") as course:
+        with open(
+            rf"titles/cxb/rss1_data/Course/Cs{extra_num}.csv", encoding="shift-jis"
+        ) as course:
             lines = course.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
-        
+        return {"data": ret_str}
+
     def handle_data_mission_list_request(self, data: Dict) -> Dict:
-        return({"data":""})
-        
+        return {"data": ""}
+
     def handle_data_mission_bonus_request(self, data: Dict) -> Dict:
-        return({"data":""})
-        
+        return {"data": ""}
+
     def handle_data_unlimited_mission_request(self, data: Dict) -> Dict:
-        return({"data":""})
-        
+        return {"data": ""}
+
     def handle_data_partner_list_request(self, data: Dict) -> Dict:
         ret_str = ""
         # Lord forgive me for the sins I am about to commit
-        for i in range(0,10):
+        for i in range(0, 10):
             ret_str += f"80000{i},{i},{i},0,10000,,\r\n"
             ret_str += f"80000{i},{i},{i},1,10500,,\r\n"
             ret_str += f"80000{i},{i},{i},2,10500,,\r\n"
-        for i in range(10,13):
+        for i in range(10, 13):
             ret_str += f"8000{i},{i},{i},0,10000,,\r\n"
             ret_str += f"8000{i},{i},{i},1,10500,,\r\n"
             ret_str += f"8000{i},{i},{i},2,10500,,\r\n"
-        ret_str +="\r\n---\r\n0,150,100,100,100,100,\r\n"
-        for i in range(1,130):
-            ret_str +=f"{i},100,100,100,100,100,\r\n"
-                    
+        ret_str += "\r\n---\r\n0,150,100,100,100,100,\r\n"
+        for i in range(1, 130):
+            ret_str += f"{i},100,100,100,100,100,\r\n"
+
         ret_str += "---\r\n"
-        return({"data": ret_str})
-    
+        return {"data": ret_str}
+
     @cached(lifetime=86400)
     def handle_data_partnerxxxx_request(self, data: Dict) -> Dict:
         partner_num = int(data["dldate"]["filetype"][-4:])
@@ -208,50 +233,54 @@ class CxbRevSunriseS1(CxbBase):
             lines = partner.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data": ret_str})
-    
+        return {"data": ret_str}
+
     def handle_data_server_state_request(self, data: Dict) -> Dict:
-        return({"data": True})
-    
+        return {"data": True}
+
     def handle_data_settings_request(self, data: Dict) -> Dict:
-        return({"data": "2,\r\n"})
+        return {"data": "2,\r\n"}
 
     def handle_data_story_list_request(self, data: Dict) -> Dict:
-        #story id, story name, game version, start time, end time, course arc, unlock flag, song mcode for menu
+        # story id, story name, game version, start time, end time, course arc, unlock flag, song mcode for menu
         ret_str = "\r\n"
-        ret_str += f"st0000,RISING PURPLE,10104,1464370990,4096483201,Cs1000,-1,purple,\r\n"
-        ret_str += f"st0001,REBEL YELL,10104,1467999790,4096483201,Cs1000,-1,chaset,\r\n"
+        ret_str += (
+            f"st0000,RISING PURPLE,10104,1464370990,4096483201,Cs1000,-1,purple,\r\n"
+        )
+        ret_str += (
+            f"st0001,REBEL YELL,10104,1467999790,4096483201,Cs1000,-1,chaset,\r\n"
+        )
         ret_str += f"st0002,REMNANT,10104,1502127790,4096483201,Cs1000,-1,overcl,\r\n"
-        return({"data": ret_str})
-        
+        return {"data": ret_str}
+
     def handle_data_stxxxx_request(self, data: Dict) -> Dict:
         story_num = int(data["dldate"]["filetype"][-4:])
         ret_str = ""
-        for i in range(1,11):
-            ret_str +=f"{i},st000{story_num}_{i-1},,,,,,,,,,,,,,,,1,,-1,1,\r\n"
-        return({"data": ret_str})
+        for i in range(1, 11):
+            ret_str += f"{i},st000{story_num}_{i-1},,,,,,,,,,,,,,,,1,,-1,1,\r\n"
+        return {"data": ret_str}
 
     def handle_data_event_stamp_list_request(self, data: Dict) -> Dict:
-        return({"data":"Cs1032,1,1,1,1,1,1,1,1,1,1,\r\n"})
+        return {"data": "Cs1032,1,1,1,1,1,1,1,1,1,1,\r\n"}
 
     def handle_data_premium_list_request(self, data: Dict) -> Dict:
-        return({"data": "1,,,,10,,,,,99,,,,,,,,,100,,\r\n"})
+        return {"data": "1,,,,10,,,,,99,,,,,,,,,100,,\r\n"}
 
     def handle_data_event_list_request(self, data: Dict) -> Dict:
-        return({"data":""})
+        return {"data": ""}
 
     def handle_data_event_detail_list_request(self, data: Dict) -> Dict:
         event_id = data["dldate"]["filetype"].split("/")[2]
         if "EventStampMapListCs1002" in event_id:
-            return({"data":"1,2,1,1,2,3,9,5,6,7,8,9,10,\r\n"})
+            return {"data": "1,2,1,1,2,3,9,5,6,7,8,9,10,\r\n"}
         elif "EventStampList" in event_id:
-            return({"data":"Cs1002,1,1,1,1,1,1,1,1,1,1,\r\n"})
+            return {"data": "Cs1002,1,1,1,1,1,1,1,1,1,1,\r\n"}
         else:
-            return({"data":""})
-    
+            return {"data": ""}
+
     def handle_data_event_stamp_map_list_csxxxx_request(self, data: Dict) -> Dict:
         event_id = data["dldate"]["filetype"].split("/")[2]
         if "EventStampMapListCs1002" in event_id:
-            return({"data":"1,2,1,1,2,3,9,5,6,7,8,9,10,\r\n"})
+            return {"data": "1,2,1,1,2,3,9,5,6,7,8,9,10,\r\n"}
         else:
-            return({"data":""})
+            return {"data": ""}

titles/cxb/rss2.py

@@ -11,128 +11,147 @@ from titles.cxb.config import CxbConfig
 from titles.cxb.base import CxbBase
 from titles.cxb.const import CxbConstants
 
+
 class CxbRevSunriseS2(CxbBase):
     def __init__(self, cfg: CoreConfig, game_cfg: CxbConfig) -> None:
         super().__init__(cfg, game_cfg)
         self.version = CxbConstants.VER_CROSSBEATS_REV_SUNRISE_S2_OMNI
-        
-    def handle_data_path_list_request(self, data: Dict) -> Dict:
-        return { "data": "" }
 
-    @cached(lifetime=86400)    
+    def handle_data_path_list_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    @cached(lifetime=86400)
     def handle_data_music_list_request(self, data: Dict) -> Dict:
         ret_str = ""
         with open(r"titles/cxb/rss2_data/MusicArchiveList.csv") as music:
             lines = music.readlines()
             for line in lines:
-                line_split = line.split(',')
+                line_split = line.split(",")
                 ret_str += f"{line_split[0]},{line_split[1]},{line_split[2]},{line_split[3]},{line_split[4]},{line_split[5]},{line_split[6]},{line_split[7]},{line_split[8]},{line_split[9]},{line_split[10]},{line_split[11]},{line_split[12]},{line_split[13]},{line_split[14]},\r\n"
-                
-        return({"data":ret_str})
 
-    @cached(lifetime=86400)    
+        return {"data": ret_str}
+
+    @cached(lifetime=86400)
     def handle_data_item_list_detail_request(self, data: Dict) -> Dict:
-        #ItemListIcon load
+        # ItemListIcon load
         ret_str = "#ItemListIcon\r\n"
-        with open(r"titles/cxb/rss2_data/Item/ItemList_Icon.csv", encoding="utf-8") as item:
+        with open(
+            r"titles/cxb/rss2_data/Item/ItemList_Icon.csv", encoding="utf-8"
+        ) as item:
             lines = item.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-                            
-        #ItemListTitle load
+
+        # ItemListTitle load
         ret_str += "\r\n#ItemListTitle\r\n"
-        with open(r"titles/cxb/rss2_data/Item/ItemList_Title.csv", encoding="utf-8") as item:
+        with open(
+            r"titles/cxb/rss2_data/Item/ItemList_Title.csv", encoding="utf-8"
+        ) as item:
             lines = item.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
 
-        return({"data":ret_str})
+        return {"data": ret_str}
 
-    @cached(lifetime=86400)    
+    @cached(lifetime=86400)
     def handle_data_shop_list_detail_request(self, data: Dict) -> Dict:
-        #ShopListIcon load
+        # ShopListIcon load
         ret_str = "#ShopListIcon\r\n"
-        with open(r"titles/cxb/rss2_data/Shop/ShopList_Icon.csv", encoding="utf-8") as shop:
+        with open(
+            r"titles/cxb/rss2_data/Shop/ShopList_Icon.csv", encoding="utf-8"
+        ) as shop:
             lines = shop.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-                            
-        #ShopListMusic load
-        ret_str += "\r\n#ShopListMusic\r\n"
-        with open(r"titles/cxb/rss2_data/Shop/ShopList_Music.csv", encoding="utf-8") as shop:
-            lines = shop.readlines()
-            for line in lines:
-                ret_str += f"{line[:-1]}\r\n"
-                        
-        #ShopListSale load
-        ret_str += "\r\n#ShopListSale\r\n"
-        with open(r"titles/cxb/rss2_data/Shop/ShopList_Sale.csv", encoding="shift-jis") as shop:
-            lines = shop.readlines()
-            for line in lines:
-                ret_str += f"{line[:-1]}\r\n"
-                            
-        #ShopListSkinBg load
-        ret_str += "\r\n#ShopListSkinBg\r\n"
-        with open(r"titles/cxb/rss2_data/Shop/ShopList_SkinBg.csv", encoding="shift-jis") as shop:
-            lines = shop.readlines()
-            for line in lines:
-                ret_str += f"{line[:-1]}\r\n"
-                            
-        #ShopListSkinEffect load
-        ret_str += "\r\n#ShopListSkinEffect\r\n"
-        with open(r"titles/cxb/rss2_data/Shop/ShopList_SkinEffect.csv", encoding="shift-jis") as shop:
-            lines = shop.readlines()
-            for line in lines:
-                ret_str += f"{line[:-1]}\r\n"
-                            
-        #ShopListSkinNotes load
-        ret_str += "\r\n#ShopListSkinNotes\r\n"
-        with open(r"titles/cxb/rss2_data/Shop/ShopList_SkinNotes.csv", encoding="shift-jis") as shop:
-            lines = shop.readlines()
-            for line in lines:
-                ret_str += f"{line[:-1]}\r\n"
-                            
-        #ShopListTitle load
-        ret_str += "\r\n#ShopListTitle\r\n"
-        with open(r"titles/cxb/rss2_data/Shop/ShopList_Title.csv", encoding="utf-8") as shop:
-            lines = shop.readlines()
-            for line in lines:
-                ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
-        
-    def handle_data_extra_stage_list_request(self, data: Dict) -> Dict:
-        return({"data":""})
-        
-    def handle_data_ex0001_request(self, data: Dict) -> Dict:
-        return({"data":""})
-        
-    def handle_data_one_more_extra_list_request(self, data: Dict) -> Dict:
-        return({"data":""})
-        
-    def handle_data_bonus_list10100_request(self, data: Dict) -> Dict:
-        return({"data":""})
-        
-    def handle_data_oe0001_request(self, data: Dict) -> Dict:
-        return({"data":""})
-        
-    def handle_data_free_coupon_request(self, data: Dict) -> Dict:
-        return({"data":""})
 
-    @cached(lifetime=86400)    
+        # ShopListMusic load
+        ret_str += "\r\n#ShopListMusic\r\n"
+        with open(
+            r"titles/cxb/rss2_data/Shop/ShopList_Music.csv", encoding="utf-8"
+        ) as shop:
+            lines = shop.readlines()
+            for line in lines:
+                ret_str += f"{line[:-1]}\r\n"
+
+        # ShopListSale load
+        ret_str += "\r\n#ShopListSale\r\n"
+        with open(
+            r"titles/cxb/rss2_data/Shop/ShopList_Sale.csv", encoding="shift-jis"
+        ) as shop:
+            lines = shop.readlines()
+            for line in lines:
+                ret_str += f"{line[:-1]}\r\n"
+
+        # ShopListSkinBg load
+        ret_str += "\r\n#ShopListSkinBg\r\n"
+        with open(
+            r"titles/cxb/rss2_data/Shop/ShopList_SkinBg.csv", encoding="shift-jis"
+        ) as shop:
+            lines = shop.readlines()
+            for line in lines:
+                ret_str += f"{line[:-1]}\r\n"
+
+        # ShopListSkinEffect load
+        ret_str += "\r\n#ShopListSkinEffect\r\n"
+        with open(
+            r"titles/cxb/rss2_data/Shop/ShopList_SkinEffect.csv", encoding="shift-jis"
+        ) as shop:
+            lines = shop.readlines()
+            for line in lines:
+                ret_str += f"{line[:-1]}\r\n"
+
+        # ShopListSkinNotes load
+        ret_str += "\r\n#ShopListSkinNotes\r\n"
+        with open(
+            r"titles/cxb/rss2_data/Shop/ShopList_SkinNotes.csv", encoding="shift-jis"
+        ) as shop:
+            lines = shop.readlines()
+            for line in lines:
+                ret_str += f"{line[:-1]}\r\n"
+
+        # ShopListTitle load
+        ret_str += "\r\n#ShopListTitle\r\n"
+        with open(
+            r"titles/cxb/rss2_data/Shop/ShopList_Title.csv", encoding="utf-8"
+        ) as shop:
+            lines = shop.readlines()
+            for line in lines:
+                ret_str += f"{line[:-1]}\r\n"
+        return {"data": ret_str}
+
+    def handle_data_extra_stage_list_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    def handle_data_ex0001_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    def handle_data_one_more_extra_list_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    def handle_data_bonus_list10100_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    def handle_data_oe0001_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    def handle_data_free_coupon_request(self, data: Dict) -> Dict:
+        return {"data": ""}
+
+    @cached(lifetime=86400)
     def handle_data_news_list_request(self, data: Dict) -> Dict:
         ret_str = ""
         with open(r"titles/cxb/rss2_data/NewsList.csv", encoding="UTF-8") as news:
             lines = news.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
+        return {"data": ret_str}
 
     def handle_data_tips_request(self, data: Dict) -> Dict:
-        return({"data":""})
-        
+        return {"data": ""}
+
     def handle_data_release_info_list_request(self, data: Dict) -> Dict:
-        return({"data":""})
-    
+        return {"data": ""}
+
     @cached(lifetime=86400)
     def handle_data_random_music_list_request(self, data: Dict) -> Dict:
         ret_str = ""
@@ -141,10 +160,12 @@ class CxbRevSunriseS2(CxbBase):
             count = 0
             for line in lines:
                 line_split = line.split(",")
-                ret_str += str(count) + "," + line_split[0] + "," + line_split[0] + ",\r\n"
+                ret_str += (
+                    str(count) + "," + line_split[0] + "," + line_split[0] + ",\r\n"
+                )
+
+        return {"data": ret_str}
 
-        return({"data":ret_str})
-    
     @cached(lifetime=86400)
     def handle_data_license_request(self, data: Dict) -> Dict:
         ret_str = ""
@@ -152,54 +173,58 @@ class CxbRevSunriseS2(CxbBase):
             lines = licenses.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
-    
+        return {"data": ret_str}
+
     @cached(lifetime=86400)
     def handle_data_course_list_request(self, data: Dict) -> Dict:
         ret_str = ""
-        with open(r"titles/cxb/rss2_data/Course/CourseList.csv", encoding="UTF-8") as course:
+        with open(
+            r"titles/cxb/rss2_data/Course/CourseList.csv", encoding="UTF-8"
+        ) as course:
             lines = course.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
+        return {"data": ret_str}
 
     @cached(lifetime=86400)
     def handle_data_csxxxx_request(self, data: Dict) -> Dict:
         extra_num = int(data["dldate"]["filetype"][-4:])
         ret_str = ""
-        with open(fr"titles/cxb/rss2_data/Course/Cs{extra_num}.csv", encoding="shift-jis") as course:
+        with open(
+            rf"titles/cxb/rss2_data/Course/Cs{extra_num}.csv", encoding="shift-jis"
+        ) as course:
             lines = course.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data":ret_str})
-        
+        return {"data": ret_str}
+
     def handle_data_mission_list_request(self, data: Dict) -> Dict:
-        return({"data":""})
-        
+        return {"data": ""}
+
     def handle_data_mission_bonus_request(self, data: Dict) -> Dict:
-        return({"data":""})
-        
+        return {"data": ""}
+
     def handle_data_unlimited_mission_request(self, data: Dict) -> Dict:
-        return({"data":""})
-        
+        return {"data": ""}
+
     def handle_data_partner_list_request(self, data: Dict) -> Dict:
         ret_str = ""
         # Lord forgive me for the sins I am about to commit
-        for i in range(0,10):
+        for i in range(0, 10):
             ret_str += f"80000{i},{i},{i},0,10000,,\r\n"
             ret_str += f"80000{i},{i},{i},1,10500,,\r\n"
             ret_str += f"80000{i},{i},{i},2,10500,,\r\n"
-        for i in range(10,13):
+        for i in range(10, 13):
             ret_str += f"8000{i},{i},{i},0,10000,,\r\n"
             ret_str += f"8000{i},{i},{i},1,10500,,\r\n"
             ret_str += f"8000{i},{i},{i},2,10500,,\r\n"
-        ret_str +="\r\n---\r\n0,150,100,100,100,100,\r\n"
-        for i in range(1,130):
-            ret_str +=f"{i},100,100,100,100,100,\r\n"
-                    
+        ret_str += "\r\n---\r\n0,150,100,100,100,100,\r\n"
+        for i in range(1, 130):
+            ret_str += f"{i},100,100,100,100,100,\r\n"
+
         ret_str += "---\r\n"
-        return({"data": ret_str})
-    
+        return {"data": ret_str}
+
     @cached(lifetime=86400)
     def handle_data_partnerxxxx_request(self, data: Dict) -> Dict:
         partner_num = int(data["dldate"]["filetype"][-4:])
@@ -208,55 +233,65 @@ class CxbRevSunriseS2(CxbBase):
             lines = partner.readlines()
             for line in lines:
                 ret_str += f"{line[:-1]}\r\n"
-        return({"data": ret_str})
-    
+        return {"data": ret_str}
+
     def handle_data_server_state_request(self, data: Dict) -> Dict:
-        return({"data": True})
-    
+        return {"data": True}
+
     def handle_data_settings_request(self, data: Dict) -> Dict:
-        return({"data": "2,\r\n"})
+        return {"data": "2,\r\n"}
 
     def handle_data_story_list_request(self, data: Dict) -> Dict:
-        #story id, story name, game version, start time, end time, course arc, unlock flag, song mcode for menu
+        # story id, story name, game version, start time, end time, course arc, unlock flag, song mcode for menu
         ret_str = "\r\n"
-        ret_str += f"st0000,RISING PURPLE,10104,1464370990,4096483201,Cs1000,-1,purple,\r\n"
-        ret_str += f"st0001,REBEL YELL,10104,1467999790,4096483201,Cs1000,-1,chaset,\r\n"
+        ret_str += (
+            f"st0000,RISING PURPLE,10104,1464370990,4096483201,Cs1000,-1,purple,\r\n"
+        )
+        ret_str += (
+            f"st0001,REBEL YELL,10104,1467999790,4096483201,Cs1000,-1,chaset,\r\n"
+        )
         ret_str += f"st0002,REMNANT,10104,1502127790,4096483201,Cs1000,-1,overcl,\r\n"
-        return({"data": ret_str})
-        
+        return {"data": ret_str}
+
     def handle_data_stxxxx_request(self, data: Dict) -> Dict:
         story_num = int(data["dldate"]["filetype"][-4:])
         ret_str = ""
         # Each stories appears to have 10 pieces based on the wiki but as on how they are set.... no clue
-        for i in range(1,11):
-            ret_str +=f"{i},st000{story_num}_{i-1},,,,,,,,,,,,,,,,1,,-1,1,\r\n"
-        return({"data": ret_str})
+        for i in range(1, 11):
+            ret_str += f"{i},st000{story_num}_{i-1},,,,,,,,,,,,,,,,1,,-1,1,\r\n"
+        return {"data": ret_str}
 
     def handle_data_event_stamp_list_request(self, data: Dict) -> Dict:
-        return({"data":"Cs1002,1,1,1,1,1,1,1,1,1,1,\r\n"})
+        return {"data": "Cs1002,1,1,1,1,1,1,1,1,1,1,\r\n"}
 
     def handle_data_premium_list_request(self, data: Dict) -> Dict:
-        return({"data": "1,,,,10,,,,,99,,,,,,,,,100,,\r\n"})
+        return {"data": "1,,,,10,,,,,99,,,,,,,,,100,,\r\n"}
 
     def handle_data_event_list_request(self, data: Dict) -> Dict:
-        return({"data":"Cs4001,0,10000,1601510400,1604188799,1,nv2006,1,\r\nCs4005,0,10000,1609459200,1615766399,1,nv2006,1,\r\n"})
+        return {
+            "data": "Cs4001,0,10000,1601510400,1604188799,1,nv2006,1,\r\nCs4005,0,10000,1609459200,1615766399,1,nv2006,1,\r\n"
+        }
 
     def handle_data_event_detail_list_request(self, data: Dict) -> Dict:
         event_id = data["dldate"]["filetype"].split("/")[2]
         if "Cs4001" in event_id:
-            return({"data":"#EventMusicList\r\n1,zonzon2,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,\r\n2,moonki,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,\r\n3,tricko,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,\r\n"})
+            return {
+                "data": "#EventMusicList\r\n1,zonzon2,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,\r\n2,moonki,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,\r\n3,tricko,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,\r\n"
+            }
         elif "Cs4005" in event_id:
-            return({"data":"#EventMusicList\r\n2,firstl,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,\r\n2,valent,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,\r\n2,dazzli2,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,\r\n"})
+            return {
+                "data": "#EventMusicList\r\n2,firstl,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,\r\n2,valent,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,\r\n2,dazzli2,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,\r\n"
+            }
         elif "EventStampMapListCs1002" in event_id:
-            return({"data":"1,2,1,1,2,3,9,5,6,7,8,9,10,\r\n"})
+            return {"data": "1,2,1,1,2,3,9,5,6,7,8,9,10,\r\n"}
         elif "EventStampList" in event_id:
-            return({"data":"Cs1002,1,1,1,1,1,1,1,1,1,1,\r\n"})
+            return {"data": "Cs1002,1,1,1,1,1,1,1,1,1,1,\r\n"}
         else:
-            return({"data":""})
-    
+            return {"data": ""}
+
     def handle_data_event_stamp_map_list_csxxxx_request(self, data: Dict) -> Dict:
         event_id = data["dldate"]["filetype"].split("/")[2]
         if "EventStampMapListCs1002" in event_id:
-            return({"data":"1,2,1,1,2,3,9,5,6,7,8,9,10,\r\n"})
+            return {"data": "1,2,1,1,2,3,9,5,6,7,8,9,10,\r\n"}
         else:
-            return({"data":""})
+            return {"data": ""}

titles/cxb/schema/item.py

@@ -14,32 +14,29 @@ energy = Table(
     Column("user", ForeignKey("aime_user.id", ondelete="cascade"), nullable=False),
     Column("energy", Integer, nullable=False, server_default="0"),
     UniqueConstraint("user", name="cxb_rev_energy_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
-class CxbItemData(BaseData):    
-    def put_energy(self, user_id: int, rev_energy: int) -> Optional[int]:
-        sql = insert(energy).values(
-            user = user_id,
-            energy = rev_energy 
-        )
 
-        conflict = sql.on_duplicate_key_update(
-            energy = rev_energy
-        )
+class CxbItemData(BaseData):
+    def put_energy(self, user_id: int, rev_energy: int) -> Optional[int]:
+        sql = insert(energy).values(user=user_id, energy=rev_energy)
+
+        conflict = sql.on_duplicate_key_update(energy=rev_energy)
 
         result = self.execute(conflict)
         if result is None:
-            self.logger.error(f"{__name__} failed to insert item! user: {user_id}, energy: {rev_energy}")
+            self.logger.error(
+                f"{__name__} failed to insert item! user: {user_id}, energy: {rev_energy}"
+            )
             return None
-        
+
         return result.lastrowid
-    
+
     def get_energy(self, user_id: int) -> Optional[Dict]:
-        sql = energy.select(
-            and_(energy.c.user == user_id)
-        )
+        sql = energy.select(and_(energy.c.user == user_id))
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchone()

titles/cxb/schema/profile.py

@@ -16,57 +16,63 @@ profile = Table(
     Column("index", Integer, nullable=False),
     Column("data", JSON, nullable=False),
     UniqueConstraint("user", "index", name="cxb_profile_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
+
 class CxbProfileData(BaseData):
-    def put_profile(self, user_id: int, version: int, index: int, data: JSON) -> Optional[int]:
+    def put_profile(
+        self, user_id: int, version: int, index: int, data: JSON
+    ) -> Optional[int]:
         sql = insert(profile).values(
-            user = user_id,
-            version = version,
-            index = index,
-            data = data 
+            user=user_id, version=version, index=index, data=data
         )
 
-        conflict = sql.on_duplicate_key_update(
-            index = index,
-            data = data
-        )
+        conflict = sql.on_duplicate_key_update(index=index, data=data)
 
         result = self.execute(conflict)
         if result is None:
-            self.logger.error(f"{__name__} failed to update! user: {user_id}, index: {index}, data: {data}")
+            self.logger.error(
+                f"{__name__} failed to update! user: {user_id}, index: {index}, data: {data}"
+            )
             return None
-        
+
         return result.lastrowid
 
     def get_profile(self, aime_id: int, version: int) -> Optional[List[Dict]]:
         """
         Given a game version and either a profile or aime id, return the profile
         """
-        sql = profile.select(and_(
-                profile.c.version == version,
-                profile.c.user == aime_id
-            ))
-        
+        sql = profile.select(
+            and_(profile.c.version == version, profile.c.user == aime_id)
+        )
+
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
 
-    def get_profile_index(self, index: int, aime_id: int = None, version: int = None) -> Optional[Dict]:
+    def get_profile_index(
+        self, index: int, aime_id: int = None, version: int = None
+    ) -> Optional[Dict]:
         """
         Given a game version and either a profile or aime id, return the profile
         """
         if aime_id is not None and version is not None and index is not None:
-            sql = profile.select(and_(
+            sql = profile.select(
+                and_(
                     profile.c.version == version,
                     profile.c.user == aime_id,
-                    profile.c.index == index
-                ))
+                    profile.c.index == index,
+                )
+            )
         else:
-            self.logger.error(f"get_profile: Bad arguments!! aime_id {aime_id} version {version}")
+            self.logger.error(
+                f"get_profile: Bad arguments!! aime_id {aime_id} version {version}"
+            )
             return None
-        
+
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchone()

titles/cxb/schema/score.py

@@ -18,7 +18,7 @@ score = Table(
     Column("song_index", Integer),
     Column("data", JSON),
     UniqueConstraint("user", "song_mcode", "song_index", name="cxb_score_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 playlog = Table(
@@ -40,7 +40,7 @@ playlog = Table(
     Column("fail", Integer),
     Column("combo", Integer),
     Column("date_scored", TIMESTAMP, server_default=func.now()),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 ranking = Table(
@@ -53,11 +53,19 @@ ranking = Table(
     Column("score", Integer),
     Column("clear", Integer),
     UniqueConstraint("user", "rev_id", name="cxb_ranking_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
+
 class CxbScoreData(BaseData):
-    def put_best_score(self, user_id: int, song_mcode: str, game_version: int, song_index: int, data: JSON) -> Optional[int]:
+    def put_best_score(
+        self,
+        user_id: int,
+        song_mcode: str,
+        game_version: int,
+        song_index: int,
+        data: JSON,
+    ) -> Optional[int]:
         """
         Update the user's best score for a chart
         """
@@ -66,22 +74,37 @@ class CxbScoreData(BaseData):
             song_mcode=song_mcode,
             game_version=game_version,
             song_index=song_index,
-            data=data
+            data=data,
         )
 
-        conflict = sql.on_duplicate_key_update(
-            data = sql.inserted.data
-        )
+        conflict = sql.on_duplicate_key_update(data=sql.inserted.data)
 
         result = self.execute(conflict)
         if result is None:
-            self.logger.error(f"{__name__} failed to insert best score! profile: {user_id}, song: {song_mcode}, data: {data}")
+            self.logger.error(
+                f"{__name__} failed to insert best score! profile: {user_id}, song: {song_mcode}, data: {data}"
+            )
             return None
-        
+
         return result.lastrowid
-    
-    def put_playlog(self, user_id: int, song_mcode: str, chart_id: int, score: int, clear: int, flawless: int, this_super: int, 
-        cool: int, this_fast: int, this_fast2: int, this_slow: int, this_slow2: int, fail: int, combo: int) -> Optional[int]:
+
+    def put_playlog(
+        self,
+        user_id: int,
+        song_mcode: str,
+        chart_id: int,
+        score: int,
+        clear: int,
+        flawless: int,
+        this_super: int,
+        cool: int,
+        this_fast: int,
+        this_fast2: int,
+        this_slow: int,
+        this_slow2: int,
+        fail: int,
+        combo: int,
+    ) -> Optional[int]:
         """
         Add an entry to the user's play log
         """
@@ -99,45 +122,42 @@ class CxbScoreData(BaseData):
             slow=this_slow,
             slow2=this_slow2,
             fail=fail,
-            combo=combo
+            combo=combo,
         )
 
         result = self.execute(sql)
         if result is None:
-            self.logger.error(f"{__name__} failed to insert playlog! profile: {user_id}, song: {song_mcode}, chart: {chart_id}")
+            self.logger.error(
+                f"{__name__} failed to insert playlog! profile: {user_id}, song: {song_mcode}, chart: {chart_id}"
+            )
             return None
-        
+
         return result.lastrowid
 
-    def put_ranking(self, user_id: int, rev_id: int, song_id: int, score: int, clear: int) -> Optional[int]:
+    def put_ranking(
+        self, user_id: int, rev_id: int, song_id: int, score: int, clear: int
+    ) -> Optional[int]:
         """
         Add an entry to the user's ranking logs
         """
         if song_id == 0:
             sql = insert(ranking).values(
-                user=user_id,
-                rev_id=rev_id,
-                score=score,
-                clear=clear
+                user=user_id, rev_id=rev_id, score=score, clear=clear
             )
         else:
             sql = insert(ranking).values(
-                user=user_id,
-                rev_id=rev_id,
-                song_id=song_id,
-                score=score,
-                clear=clear
+                user=user_id, rev_id=rev_id, song_id=song_id, score=score, clear=clear
             )
-            
-        conflict = sql.on_duplicate_key_update(
-            score = score
-        )
+
+        conflict = sql.on_duplicate_key_update(score=score)
 
         result = self.execute(conflict)
         if result is None:
-            self.logger.error(f"{__name__} failed to insert ranking log! profile: {user_id}, score: {score}, clear: {clear}")
+            self.logger.error(
+                f"{__name__} failed to insert ranking log! profile: {user_id}, score: {score}, clear: {clear}"
+            )
             return None
-        
+
         return result.lastrowid
 
     def get_best_score(self, user_id: int, song_mcode: int) -> Optional[Dict]:
@@ -146,21 +166,22 @@ class CxbScoreData(BaseData):
         )
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchone()
 
     def get_best_scores(self, user_id: int) -> Optional[Dict]:
         sql = score.select(score.c.user == user_id)
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
 
     def get_best_rankings(self, user_id: int) -> Optional[List[Dict]]:
-        sql = ranking.select(
-            ranking.c.user == user_id
-        )
+        sql = ranking.select(ranking.c.user == user_id)
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()

titles/cxb/schema/static.py

@@ -21,54 +21,75 @@ music = Table(
     Column("artist", String(255)),
     Column("category", String(255)),
     Column("level", Float),
-    UniqueConstraint("version", "songId", "chartId", "index", name="cxb_static_music_uk"),
-    mysql_charset='utf8mb4'
+    UniqueConstraint(
+        "version", "songId", "chartId", "index", name="cxb_static_music_uk"
+    ),
+    mysql_charset="utf8mb4",
 )
 
+
 class CxbStaticData(BaseData):
-    def put_music(self, version: int, mcode: str, index: int, chart: int, title: str, artist: str, category: str, level: float ) -> Optional[int]:
+    def put_music(
+        self,
+        version: int,
+        mcode: str,
+        index: int,
+        chart: int,
+        title: str,
+        artist: str,
+        category: str,
+        level: float,
+    ) -> Optional[int]:
         sql = insert(music).values(
-            version = version,
-            songId = mcode,
-            index = index,
-            chartId = chart,
-            title = title,
-            artist = artist,
-            category = category,
-            level = level
+            version=version,
+            songId=mcode,
+            index=index,
+            chartId=chart,
+            title=title,
+            artist=artist,
+            category=category,
+            level=level,
         )
 
         conflict = sql.on_duplicate_key_update(
-            title = title,
-            artist = artist,
-            category = category,
-            level = level
+            title=title, artist=artist, category=category, level=level
         )
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
-    
-    def get_music(self, version: int, song_id: Optional[int] = None) -> Optional[List[Row]]:
+
+    def get_music(
+        self, version: int, song_id: Optional[int] = None
+    ) -> Optional[List[Row]]:
         if song_id is None:
             sql = select(music).where(music.c.version == version)
         else:
-            sql = select(music).where(and_(
-            music.c.version == version,
-            music.c.songId == song_id,
-            ))
+            sql = select(music).where(
+                and_(
+                    music.c.version == version,
+                    music.c.songId == song_id,
+                )
+            )
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
-    
-    def get_music_chart(self, version: int, song_id: int, chart_id: int) -> Optional[List[Row]]:
-        sql = select(music).where(and_(
-            music.c.version == version,
-            music.c.songId == song_id,
-            music.c.chartId == chart_id
-            ))
+
+    def get_music_chart(
+        self, version: int, song_id: int, chart_id: int
+    ) -> Optional[List[Row]]:
+        sql = select(music).where(
+            and_(
+                music.c.version == version,
+                music.c.songId == song_id,
+                music.c.chartId == chart_id,
+            )
+        )
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchone()

titles/diva/__init__.py

@@ -7,4 +7,4 @@ index = DivaServlet
 database = DivaData
 reader = DivaReader
 game_codes = [DivaConstants.GAME_CODE]
-current_schema_version = 1
+current_schema_version = 1

titles/diva/base.py

@@ -1,6 +1,6 @@
 import datetime
 from typing import Any, List, Dict
-import logging 
+import logging
 import json
 import urllib
 
@@ -9,34 +9,35 @@ from titles.diva.config import DivaConfig
 from titles.diva.const import DivaConstants
 from titles.diva.database import DivaData
 
-class DivaBase():
+
+class DivaBase:
     def __init__(self, cfg: CoreConfig, game_cfg: DivaConfig) -> None:
-        self.core_cfg = cfg # Config file
+        self.core_cfg = cfg  # Config file
         self.game_config = game_cfg
-        self.data = DivaData(cfg) # Database
+        self.data = DivaData(cfg)  # Database
         self.date_time_format = "%Y-%m-%d %H:%M:%S"
         self.logger = logging.getLogger("diva")
         self.game = DivaConstants.GAME_CODE
         self.version = DivaConstants.VER_PROJECT_DIVA_ARCADE_FUTURE_TONE
 
         dt = datetime.datetime.now()
-        self.time_lut=urllib.parse.quote(dt.strftime("%Y-%m-%d %H:%M:%S:16.0"))
-    
+        self.time_lut = urllib.parse.quote(dt.strftime("%Y-%m-%d %H:%M:%S:16.0"))
+
     def handle_test_request(self, data: Dict) -> Dict:
         return ""
 
     def handle_game_init_request(self, data: Dict) -> Dict:
-        return ( f'' )
+        return f""
 
     def handle_attend_request(self, data: Dict) -> Dict:
         encoded = "&"
         params = {
-            'atnd_prm1': '0,1,1,0,0,0,1,0,100,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1', 
-            'atnd_prm2': '30,10,100,4,1,50,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1',
-            'atnd_prm3': '100,0,1,1,1,1,1,1,1,1,2,3,4,1,1,1,3,4,5,1,1,1,4,5,6,1,1,1,5,6,7,4,4,4,9,10,14,5,10,10,25,20,50,30,90,5,10,10,25,20,50,30,90,5,10,10,25,20,50,30,90,5,10,10,25,20,50,30,90,5,10,10,25,20,50,30,90,10,30,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0',
-            'atnd_lut': f'{self.time_lut}',
+            "atnd_prm1": "0,1,1,0,0,0,1,0,100,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1",
+            "atnd_prm2": "30,10,100,4,1,50,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1",
+            "atnd_prm3": "100,0,1,1,1,1,1,1,1,1,2,3,4,1,1,1,3,4,5,1,1,1,4,5,6,1,1,1,5,6,7,4,4,4,9,10,14,5,10,10,25,20,50,30,90,5,10,10,25,20,50,30,90,5,10,10,25,20,50,30,90,5,10,10,25,20,50,30,90,5,10,10,25,20,50,30,90,10,30,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0",
+            "atnd_lut": f"{self.time_lut}",
         }
-        
+
         encoded += urllib.parse.urlencode(params)
         encoded = encoded.replace("%2C", ",")
 
@@ -45,42 +46,42 @@ class DivaBase():
     def handle_ping_request(self, data: Dict) -> Dict:
         encoded = "&"
         params = {
-            'ping_b_msg': f'Welcome to {self.core_cfg.server.name} network!', 
-            'ping_m_msg': 'xxx',
-            'atnd_lut': f'{self.time_lut}',
-            'fi_lut': f'{self.time_lut}',
-            'ci_lut': f'{self.time_lut}',
-            'qi_lut': f'{self.time_lut}',
-            'pvl_lut': '2021-05-22 12:08:16.0',
-            'shp_ctlg_lut': '2020-06-10 19:44:16.0',
-            'cstmz_itm_ctlg_lut': '2019-10-08 20:23:12.0',
-            'ngwl_lut': '2019-10-08 20:23:12.0',
-            'rnk_nv_lut': '2020-06-10 19:51:30.0',
-            'rnk_ps_lut': f'{self.time_lut}',
-            'bi_lut': '2020-09-18 10:00:00.0',
-            'cpi_lut': '2020-10-25 09:25:10.0',
-            'bdlol_lut': '2020-09-18 10:00:00.0',
-            'p_std_hc_lut': '2019-08-01 04:00:36.0',
-            'p_std_i_n_lut': '2019-08-01 04:00:36.0',
-            'pdcl_lut': '2019-08-01 04:00:36.0',
-            'pnml_lut': '2019-08-01 04:00:36.0',
-            'cinml_lut': '2019-08-01 04:00:36.0',
-            'rwl_lut': '2019-08-01 04:00:36.0',
-            'req_inv_cmd_num': '-1,-1,-1,-1,-1,-1,-1,-1,-1,-1',
-            'req_inv_cmd_prm1': '-1,-1,-1,-1,-1,-1,-1,-1,-1,-1',
-            'req_inv_cmd_prm2': '-1,-1,-1,-1,-1,-1,-1,-1,-1,-1',
-            'req_inv_cmd_prm3': '-1,-1,-1,-1,-1,-1,-1,-1,-1,-1',
-            'req_inv_cmd_prm4': '-1,-1,-1,-1,-1,-1,-1,-1,-1,-1',
-            'pow_save_flg': 0,
-            'nblss_dnt_p': 100,
-            'nblss_ltt_rl_vp': 1500,
-            'nblss_ex_ltt_flg': 1,
-            'nblss_dnt_st_tm': "2019-07-15 12:00:00.0",
-            'nblss_dnt_ed_tm': "2019-09-17 12:00:00.0",
-            'nblss_ltt_st_tm': "2019-09-18 12:00:00.0",
-            'nblss_ltt_ed_tm': "2019-09-22 12:00:00.0",
+            "ping_b_msg": f"Welcome to {self.core_cfg.server.name} network!",
+            "ping_m_msg": "xxx",
+            "atnd_lut": f"{self.time_lut}",
+            "fi_lut": f"{self.time_lut}",
+            "ci_lut": f"{self.time_lut}",
+            "qi_lut": f"{self.time_lut}",
+            "pvl_lut": "2021-05-22 12:08:16.0",
+            "shp_ctlg_lut": "2020-06-10 19:44:16.0",
+            "cstmz_itm_ctlg_lut": "2019-10-08 20:23:12.0",
+            "ngwl_lut": "2019-10-08 20:23:12.0",
+            "rnk_nv_lut": "2020-06-10 19:51:30.0",
+            "rnk_ps_lut": f"{self.time_lut}",
+            "bi_lut": "2020-09-18 10:00:00.0",
+            "cpi_lut": "2020-10-25 09:25:10.0",
+            "bdlol_lut": "2020-09-18 10:00:00.0",
+            "p_std_hc_lut": "2019-08-01 04:00:36.0",
+            "p_std_i_n_lut": "2019-08-01 04:00:36.0",
+            "pdcl_lut": "2019-08-01 04:00:36.0",
+            "pnml_lut": "2019-08-01 04:00:36.0",
+            "cinml_lut": "2019-08-01 04:00:36.0",
+            "rwl_lut": "2019-08-01 04:00:36.0",
+            "req_inv_cmd_num": "-1,-1,-1,-1,-1,-1,-1,-1,-1,-1",
+            "req_inv_cmd_prm1": "-1,-1,-1,-1,-1,-1,-1,-1,-1,-1",
+            "req_inv_cmd_prm2": "-1,-1,-1,-1,-1,-1,-1,-1,-1,-1",
+            "req_inv_cmd_prm3": "-1,-1,-1,-1,-1,-1,-1,-1,-1,-1",
+            "req_inv_cmd_prm4": "-1,-1,-1,-1,-1,-1,-1,-1,-1,-1",
+            "pow_save_flg": 0,
+            "nblss_dnt_p": 100,
+            "nblss_ltt_rl_vp": 1500,
+            "nblss_ex_ltt_flg": 1,
+            "nblss_dnt_st_tm": "2019-07-15 12:00:00.0",
+            "nblss_dnt_ed_tm": "2019-09-17 12:00:00.0",
+            "nblss_ltt_st_tm": "2019-09-18 12:00:00.0",
+            "nblss_ltt_ed_tm": "2019-09-22 12:00:00.0",
         }
-        
+
         encoded += urllib.parse.urlencode(params)
         encoded = encoded.replace("+", "%20")
         encoded = encoded.replace("%2C", ",")
@@ -122,7 +123,7 @@ class DivaBase():
         response += f"&pvl_lut={self.time_lut}"
         response += f"&pv_lst={pvlist}"
 
-        return ( response )
+        return response
 
     def handle_shop_catalog_request(self, data: Dict) -> Dict:
         catalog = ""
@@ -137,7 +138,21 @@ class DivaBase():
 
         else:
             for shop in shopList:
-                line = str(shop["shopId"]) + "," + str(shop['unknown_0']) + "," + shop['name'] + "," + str(shop['points']) + "," + shop['start_date'] + "," + shop['end_date'] + "," + str(shop["type"])
+                line = (
+                    str(shop["shopId"])
+                    + ","
+                    + str(shop["unknown_0"])
+                    + ","
+                    + shop["name"]
+                    + ","
+                    + str(shop["points"])
+                    + ","
+                    + shop["start_date"]
+                    + ","
+                    + shop["end_date"]
+                    + ","
+                    + str(shop["type"])
+                )
                 line = urllib.parse.quote(line) + ","
                 catalog += f"{urllib.parse.quote(line)}"
 
@@ -146,7 +161,7 @@ class DivaBase():
         response = f"&shp_ctlg_lut={self.time_lut}"
         response += f"&shp_ctlg={catalog[:-3]}"
 
-        return ( response )
+        return response
 
     def handle_buy_module_request(self, data: Dict) -> Dict:
         profile = self.data.profile.get_profile(data["pd_id"], self.version)
@@ -162,10 +177,7 @@ class DivaBase():
 
         new_vcld_pts = profile["vcld_pts"] - int(data["mdl_price"])
 
-        self.data.profile.update_profile(
-            profile["user"],
-            vcld_pts=new_vcld_pts
-        )
+        self.data.profile.update_profile(profile["user"], vcld_pts=new_vcld_pts)
         self.data.module.put_module(data["pd_id"], self.version, data["mdl_id"])
 
         # generate the mdl_have string
@@ -191,7 +203,21 @@ class DivaBase():
 
         else:
             for item in itemList:
-                line = str(item["itemId"]) + "," + str(item['unknown_0']) + "," + item['name'] + "," + str(item['points']) + "," + item['start_date'] + "," + item['end_date'] + "," + str(item["type"])
+                line = (
+                    str(item["itemId"])
+                    + ","
+                    + str(item["unknown_0"])
+                    + ","
+                    + item["name"]
+                    + ","
+                    + str(item["points"])
+                    + ","
+                    + item["start_date"]
+                    + ","
+                    + item["end_date"]
+                    + ","
+                    + str(item["type"])
+                )
                 line = urllib.parse.quote(line) + ","
                 catalog += f"{urllib.parse.quote(line)}"
 
@@ -200,11 +226,13 @@ class DivaBase():
         response = f"&cstmz_itm_ctlg_lut={self.time_lut}"
         response += f"&cstmz_itm_ctlg={catalog[:-3]}"
 
-        return ( response )
+        return response
 
     def handle_buy_cstmz_itm_request(self, data: Dict) -> Dict:
         profile = self.data.profile.get_profile(data["pd_id"], self.version)
-        item = self.data.static.get_enabled_item(self.version, int(data["cstmz_itm_id"]))
+        item = self.data.static.get_enabled_item(
+            self.version, int(data["cstmz_itm_id"])
+        )
 
         # make sure module is available to purchase
         if not item:
@@ -217,15 +245,16 @@ class DivaBase():
         new_vcld_pts = profile["vcld_pts"] - int(data["cstmz_itm_price"])
 
         # save new Vocaloid Points balance
-        self.data.profile.update_profile(
-            profile["user"],
-            vcld_pts=new_vcld_pts
+        self.data.profile.update_profile(profile["user"], vcld_pts=new_vcld_pts)
+
+        self.data.customize.put_customize_item(
+            data["pd_id"], self.version, data["cstmz_itm_id"]
         )
 
-        self.data.customize.put_customize_item(data["pd_id"], self.version, data["cstmz_itm_id"])
-
         # generate the cstmz_itm_have string
-        cstmz_itm_have = self.data.customize.get_customize_items_have_string(data["pd_id"], self.version)
+        cstmz_itm_have = self.data.customize.get_customize_items_have_string(
+            data["pd_id"], self.version
+        )
 
         response = "&shp_rslt=1"
         response += f"&cstmz_itm_id={data['cstmz_itm_id']}"
@@ -237,33 +266,33 @@ class DivaBase():
     def handle_festa_info_request(self, data: Dict) -> Dict:
         encoded = "&"
         params = {
-            'fi_id': '1,-1',
-            'fi_name': f'{self.core_cfg.server.name} Opening,xxx',
-            'fi_kind': '0,0',
-            'fi_difficulty': '-1,-1',
-            'fi_pv_id_lst': 'ALL,ALL',
-            'fi_attr': '7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF',
-            'fi_add_vp': '20,0',
-            'fi_mul_vp': '1,1',
-            'fi_st': '2022-06-17 17:00:00.0,2014-07-08 18:10:11.0',
-            'fi_et': '2029-01-01 10:00:00.0,2014-07-08 18:10:11.0',
-            'fi_lut': '{self.time_lut}',
+            "fi_id": "1,-1",
+            "fi_name": f"{self.core_cfg.server.name} Opening,xxx",
+            "fi_kind": "0,0",
+            "fi_difficulty": "-1,-1",
+            "fi_pv_id_lst": "ALL,ALL",
+            "fi_attr": "7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
+            "fi_add_vp": "20,0",
+            "fi_mul_vp": "1,1",
+            "fi_st": "2022-06-17 17:00:00.0,2014-07-08 18:10:11.0",
+            "fi_et": "2029-01-01 10:00:00.0,2014-07-08 18:10:11.0",
+            "fi_lut": "{self.time_lut}",
         }
-        
+
         encoded += urllib.parse.urlencode(params)
         encoded = encoded.replace("+", "%20")
         encoded = encoded.replace("%2C", ",")
 
         return encoded
-        
+
     def handle_contest_info_request(self, data: Dict) -> Dict:
         response = ""
 
         response += f"&ci_lut={self.time_lut}"
         response += "&ci_str=%2A%2A%2A,%2A%2A%2A,%2A%2A%2A,%2A%2A%2A,%2A%2A%2A,%2A%2A%2A,%2A%2A%2A,%2A%2A%2A"
-        
-        return ( response )
-        
+
+        return response
+
     def handle_qst_inf_request(self, data: Dict) -> Dict:
         quest = ""
 
@@ -279,11 +308,31 @@ class DivaBase():
             response += f"&qhi_str={quest[:-1]}"
         else:
             for quests in questList:
-                line = str(quests["questId"]) + "," + str(quests['quest_order']) + "," + str(quests['kind']) + "," + str(quests['unknown_0']) + "," + quests['start_datetime'] + "," + quests['end_datetime'] + "," + quests["name"] + "," + str(quests["unknown_1"]) + "," + str(quests["unknown_2"]) + "," + str(quests["quest_enable"])
+                line = (
+                    str(quests["questId"])
+                    + ","
+                    + str(quests["quest_order"])
+                    + ","
+                    + str(quests["kind"])
+                    + ","
+                    + str(quests["unknown_0"])
+                    + ","
+                    + quests["start_datetime"]
+                    + ","
+                    + quests["end_datetime"]
+                    + ","
+                    + quests["name"]
+                    + ","
+                    + str(quests["unknown_1"])
+                    + ","
+                    + str(quests["unknown_2"])
+                    + ","
+                    + str(quests["quest_enable"])
+                )
                 quest += f"{urllib.parse.quote(line)}%0A,"
 
             responseline = f"{quest[:-1]},"
-            for i in range(len(questList),59):
+            for i in range(len(questList), 59):
                 responseline += "%2A%2A%2A%0A,"
 
             response = ""
@@ -292,44 +341,44 @@ class DivaBase():
 
         response += "&qrai_str=%2D1%2C%2D1%2C%2D1%2C%2D1%2C%2D1%2C%2D1%2C%2D1%2C%2D1%2C%2D1%2C%2D1%2C%2D1,%2D1%2C%2D1%2C%2D1%2C%2D1%2C%2D1%2C%2D1%2C%2D1%2C%2D1%2C%2D1%2C%2D1%2C%2D1,%2D1%2C%2D1%2C%2D1%2C%2D1%2C%2D1%2C%2D1%2C%2D1%2C%2D1%2C%2D1%2C%2D1%2C%2D1"
 
-        return ( response )
-        
+        return response
+
     def handle_nv_ranking_request(self, data: Dict) -> Dict:
-        return ( f'' )
-        
+        return f""
+
     def handle_ps_ranking_request(self, data: Dict) -> Dict:
-        return ( f'' )
-        
+        return f""
+
     def handle_ng_word_request(self, data: Dict) -> Dict:
-        return ( f'' )
-        
+        return f""
+
     def handle_rmt_wp_list_request(self, data: Dict) -> Dict:
-        return ( f'' )
-        
+        return f""
+
     def handle_pv_def_chr_list_request(self, data: Dict) -> Dict:
-        return ( f'' )
-        
+        return f""
+
     def handle_pv_ng_mdl_list_request(self, data: Dict) -> Dict:
-        return ( f'' )
-        
+        return f""
+
     def handle_cstmz_itm_ng_mdl_lst_request(self, data: Dict) -> Dict:
-        return ( f'' )
-        
+        return f""
+
     def handle_banner_info_request(self, data: Dict) -> Dict:
-        return ( f'' )
-        
+        return f""
+
     def handle_banner_data_request(self, data: Dict) -> Dict:
-        return ( f'' )
-        
+        return f""
+
     def handle_cm_ply_info_request(self, data: Dict) -> Dict:
-        return ( f'' )
-        
+        return f""
+
     def handle_pstd_h_ctrl_request(self, data: Dict) -> Dict:
-        return ( f'' )
-        
+        return f""
+
     def handle_pstd_item_ng_lst_request(self, data: Dict) -> Dict:
-        return ( f'' )
-        
+        return f""
+
     def handle_pre_start_request(self, data: Dict) -> str:
         profile = self.data.profile.get_profile(data["aime_id"], self.version)
         profile_shop = self.data.item.get_shop(data["aime_id"], self.version)
@@ -372,8 +421,10 @@ class DivaBase():
             return response
 
     def handle_registration_request(self, data: Dict) -> Dict:
-        self.data.profile.create_profile(self.version, data["aime_id"], data["player_name"])
-        return (f"&cd_adm_result=1&pd_id={data['aime_id']}")
+        self.data.profile.create_profile(
+            self.version, data["aime_id"], data["player_name"]
+        )
+        return f"&cd_adm_result=1&pd_id={data['aime_id']}"
 
     def handle_start_request(self, data: Dict) -> Dict:
         profile = self.data.profile.get_profile(data["pd_id"], self.version)
@@ -384,12 +435,16 @@ class DivaBase():
         mdl_have = "F" * 250
         # generate the mdl_have string if "unlock_all_modules" is disabled
         if not self.game_config.mods.unlock_all_modules:
-            mdl_have = self.data.module.get_modules_have_string(data["pd_id"], self.version)
+            mdl_have = self.data.module.get_modules_have_string(
+                data["pd_id"], self.version
+            )
 
         cstmz_itm_have = "F" * 250
         # generate the cstmz_itm_have string if "unlock_all_items" is disabled
         if not self.game_config.mods.unlock_all_items:
-            cstmz_itm_have = self.data.customize.get_customize_items_have_string(data["pd_id"], self.version)
+            cstmz_itm_have = self.data.customize.get_customize_items_have_string(
+                data["pd_id"], self.version
+            )
 
         response = f"&pd_id={data['pd_id']}"
         response += "&start_result=1"
@@ -452,15 +507,16 @@ class DivaBase():
         response += f"&mdl_eqp_ary={mdl_eqp_ary}"
         response += f"&c_itm_eqp_ary={c_itm_eqp_ary}"
         response += f"&ms_itm_flg_ary={ms_itm_flg_ary}"
-        
-        return ( response )
+
+        return response
 
     def handle_pd_unlock_request(self, data: Dict) -> Dict:
-        return ( f'' )
-        
+        return f""
+
     def handle_spend_credit_request(self, data: Dict) -> Dict:
         profile = self.data.profile.get_profile(data["pd_id"], self.version)
-        if profile is None: return
+        if profile is None:
+            return
 
         response = ""
 
@@ -471,10 +527,16 @@ class DivaBase():
         response += f"&lv_efct_id={profile['lv_efct_id']}"
         response += f"&lv_plt_id={profile['lv_plt_id']}"
 
-        return ( response )
+        return response
 
-    def _get_pv_pd_result(self, song: int, pd_db_song: Dict, pd_db_ranking: Dict,
-                          pd_db_customize: Dict, edition: int) -> str:
+    def _get_pv_pd_result(
+        self,
+        song: int,
+        pd_db_song: Dict,
+        pd_db_ranking: Dict,
+        pd_db_customize: Dict,
+        edition: int,
+    ) -> str:
         """
         Helper function to generate the pv_result string for every song, ranking and edition
         """
@@ -483,7 +545,7 @@ class DivaBase():
             # make sure there are enough max scores to calculate a ranking
             if pd_db_ranking["ranking"] != 0:
                 global_ranking = pd_db_ranking["ranking"]
-    
+
         # pv_no
         pv_result = f"{song},"
         # edition
@@ -513,7 +575,7 @@ class DivaBase():
                 f"{pd_db_customize['chsld_se']},"
                 f"{pd_db_customize['sldtch_se']}"
             )
-        
+
         pv_result += f"{module_eqp},"
         pv_result += f"{customize_eqp},"
         pv_result += f"{customize_flag},"
@@ -537,21 +599,35 @@ class DivaBase():
             if int(song) > 0:
                 # the request do not send a edition so just perform a query best score and ranking for each edition.
                 # 0=ORIGINAL, 1=EXTRA
-                pd_db_song_0 = self.data.score.get_best_user_score(data["pd_id"], int(song), data["difficulty"], edition=0)
-                pd_db_song_1 = self.data.score.get_best_user_score(data["pd_id"], int(song), data["difficulty"], edition=1)
-                
+                pd_db_song_0 = self.data.score.get_best_user_score(
+                    data["pd_id"], int(song), data["difficulty"], edition=0
+                )
+                pd_db_song_1 = self.data.score.get_best_user_score(
+                    data["pd_id"], int(song), data["difficulty"], edition=1
+                )
+
                 pd_db_ranking_0, pd_db_ranking_1 = None, None
                 if pd_db_song_0:
-                    pd_db_ranking_0 = self.data.score.get_global_ranking(data["pd_id"], int(song), data["difficulty"], edition=0)
+                    pd_db_ranking_0 = self.data.score.get_global_ranking(
+                        data["pd_id"], int(song), data["difficulty"], edition=0
+                    )
 
                 if pd_db_song_1:
-                    pd_db_ranking_1 = self.data.score.get_global_ranking(data["pd_id"], int(song), data["difficulty"], edition=1)
+                    pd_db_ranking_1 = self.data.score.get_global_ranking(
+                        data["pd_id"], int(song), data["difficulty"], edition=1
+                    )
+
+                pd_db_customize = self.data.pv_customize.get_pv_customize(
+                    data["pd_id"], int(song)
+                )
 
-                pd_db_customize = self.data.pv_customize.get_pv_customize(data["pd_id"], int(song))
-                
                 # generate the pv_result string with the ORIGINAL edition and the EXTRA edition appended
-                pv_result = self._get_pv_pd_result(int(song), pd_db_song_0, pd_db_ranking_0, pd_db_customize, edition=0)
-                pv_result += "," + self._get_pv_pd_result(int(song), pd_db_song_1, pd_db_ranking_1, pd_db_customize, edition=1)
+                pv_result = self._get_pv_pd_result(
+                    int(song), pd_db_song_0, pd_db_ranking_0, pd_db_customize, edition=0
+                )
+                pv_result += "," + self._get_pv_pd_result(
+                    int(song), pd_db_song_1, pd_db_ranking_1, pd_db_customize, edition=1
+                )
 
                 self.logger.debug(f"pv_result = {pv_result}")
 
@@ -565,13 +641,12 @@ class DivaBase():
         response += "&pdddt_flg=0"
         response += f"&pdddt_tm={self.time_lut}"
 
-        return ( response )
+        return response
 
     def handle_stage_start_request(self, data: Dict) -> Dict:
-        return ( f'' )
+        return f""
 
     def handle_stage_result_request(self, data: Dict) -> Dict:
-
         profile = self.data.profile.get_profile(data["pd_id"], self.version)
 
         pd_song_list = data["stg_ply_pv_id"].split(",")
@@ -590,15 +665,100 @@ class DivaBase():
 
         for index, value in enumerate(pd_song_list):
             if "-1" not in pd_song_list[index]:
-                profile_pd_db_song = self.data.score.get_best_user_score(data["pd_id"], pd_song_list[index], pd_song_difficulty[index], pd_song_edition[index])
+                profile_pd_db_song = self.data.score.get_best_user_score(
+                    data["pd_id"],
+                    pd_song_list[index],
+                    pd_song_difficulty[index],
+                    pd_song_edition[index],
+                )
                 if profile_pd_db_song is None:
-                    self.data.score.put_best_score(data["pd_id"], self.version, pd_song_list[index], pd_song_difficulty[index], pd_song_edition[index], pd_song_max_score[index], pd_song_max_atn_pnt[index], pd_song_ranking[index], pd_song_sort_kind, pd_song_cool_cnt[index], pd_song_fine_cnt[index], pd_song_safe_cnt[index], pd_song_sad_cnt[index], pd_song_worst_cnt[index], pd_song_max_combo[index])
-                    self.data.score.put_playlog(data["pd_id"], self.version, pd_song_list[index], pd_song_difficulty[index], pd_song_edition[index], pd_song_max_score[index], pd_song_max_atn_pnt[index], pd_song_ranking[index], pd_song_sort_kind, pd_song_cool_cnt[index], pd_song_fine_cnt[index], pd_song_safe_cnt[index], pd_song_sad_cnt[index], pd_song_worst_cnt[index], pd_song_max_combo[index])
+                    self.data.score.put_best_score(
+                        data["pd_id"],
+                        self.version,
+                        pd_song_list[index],
+                        pd_song_difficulty[index],
+                        pd_song_edition[index],
+                        pd_song_max_score[index],
+                        pd_song_max_atn_pnt[index],
+                        pd_song_ranking[index],
+                        pd_song_sort_kind,
+                        pd_song_cool_cnt[index],
+                        pd_song_fine_cnt[index],
+                        pd_song_safe_cnt[index],
+                        pd_song_sad_cnt[index],
+                        pd_song_worst_cnt[index],
+                        pd_song_max_combo[index],
+                    )
+                    self.data.score.put_playlog(
+                        data["pd_id"],
+                        self.version,
+                        pd_song_list[index],
+                        pd_song_difficulty[index],
+                        pd_song_edition[index],
+                        pd_song_max_score[index],
+                        pd_song_max_atn_pnt[index],
+                        pd_song_ranking[index],
+                        pd_song_sort_kind,
+                        pd_song_cool_cnt[index],
+                        pd_song_fine_cnt[index],
+                        pd_song_safe_cnt[index],
+                        pd_song_sad_cnt[index],
+                        pd_song_worst_cnt[index],
+                        pd_song_max_combo[index],
+                    )
                 elif int(pd_song_max_score[index]) >= int(profile_pd_db_song["score"]):
-                    self.data.score.put_best_score(data["pd_id"], self.version, pd_song_list[index], pd_song_difficulty[index], pd_song_edition[index], pd_song_max_score[index], pd_song_max_atn_pnt[index], pd_song_ranking[index], pd_song_sort_kind, pd_song_cool_cnt[index], pd_song_fine_cnt[index], pd_song_safe_cnt[index], pd_song_sad_cnt[index], pd_song_worst_cnt[index], pd_song_max_combo[index])
-                    self.data.score.put_playlog(data["pd_id"], self.version, pd_song_list[index], pd_song_difficulty[index], pd_song_edition[index], pd_song_max_score[index], pd_song_max_atn_pnt[index], pd_song_ranking[index], pd_song_sort_kind, pd_song_cool_cnt[index], pd_song_fine_cnt[index], pd_song_safe_cnt[index], pd_song_sad_cnt[index], pd_song_worst_cnt[index], pd_song_max_combo[index])
+                    self.data.score.put_best_score(
+                        data["pd_id"],
+                        self.version,
+                        pd_song_list[index],
+                        pd_song_difficulty[index],
+                        pd_song_edition[index],
+                        pd_song_max_score[index],
+                        pd_song_max_atn_pnt[index],
+                        pd_song_ranking[index],
+                        pd_song_sort_kind,
+                        pd_song_cool_cnt[index],
+                        pd_song_fine_cnt[index],
+                        pd_song_safe_cnt[index],
+                        pd_song_sad_cnt[index],
+                        pd_song_worst_cnt[index],
+                        pd_song_max_combo[index],
+                    )
+                    self.data.score.put_playlog(
+                        data["pd_id"],
+                        self.version,
+                        pd_song_list[index],
+                        pd_song_difficulty[index],
+                        pd_song_edition[index],
+                        pd_song_max_score[index],
+                        pd_song_max_atn_pnt[index],
+                        pd_song_ranking[index],
+                        pd_song_sort_kind,
+                        pd_song_cool_cnt[index],
+                        pd_song_fine_cnt[index],
+                        pd_song_safe_cnt[index],
+                        pd_song_sad_cnt[index],
+                        pd_song_worst_cnt[index],
+                        pd_song_max_combo[index],
+                    )
                 elif int(pd_song_max_score[index]) != int(profile_pd_db_song["score"]):
-                    self.data.score.put_playlog(data["pd_id"], self.version, pd_song_list[index], pd_song_difficulty[index], pd_song_edition[index], pd_song_max_score[index], pd_song_max_atn_pnt[index], pd_song_ranking[index], pd_song_sort_kind, pd_song_cool_cnt[index], pd_song_fine_cnt[index], pd_song_safe_cnt[index], pd_song_sad_cnt[index], pd_song_worst_cnt[index], pd_song_max_combo[index])
+                    self.data.score.put_playlog(
+                        data["pd_id"],
+                        self.version,
+                        pd_song_list[index],
+                        pd_song_difficulty[index],
+                        pd_song_edition[index],
+                        pd_song_max_score[index],
+                        pd_song_max_atn_pnt[index],
+                        pd_song_ranking[index],
+                        pd_song_sort_kind,
+                        pd_song_cool_cnt[index],
+                        pd_song_fine_cnt[index],
+                        pd_song_safe_cnt[index],
+                        pd_song_sad_cnt[index],
+                        pd_song_worst_cnt[index],
+                        pd_song_max_combo[index],
+                    )
 
         # Profile saving based on registration list
 
@@ -608,7 +768,7 @@ class DivaBase():
         total_atn_pnt = 0
         for best_score in best_scores:
             total_atn_pnt += best_score["atn_pnt"]
-        
+
         new_level = (total_atn_pnt // 13979) + 1
         new_level_pnt = round((total_atn_pnt % 13979) / 13979 * 100)
 
@@ -630,7 +790,7 @@ class DivaBase():
             nxt_dffclty=int(data["nxt_dffclty"]),
             nxt_edtn=int(data["nxt_edtn"]),
             my_qst_id=data["my_qst_id"],
-            my_qst_sts=data["my_qst_sts"]
+            my_qst_sts=data["my_qst_sts"],
         )
 
         response += f"&lv_num={new_level}"
@@ -663,35 +823,51 @@ class DivaBase():
         response += "&my_ccd_r_hnd=-1,-1,-1,-1,-1"
         response += "&my_ccd_r_vp=-1,-1,-1,-1,-1"
 
-        return ( response )
+        return response
 
     def handle_end_request(self, data: Dict) -> Dict:
         profile = self.data.profile.get_profile(data["pd_id"], self.version)
 
         self.data.profile.update_profile(
-            profile["user"],
-            my_qst_id=data["my_qst_id"],
-            my_qst_sts=data["my_qst_sts"]
+            profile["user"], my_qst_id=data["my_qst_id"], my_qst_sts=data["my_qst_sts"]
         )
-        return (f'')
+        return f""
 
     def handle_shop_exit_request(self, data: Dict) -> Dict:
-        self.data.item.put_shop(data["pd_id"], self.version, data["mdl_eqp_cmn_ary"], data["c_itm_eqp_cmn_ary"], data["ms_itm_flg_cmn_ary"])
+        self.data.item.put_shop(
+            data["pd_id"],
+            self.version,
+            data["mdl_eqp_cmn_ary"],
+            data["c_itm_eqp_cmn_ary"],
+            data["ms_itm_flg_cmn_ary"],
+        )
         if int(data["use_pv_mdl_eqp"]) == 1:
-            self.data.pv_customize.put_pv_customize(data["pd_id"], self.version, data["ply_pv_id"],
-                                                    data["mdl_eqp_pv_ary"], data["c_itm_eqp_pv_ary"], data["ms_itm_flg_pv_ary"])
+            self.data.pv_customize.put_pv_customize(
+                data["pd_id"],
+                self.version,
+                data["ply_pv_id"],
+                data["mdl_eqp_pv_ary"],
+                data["c_itm_eqp_pv_ary"],
+                data["ms_itm_flg_pv_ary"],
+            )
         else:
-            self.data.pv_customize.put_pv_customize(data["pd_id"], self.version, data["ply_pv_id"],
-                                                    "-1,-1,-1", "-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1", "1,1,1,1,1,1,1,1,1,1,1,1")
+            self.data.pv_customize.put_pv_customize(
+                data["pd_id"],
+                self.version,
+                data["ply_pv_id"],
+                "-1,-1,-1",
+                "-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1",
+                "1,1,1,1,1,1,1,1,1,1,1,1",
+            )
 
         response = "&shp_rslt=1"
-        return ( response )
+        return response
 
     def handle_card_procedure_request(self, data: Dict) -> str:
         profile = self.data.profile.get_profile(data["aime_id"], self.version)
         if profile is None:
             return "&cd_adm_result=0"
-        
+
         response = "&cd_adm_result=1"
         response += "&chg_name_price=100"
         response += "&accept_idx=100"
@@ -706,20 +882,18 @@ class DivaBase():
         response += f"&passwd_stat={profile['passwd_stat']}"
 
         return response
-    
+
     def handle_change_name_request(self, data: Dict) -> str:
         profile = self.data.profile.get_profile(data["pd_id"], self.version)
 
         # make sure user has enough Vocaloid Points
         if profile["vcld_pts"] < int(data["chg_name_price"]):
             return "&cd_adm_result=0"
-        
+
         # update the vocaloid points and player name
         new_vcld_pts = profile["vcld_pts"] - int(data["chg_name_price"])
         self.data.profile.update_profile(
-            profile["user"],
-            player_name=data["player_name"],
-            vcld_pts=new_vcld_pts
+            profile["user"], player_name=data["player_name"], vcld_pts=new_vcld_pts
         )
 
         response = "&cd_adm_result=1"
@@ -728,19 +902,17 @@ class DivaBase():
         response += f"&player_name={data['player_name']}"
 
         return response
-    
+
     def handle_change_passwd_request(self, data: Dict) -> str:
         profile = self.data.profile.get_profile(data["pd_id"], self.version)
 
         # TODO: return correct error number instead of 0
-        if (data["passwd"] != profile["passwd"]):
+        if data["passwd"] != profile["passwd"]:
             return "&cd_adm_result=0"
 
         # set password to true and update the saved password
         self.data.profile.update_profile(
-            profile["user"],
-            passwd_stat=1,
-            passwd=data["new_passwd"]
+            profile["user"], passwd_stat=1, passwd=data["new_passwd"]
         )
 
         response = "&cd_adm_result=1"

titles/diva/config.py

@@ -1,30 +1,40 @@
 from core.config import CoreConfig
 
 
-class DivaServerConfig():
+class DivaServerConfig:
     def __init__(self, parent_config: "DivaConfig") -> None:
         self.__config = parent_config
 
     @property
     def enable(self) -> bool:
-        return CoreConfig.get_config_field(self.__config, 'diva', 'server', 'enable', default=True)
+        return CoreConfig.get_config_field(
+            self.__config, "diva", "server", "enable", default=True
+        )
 
     @property
     def loglevel(self) -> int:
-        return CoreConfig.str_to_loglevel(CoreConfig.get_config_field(self.__config, 'diva', 'server', 'loglevel', default="info"))
+        return CoreConfig.str_to_loglevel(
+            CoreConfig.get_config_field(
+                self.__config, "diva", "server", "loglevel", default="info"
+            )
+        )
 
 
-class DivaModsConfig():
+class DivaModsConfig:
     def __init__(self, parent_config: "DivaConfig") -> None:
         self.__config = parent_config
 
     @property
     def unlock_all_modules(self) -> bool:
-        return CoreConfig.get_config_field(self.__config, 'diva', 'mods', 'unlock_all_modules', default=True)
+        return CoreConfig.get_config_field(
+            self.__config, "diva", "mods", "unlock_all_modules", default=True
+        )
 
     @property
     def unlock_all_items(self) -> bool:
-        return CoreConfig.get_config_field(self.__config, 'diva', 'mods', 'unlock_all_items', default=True)
+        return CoreConfig.get_config_field(
+            self.__config, "diva", "mods", "unlock_all_items", default=True
+        )
 
 
 class DivaConfig(dict):

titles/diva/const.py

@@ -1,4 +1,4 @@
-class DivaConstants():
+class DivaConstants:
     GAME_CODE = "SBZV"
 
     CONFIG_NAME = "diva.yaml"
@@ -10,4 +10,4 @@ class DivaConstants():
 
     @classmethod
     def game_ver_to_string(cls, ver: int):
-        return cls.VERSION_NAMES[ver]
+        return cls.VERSION_NAMES[ver]

titles/diva/database.py

@@ -1,6 +1,14 @@
 from core.data import Data
 from core.config import CoreConfig
-from titles.diva.schema import DivaProfileData, DivaScoreData, DivaModuleData, DivaCustomizeItemData, DivaPvCustomizeData, DivaItemData, DivaStaticData
+from titles.diva.schema import (
+    DivaProfileData,
+    DivaScoreData,
+    DivaModuleData,
+    DivaCustomizeItemData,
+    DivaPvCustomizeData,
+    DivaItemData,
+    DivaStaticData,
+)
 
 
 class DivaData(Data):

titles/diva/index.py

@@ -14,85 +14,112 @@ from titles.diva.config import DivaConfig
 from titles.diva.const import DivaConstants
 from titles.diva.base import DivaBase
 
-class DivaServlet():
+
+class DivaServlet:
     def __init__(self, core_cfg: CoreConfig, cfg_dir: str) -> None:
         self.core_cfg = core_cfg
         self.game_cfg = DivaConfig()
         if path.exists(f"{cfg_dir}/{DivaConstants.CONFIG_NAME}"):
-            self.game_cfg.update(yaml.safe_load(open(f"{cfg_dir}/{DivaConstants.CONFIG_NAME}")))
+            self.game_cfg.update(
+                yaml.safe_load(open(f"{cfg_dir}/{DivaConstants.CONFIG_NAME}"))
+            )
 
         self.base = DivaBase(core_cfg, self.game_cfg)
 
         self.logger = logging.getLogger("diva")
         log_fmt_str = "[%(asctime)s] Diva | %(levelname)s | %(message)s"
         log_fmt = logging.Formatter(log_fmt_str)
-        fileHandler = TimedRotatingFileHandler("{0}/{1}.log".format(self.core_cfg.server.log_dir, "diva"), encoding='utf8',
-            when="d", backupCount=10)
+        fileHandler = TimedRotatingFileHandler(
+            "{0}/{1}.log".format(self.core_cfg.server.log_dir, "diva"),
+            encoding="utf8",
+            when="d",
+            backupCount=10,
+        )
 
         fileHandler.setFormatter(log_fmt)
-        
+
         consoleHandler = logging.StreamHandler()
         consoleHandler.setFormatter(log_fmt)
 
         self.logger.addHandler(fileHandler)
         self.logger.addHandler(consoleHandler)
-        
+
         self.logger.setLevel(self.game_cfg.server.loglevel)
-        coloredlogs.install(level=self.game_cfg.server.loglevel, logger=self.logger, fmt=log_fmt_str)
-    
+        coloredlogs.install(
+            level=self.game_cfg.server.loglevel, logger=self.logger, fmt=log_fmt_str
+        )
+
     @classmethod
-    def get_allnet_info(cls, game_code: str, core_cfg: CoreConfig, cfg_dir: str) -> Tuple[bool, str, str]:
+    def get_allnet_info(
+        cls, game_code: str, core_cfg: CoreConfig, cfg_dir: str
+    ) -> Tuple[bool, str, str]:
         game_cfg = DivaConfig()
         if path.exists(f"{cfg_dir}/{DivaConstants.CONFIG_NAME}"):
-            game_cfg.update(yaml.safe_load(open(f"{cfg_dir}/{DivaConstants.CONFIG_NAME}")))
+            game_cfg.update(
+                yaml.safe_load(open(f"{cfg_dir}/{DivaConstants.CONFIG_NAME}"))
+            )
 
         if not game_cfg.server.enable:
             return (False, "", "")
-        
+
         if core_cfg.server.is_develop:
-            return (True, f"http://{core_cfg.title.hostname}:{core_cfg.title.port}/{game_code}/$v/", "")
-        
+            return (
+                True,
+                f"http://{core_cfg.title.hostname}:{core_cfg.title.port}/{game_code}/$v/",
+                "",
+            )
+
         return (True, f"http://{core_cfg.title.hostname}/{game_code}/$v/", "")
 
     def render_POST(self, req: Request, version: int, url_path: str) -> bytes:
         req_raw = req.content.getvalue()
         url_header = req.getAllHeaders()
 
-        #Ping Dispatch
-        if "THIS_STRING_SEPARATES"in str(url_header):
+        # Ping Dispatch
+        if "THIS_STRING_SEPARATES" in str(url_header):
             binary_request = req_raw.splitlines()
             binary_cmd_decoded = binary_request[3].decode("utf-8")
-            binary_array = binary_cmd_decoded.split('&')
+            binary_array = binary_cmd_decoded.split("&")
 
             bin_req_data = {}
 
             for kvp in binary_array:
                 split_bin = kvp.split("=")
                 bin_req_data[split_bin[0]] = split_bin[1]
-            
+
             self.logger.info(f"Binary {bin_req_data['cmd']} Request")
             self.logger.debug(bin_req_data)
 
             handler = getattr(self.base, f"handle_{bin_req_data['cmd']}_request")
             resp = handler(bin_req_data)
 
-            self.logger.debug(f"Response cmd={bin_req_data['cmd']}&req_id={bin_req_data['req_id']}&stat=ok{resp}")
-            return f"cmd={bin_req_data['cmd']}&req_id={bin_req_data['req_id']}&stat=ok{resp}".encode('utf-8')
+            self.logger.debug(
+                f"Response cmd={bin_req_data['cmd']}&req_id={bin_req_data['req_id']}&stat=ok{resp}"
+            )
+            return f"cmd={bin_req_data['cmd']}&req_id={bin_req_data['req_id']}&stat=ok{resp}".encode(
+                "utf-8"
+            )
+
+        # Main Dispatch
+        json_string = json.dumps(
+            req_raw.decode("utf-8")
+        )  # Take the response and decode as UTF-8 and dump
+        b64string = json_string.replace(
+            r"\n", "\n"
+        )  # Remove all \n and separate them as new lines
+        gz_string = base64.b64decode(b64string)  # Decompressing the base64 string
 
-        #Main Dispatch
-        json_string = json.dumps(req_raw.decode("utf-8")) #Take the response and decode as UTF-8 and dump
-        b64string = json_string.replace(r'\n', '\n') # Remove all \n and separate them as new lines
-        gz_string = base64.b64decode(b64string) # Decompressing the base64 string
-        
         try:
-            url_data = zlib.decompress( gz_string ).decode("utf-8") # Decompressing the gzip
+            url_data = zlib.decompress(gz_string).decode(
+                "utf-8"
+            )  # Decompressing the gzip
         except zlib.error as e:
             self.logger.error(f"Failed to defalte! {e} -> {gz_string}")
             return "stat=0"
 
         req_kvp = urllib.parse.unquote(url_data)
         req_data = {}
-        
+
         # We then need to split each parts with & so we can reuse them to fill out the requests
         splitted_request = str.split(req_kvp, "&")
         for kvp in splitted_request:
@@ -109,15 +136,25 @@ class DivaServlet():
             handler = getattr(self.base, func_to_find)
             resp = handler(req_data)
 
-        except AttributeError as e: 
+        except AttributeError as e:
             self.logger.warning(f"Unhandled {req_data['cmd']} request {e}")
-            return f"cmd={req_data['cmd']}&req_id={req_data['req_id']}&stat=ok".encode('utf-8')
+            return f"cmd={req_data['cmd']}&req_id={req_data['req_id']}&stat=ok".encode(
+                "utf-8"
+            )
 
         except Exception as e:
             self.logger.error(f"Error handling method {func_to_find} {e}")
-            return f"cmd={req_data['cmd']}&req_id={req_data['req_id']}&stat=ok".encode('utf-8')
+            return f"cmd={req_data['cmd']}&req_id={req_data['req_id']}&stat=ok".encode(
+                "utf-8"
+            )
 
         req.responseHeaders.addRawHeader(b"content-type", b"text/plain")
-        self.logger.debug(f"Response cmd={req_data['cmd']}&req_id={req_data['req_id']}&stat=ok{resp}")
+        self.logger.debug(
+            f"Response cmd={req_data['cmd']}&req_id={req_data['req_id']}&stat=ok{resp}"
+        )
 
-        return f"cmd={req_data['cmd']}&req_id={req_data['req_id']}&stat=ok{resp}".encode('utf-8')
+        return (
+            f"cmd={req_data['cmd']}&req_id={req_data['req_id']}&stat=ok{resp}".encode(
+                "utf-8"
+            )
+        )

titles/diva/read.py

@@ -7,13 +7,23 @@ from core.config import CoreConfig
 from titles.diva.database import DivaData
 from titles.diva.const import DivaConstants
 
+
 class DivaReader(BaseReader):
-    def __init__(self, config: CoreConfig, version: int, bin_dir: Optional[str], opt_dir: Optional[str], extra: Optional[str]) -> None:
+    def __init__(
+        self,
+        config: CoreConfig,
+        version: int,
+        bin_dir: Optional[str],
+        opt_dir: Optional[str],
+        extra: Optional[str],
+    ) -> None:
         super().__init__(config, version, bin_dir, opt_dir, extra)
         self.data = DivaData(config)
 
         try:
-            self.logger.info(f"Start importer for {DivaConstants.game_ver_to_string(version)}")
+            self.logger.info(
+                f"Start importer for {DivaConstants.game_ver_to_string(version)}"
+            )
         except IndexError:
             self.logger.error(f"Invalid project diva version {version}")
             exit(1)
@@ -30,7 +40,7 @@ class DivaReader(BaseReader):
         if not path.exists(f"{self.bin_dir}/rom"):
             self.logger.warn(f"Couldn't find rom folder in {self.bin_dir}, skipping")
             pull_bin_rom = False
-        
+
         if self.opt_dir is not None:
             opt_dirs = self.get_data_directories(self.opt_dir)
         else:
@@ -44,18 +54,25 @@ class DivaReader(BaseReader):
         if pull_opt_rom:
             for dir in opt_dirs:
                 self.read_rom(f"{dir}/rom")
-        
+
     def read_ram(self, ram_root_dir: str) -> None:
         self.logger.info(f"Read RAM from {ram_root_dir}")
 
         if path.exists(f"{ram_root_dir}/databank"):
             for root, dirs, files in walk(f"{ram_root_dir}/databank"):
                 for file in files:
-                    if file.startswith("ShopCatalog_") or file.startswith("CustomizeItemCatalog_") or \
-                        (file.startswith("QuestInfo") and not file.startswith("QuestInfoTm")):
-                        
+                    if (
+                        file.startswith("ShopCatalog_")
+                        or file.startswith("CustomizeItemCatalog_")
+                        or (
+                            file.startswith("QuestInfo")
+                            and not file.startswith("QuestInfoTm")
+                        )
+                    ):
                         with open(f"{root}/{file}", "r") as f:
-                            file_data: str = urllib.parse.unquote(urllib.parse.unquote(f.read()))
+                            file_data: str = urllib.parse.unquote(
+                                urllib.parse.unquote(f.read())
+                            )
                             if file_data == "***":
                                 self.logger.info(f"{file} is empty, skipping")
                                 continue
@@ -70,23 +87,54 @@ class DivaReader(BaseReader):
 
                                 if file.startswith("ShopCatalog_"):
                                     for x in range(0, len(split), 7):
-                                        self.logger.info(f"Added shop item {split[x+0]}")
+                                        self.logger.info(
+                                            f"Added shop item {split[x+0]}"
+                                        )
 
-                                        self.data.static.put_shop(self.version, split[x+0], split[x+2], split[x+6], split[x+3], 
-                                        split[x+1], split[x+4], split[x+5])
+                                        self.data.static.put_shop(
+                                            self.version,
+                                            split[x + 0],
+                                            split[x + 2],
+                                            split[x + 6],
+                                            split[x + 3],
+                                            split[x + 1],
+                                            split[x + 4],
+                                            split[x + 5],
+                                        )
 
-                                elif file.startswith("CustomizeItemCatalog_") and len(split) >= 7:
+                                elif (
+                                    file.startswith("CustomizeItemCatalog_")
+                                    and len(split) >= 7
+                                ):
                                     for x in range(0, len(split), 7):
                                         self.logger.info(f"Added item {split[x+0]}")
 
-                                        self.data.static.put_items(self.version, split[x+0], split[x+2], split[x+6], split[x+3], 
-                                        split[x+1], split[x+4], split[x+5])
+                                        self.data.static.put_items(
+                                            self.version,
+                                            split[x + 0],
+                                            split[x + 2],
+                                            split[x + 6],
+                                            split[x + 3],
+                                            split[x + 1],
+                                            split[x + 4],
+                                            split[x + 5],
+                                        )
 
                                 elif file.startswith("QuestInfo") and len(split) >= 9:
                                     self.logger.info(f"Added quest {split[0]}")
-                                    
-                                    self.data.static.put_quests(self.version, split[0], split[6], split[2], split[3],
-                                    split[7], split[8], split[1], split[4], split[5])
+
+                                    self.data.static.put_quests(
+                                        self.version,
+                                        split[0],
+                                        split[6],
+                                        split[2],
+                                        split[3],
+                                        split[7],
+                                        split[8],
+                                        split[1],
+                                        split[4],
+                                        split[5],
+                                    )
 
                                 else:
                                     continue
@@ -102,13 +150,13 @@ class DivaReader(BaseReader):
         elif path.exists(f"{rom_root_dir}/pv_db.txt"):
             file_path = f"{rom_root_dir}/pv_db.txt"
         else:
-            self.logger.warn(f"Cannot find pv_db.txt or mdata_pv_db.txt in {rom_root_dir}, skipping")
+            self.logger.warn(
+                f"Cannot find pv_db.txt or mdata_pv_db.txt in {rom_root_dir}, skipping"
+            )
             return
 
         with open(file_path, "r", encoding="utf-8") as f:
-            
             for line in f.readlines():
-                
                 if line.startswith("#") or not line:
                     continue
 
@@ -127,14 +175,13 @@ class DivaReader(BaseReader):
 
                 for x in range(1, len(key_split)):
                     key_args.append(key_split[x])
-                
+
                 try:
                     pv_list[pv_id] = self.add_branch(pv_list[pv_id], key_args, val)
                 except KeyError:
                     pv_list[pv_id] = {}
                     pv_list[pv_id] = self.add_branch(pv_list[pv_id], key_args, val)
 
-        
         for pv_id, pv_data in pv_list.items():
             song_id = int(pv_id.split("_")[1])
             if "songinfo" not in pv_data:
@@ -148,46 +195,99 @@ class DivaReader(BaseReader):
             if "music" not in pv_data["songinfo"]:
                 pv_data["songinfo"]["music"] = "-"
 
-            if "easy" in pv_data['difficulty'] and '0' in pv_data['difficulty']['easy']:
-                diff = pv_data['difficulty']['easy']['0']['level'].split('_')
+            if "easy" in pv_data["difficulty"] and "0" in pv_data["difficulty"]["easy"]:
+                diff = pv_data["difficulty"]["easy"]["0"]["level"].split("_")
                 self.logger.info(f"Added song {song_id} chart 0")
 
-                self.data.static.put_music(self.version, song_id, 0, pv_data["song_name"], pv_data["songinfo"]["arranger"],
-                pv_data["songinfo"]["illustrator"], pv_data["songinfo"]["lyrics"], pv_data["songinfo"]["music"],
-                float(f"{diff[2]}.{diff[3]}"), pv_data["bpm"], pv_data["date"])
-            
-            if "normal" in pv_data['difficulty'] and '0' in pv_data['difficulty']['normal']:
-                diff = pv_data['difficulty']['normal']['0']['level'].split('_')
+                self.data.static.put_music(
+                    self.version,
+                    song_id,
+                    0,
+                    pv_data["song_name"],
+                    pv_data["songinfo"]["arranger"],
+                    pv_data["songinfo"]["illustrator"],
+                    pv_data["songinfo"]["lyrics"],
+                    pv_data["songinfo"]["music"],
+                    float(f"{diff[2]}.{diff[3]}"),
+                    pv_data["bpm"],
+                    pv_data["date"],
+                )
+
+            if (
+                "normal" in pv_data["difficulty"]
+                and "0" in pv_data["difficulty"]["normal"]
+            ):
+                diff = pv_data["difficulty"]["normal"]["0"]["level"].split("_")
                 self.logger.info(f"Added song {song_id} chart 1")
 
-                self.data.static.put_music(self.version, song_id, 1, pv_data["song_name"], pv_data["songinfo"]["arranger"],
-                pv_data["songinfo"]["illustrator"], pv_data["songinfo"]["lyrics"], pv_data["songinfo"]["music"],
-                float(f"{diff[2]}.{diff[3]}"), pv_data["bpm"], pv_data["date"])
-            
-            if "hard" in pv_data['difficulty'] and '0' in pv_data['difficulty']['hard']:
-                diff = pv_data['difficulty']['hard']['0']['level'].split('_')
+                self.data.static.put_music(
+                    self.version,
+                    song_id,
+                    1,
+                    pv_data["song_name"],
+                    pv_data["songinfo"]["arranger"],
+                    pv_data["songinfo"]["illustrator"],
+                    pv_data["songinfo"]["lyrics"],
+                    pv_data["songinfo"]["music"],
+                    float(f"{diff[2]}.{diff[3]}"),
+                    pv_data["bpm"],
+                    pv_data["date"],
+                )
+
+            if "hard" in pv_data["difficulty"] and "0" in pv_data["difficulty"]["hard"]:
+                diff = pv_data["difficulty"]["hard"]["0"]["level"].split("_")
                 self.logger.info(f"Added song {song_id} chart 2")
 
-                self.data.static.put_music(self.version, song_id, 2, pv_data["song_name"], pv_data["songinfo"]["arranger"],
-                pv_data["songinfo"]["illustrator"], pv_data["songinfo"]["lyrics"], pv_data["songinfo"]["music"],
-                float(f"{diff[2]}.{diff[3]}"), pv_data["bpm"], pv_data["date"])
-            
-            if "extreme" in pv_data['difficulty']:
-                if "0" in pv_data['difficulty']['extreme']:
-                    diff = pv_data['difficulty']['extreme']['0']['level'].split('_')
+                self.data.static.put_music(
+                    self.version,
+                    song_id,
+                    2,
+                    pv_data["song_name"],
+                    pv_data["songinfo"]["arranger"],
+                    pv_data["songinfo"]["illustrator"],
+                    pv_data["songinfo"]["lyrics"],
+                    pv_data["songinfo"]["music"],
+                    float(f"{diff[2]}.{diff[3]}"),
+                    pv_data["bpm"],
+                    pv_data["date"],
+                )
+
+            if "extreme" in pv_data["difficulty"]:
+                if "0" in pv_data["difficulty"]["extreme"]:
+                    diff = pv_data["difficulty"]["extreme"]["0"]["level"].split("_")
                     self.logger.info(f"Added song {song_id} chart 3")
 
-                    self.data.static.put_music(self.version, song_id, 3, pv_data["song_name"], pv_data["songinfo"]["arranger"],
-                    pv_data["songinfo"]["illustrator"], pv_data["songinfo"]["lyrics"], pv_data["songinfo"]["music"],
-                    float(f"{diff[2]}.{diff[3]}"), pv_data["bpm"], pv_data["date"])
+                    self.data.static.put_music(
+                        self.version,
+                        song_id,
+                        3,
+                        pv_data["song_name"],
+                        pv_data["songinfo"]["arranger"],
+                        pv_data["songinfo"]["illustrator"],
+                        pv_data["songinfo"]["lyrics"],
+                        pv_data["songinfo"]["music"],
+                        float(f"{diff[2]}.{diff[3]}"),
+                        pv_data["bpm"],
+                        pv_data["date"],
+                    )
 
-                if "1" in pv_data['difficulty']['extreme']:
-                    diff = pv_data['difficulty']['extreme']['1']['level'].split('_')
+                if "1" in pv_data["difficulty"]["extreme"]:
+                    diff = pv_data["difficulty"]["extreme"]["1"]["level"].split("_")
                     self.logger.info(f"Added song {song_id} chart 4")
 
-                    self.data.static.put_music(self.version, song_id, 4, pv_data["song_name"], pv_data["songinfo"]["arranger"],
-                    pv_data["songinfo"]["illustrator"], pv_data["songinfo"]["lyrics"], pv_data["songinfo"]["music"],
-                    float(f"{diff[2]}.{diff[3]}"), pv_data["bpm"], pv_data["date"])
+                    self.data.static.put_music(
+                        self.version,
+                        song_id,
+                        4,
+                        pv_data["song_name"],
+                        pv_data["songinfo"]["arranger"],
+                        pv_data["songinfo"]["illustrator"],
+                        pv_data["songinfo"]["lyrics"],
+                        pv_data["songinfo"]["music"],
+                        float(f"{diff[2]}.{diff[3]}"),
+                        pv_data["bpm"],
+                        pv_data["date"],
+                    )
 
     def add_branch(self, tree: Dict, vector: List, value: str):
         """
@@ -195,9 +295,9 @@ class DivaReader(BaseReader):
         Author: iJames on StackOverflow
         """
         key = vector[0]
-        tree[key] = value \
-            if len(vector) == 1 \
-            else self.add_branch(tree[key] if key in tree else {},
-                            vector[1:],
-                            value)
-        return tree
+        tree[key] = (
+            value
+            if len(vector) == 1
+            else self.add_branch(tree[key] if key in tree else {}, vector[1:], value)
+        )
+        return tree