Updated checkDatatables, better checks for missing songs

I used to rely on musicinfo.bin to build the songlist,
Now using all files to build an expected song database

checkDatatables.py

@@ -36,13 +36,14 @@ if __name__ == "__main__":
         exit(1)
 
 isChn = isChn()
+songs = []
 
 # region Loading files
 checkFile = {}
 
 infos = loadFile(path="./Data/x64/datatable/musicinfo.bin")
-usb = loadFile(path="./Data/x64/datatable/music_usbsetting.bin")
+usbs = loadFile(path="./Data/x64/datatable/music_usbsetting.bin")
-order = loadFile(path="./Data/x64/datatable/music_order.bin")
+orders = loadFile(path="./Data/x64/datatable/music_order.bin")
 attributes = loadFile(path="./Data/x64/datatable/music_attribute.bin")
 words = loadFile(path="./Data/x64/datatable/wordlist.bin")
 # endregion
@@ -67,104 +68,29 @@ class Genres(Enum):
         return cls.Unknown
 
 
-class Song:
-    id = ""
-    uniqueId = -1
-    genreNo = -1
-    name = ""
-    sub = ""
-    detail = ""
-
-    def __init__(self, id, uniqueId, genreNo, name, sub, detail):
-        self.id = id
-        self.uniqueId = uniqueId
-        self.genreNo = genreNo
-        self.name = name
-        self.sub = sub
-        self.detail = detail
-
-
 def initCheckFile():
     global checkFile
     checkFile = {
-        "musicinfo.bin": {
+        "stats": {
-            "TotalEntries": len(infos),
+            "TotalSongs": 0,
-            "MaxId": max(infos, key=lambda ev: ev["uniqueId"])["uniqueId"],
+            "MaxId": 0,
             "UniqueIdTooHigh": 0,
             "UniqueIdTooHighList": [],
             "UnusedUniqueIds": 0,
             "UnusedUniqueIdsList": [],
-            "Doublons": 0,
-            "DoublonsList": [],
-            "GenreNoList": [],
         },
     }
 
-    if attributes is not None:
+    if infos is not None:
-        checkFile["music_attribute.bin"] = {
+        checkFile["musicinfo.bin"] = {
-            "TotalEntries": len(attributes),
+            "TotalEntries": len(infos),
             "Missing": 0,
             "MissingList": [],
-            "Mismatch": 0,
-            "MismatchList": [],
             "Doublons": 0,
             "DoublonsList": [],
-        }
-
-    if order is not None:
-        checkFile["music_order.bin"] = {
-            "TotalEntries": len(order),
-            "UniqueEntries": 0,
-            "UniqueEntriesList": [],
             "GenreNoList": [],
-            "Missing": 0,
-            "MissingList": [],
-            "Mismatch": 0,
-            "MismatchList": [],
         }
-
+        for song in infos:
-    if usb is not None:
-        checkFile["music_usbsetting.bin"] = {
-            "TotalEntries": len(usb),
-            "Missing": 0,
-            "MissingList": [],
-            "Mismatch": 0,
-            "MismatchList": [],
-            "Doublons": 0,
-            "DoublonsList": [],
-        }
-
-    if words is not None:
-        checkFile["wordlist.bin"] = {
-            "TotalEntries": len(words),
-            "MissingSongName": 0,
-            "MissingSongNameList": [],
-            "MissingSongSub": 0,
-            "MissingSongSubList": [],
-            "MissingSongDetail": 0,
-            "MissingSongDetailList": [],
-            "Doublons": 0,
-            "DoublonsList": [],
-        }
-
-    checkFile.update(
-        {
-            "GameFiles": {
-                "MissingSound": 0,
-                "MissingSoundList": [],
-                "MissingFumen": 0,
-                "MissingFumenList": [],
-            },
-        }
-    )
-
-
-# endregion
-
-# Loading all songs from musicinfo in an array
-songs = []
-
-for song in infos:
             name = findKeyInList(
                 list=words,
                 key="key",
@@ -185,143 +111,360 @@ for song in infos:
             )
 
             songs.append(
-        Song(
+                {
-            id=song["id"],
+                    "id": song["id"],
-            uniqueId=song["uniqueId"],
+                    "uniqueId": song["uniqueId"],
-            genreNo=song["genreNo"],
+                    "genreNo": song["genreNo"],
-            name=name,
+                    "name": name,
-            sub=sub,
+                    "sub": sub,
-            detail=detail,
+                    "detail": detail,
+                }
             )
+
+    if attributes is not None:
+        checkFile["music_attribute.bin"] = {
+            "TotalEntries": len(attributes),
+            "Missing": 0,
+            "MissingList": [],
+            "Mismatch": 0,
+            "MismatchList": [],
+            "Doublons": 0,
+            "DoublonsList": [],
+        }
+        for song in attributes:
+            temp = findKeyInList(list=songs, key="id", keyValue=song["id"])
+            if temp is not None:
+                continue
+
+            name = findKeyInList(
+                list=words,
+                key="key",
+                keyValue="song_" + song["id"],
+                value=language,
             )
+            sub = findKeyInList(
+                list=words,
+                key="key",
+                keyValue="song_sub_" + song["id"],
+                value=language,
+            )
+            detail = findKeyInList(
+                list=words,
+                key="key",
+                keyValue="song_detail_" + song["id"],
+                value=language,
+            )
+            genreNo = findKeyInList(
+                list=infos,
+                key="id",
+                keyValue=song["id"],
+                value="genreNo",
+            )
+
+            songs.append(
+                {
+                    "id": song["id"],
+                    "uniqueId": song["uniqueId"],
+                    "genreNo": genreNo,
+                    "name": name,
+                    "sub": sub,
+                    "detail": detail,
+                }
+            )
+
+    if orders is not None:
+        checkFile["music_order.bin"] = {
+            "TotalEntries": len(orders),
+            "UniqueEntries": 0,
+            "UniqueEntriesList": [],
+            "GenreNoList": [],
+            "Missing": 0,
+            "MissingList": [],
+            "Mismatch": 0,
+            "MismatchList": [],
+        }
+        for song in orders:
+            temp = findKeyInList(list=songs, key="id", keyValue=song["id"])
+            if temp is not None:
+                continue
+
+            name = findKeyInList(
+                list=words,
+                key="key",
+                keyValue="song_" + song["id"],
+                value=language,
+            )
+            sub = findKeyInList(
+                list=words,
+                key="key",
+                keyValue="song_sub_" + song["id"],
+                value=language,
+            )
+            detail = findKeyInList(
+                list=words,
+                key="key",
+                keyValue="song_detail_" + song["id"],
+                value=language,
+            )
+            genreNo = findKeyInList(
+                list=infos,
+                key="id",
+                keyValue=song["id"],
+                value="genreNo",
+            )
+
+            songs.append(
+                {
+                    "id": song["id"],
+                    "uniqueId": song["uniqueId"],
+                    "genreNo": genreNo,
+                    "name": name,
+                    "sub": sub,
+                    "detail": detail,
+                }
+            )
+
+    if usbs is not None:
+        checkFile["music_usbsetting.bin"] = {
+            "TotalEntries": len(usbs),
+            "Missing": 0,
+            "MissingList": [],
+            "Mismatch": 0,
+            "MismatchList": [],
+            "Doublons": 0,
+            "DoublonsList": [],
+        }
+        for song in usbs:
+            temp = findKeyInList(list=songs, key="id", keyValue=song["id"])
+            if temp is not None:
+                continue
+
+            name = findKeyInList(
+                list=words,
+                key="key",
+                keyValue="song_" + song["id"],
+                value=language,
+            )
+            sub = findKeyInList(
+                list=words,
+                key="key",
+                keyValue="song_sub_" + song["id"],
+                value=language,
+            )
+            detail = findKeyInList(
+                list=words,
+                key="key",
+                keyValue="song_detail_" + song["id"],
+                value=language,
+            )
+            genreNo = findKeyInList(
+                list=infos,
+                key="id",
+                keyValue=song["id"],
+                value="genreNo",
+            )
+
+            songs.append(
+                {
+                    "id": song["id"],
+                    "uniqueId": song["uniqueId"],
+                    "genreNo": genreNo,
+                    "name": name,
+                    "sub": sub,
+                    "detail": detail,
+                }
+            )
+
+    if words is not None:
+        checkFile["wordlist.bin"] = {
+            "TotalEntries": len(words),
+            "MissingSongName": 0,
+            "MissingSongNameList": [],
+            "MissingSongSub": 0,
+            "MissingSongSubList": [],
+            "MissingSongDetail": 0,
+            "MissingSongDetailList": [],
+            "Doublons": 0,
+            "DoublonsList": [],
+        }
+
+    if all([doesPathExist("./Data/x64/fumen"), doesPathExist("./Data/x64/sound")]):
+        checkFile.update(
+            {
+                "GameFiles": {
+                    "MissingSound": 0,
+                    "MissingSoundList": [],
+                    "MissingFumen": 0,
+                    "MissingFumenList": [],
+                },
+            }
+        )
+
+    # Update stats
+    checkFile["stats"]["TotalSongs"] = len(songs)
+    checkFile["stats"]["MaxId"] = max(songs, key=lambda ev: ev["uniqueId"])["uniqueId"]
+
+    print("Found a total of", str(len(songs)), "songs in datatables")
+
+
+# endregion
+
 
 # Preparing the json file containing the results of this checking script
 initCheckFile()
 
 # Checking...
 for song in songs:
-    # musicinfo.bin
+    # stats
-    if infos is not None:
     # Checking for too high of an id
-        if song.uniqueId > 1599:
+    if song["uniqueId"] > 1599:
-            checkFile["musicinfo.bin"]["UniqueIdTooHigh"] += 1
+        checkFile["stats"]["UniqueIdTooHigh"] += 1
-            checkFile["musicinfo.bin"]["UniqueIdTooHighList"].append(
+        checkFile["stats"]["UniqueIdTooHighList"].append(
             {
-                    "id": song.id,
+                "id": song["id"],
-                    "uniqueId": song.uniqueId,
+                "uniqueId": song["uniqueId"],
             }
         )
+
+    # musicinfo.bin
+    if infos is not None:
+        # Check for missing uniqueIds or id and uniqueId mismatches
+        orderOccurences = findAllObjects(list=infos, key="id", keyValue=song["id"])
+        if len(orderOccurences) == 0:
+            checkFile["musicinfo.bin"]["Missing"] += 1
+            checkFile["musicinfo.bin"]["MissingList"].append(song["id"])
         # Listing genres and counting entries for each genres
         genre = {
-            "GenreNo": song.genreNo,
+            "GenreNo": song["genreNo"],
-            "Name": Genres(song.genreNo).name,
+            "Name": Genres(song["genreNo"]).name,
             "NumberofSongs": 0,
         }
         if (
             findKeyInList(
                 list=checkFile["musicinfo.bin"]["GenreNoList"],
                 key="GenreNo",
-                keyValue=song.genreNo,
+                keyValue=song["genreNo"],
             )
             is None
         ):
             genre["NumberofSongs"] = len(
-                findAllObjects(list=infos, key="genreNo", keyValue=song.genreNo)
+                findAllObjects(list=infos, key="genreNo", keyValue=song["genreNo"])
             )
             checkFile["musicinfo.bin"]["GenreNoList"].append(genre)
         # Search doublons
-        if findDoubloninList(list=infos, key="id", keyValue=song.id):
+        if findDoubloninList(list=infos, key="id", keyValue=song["id"]):
-            if song.id not in checkFile["musicinfo.bin"]["DoublonsList"]:
+            if song["id"] not in checkFile["musicinfo.bin"]["DoublonsList"]:
                 checkFile["musicinfo.bin"]["Doublons"] += 1
-                checkFile["musicinfo.bin"]["DoublonsList"].append(song.id)
+                checkFile["musicinfo.bin"]["DoublonsList"].append(song["id"])
 
-        if findDoubloninList(list=infos, key="uniqueId", keyValue=song.uniqueId):
+        if findDoubloninList(list=infos, key="uniqueId", keyValue=song["uniqueId"]):
-            if song.id not in checkFile["musicinfo.bin"]["DoublonsList"]:
+            if song["uniqueId"] not in checkFile["musicinfo.bin"]["DoublonsList"]:
                 checkFile["musicinfo.bin"]["Doublons"] += 1
-                checkFile["musicinfo.bin"]["DoublonsList"].append(song.uniqueId)
+                checkFile["musicinfo.bin"]["DoublonsList"].append(song["uniqueId"])
-
-    # music_usbsetting.bin
-    if usb is not None:
-        # Check for missing uniqueIds or id and uniqueId mismatches
-        orderOccurences = findAllObjects(list=usb, key="id", keyValue=song.id)
-        if len(orderOccurences) == 0:
-            checkFile["music_usbsetting.bin"]["Missing"] += 1
-            checkFile["music_usbsetting.bin"]["MissingList"].append(song.id)
-        else:
-            for occurence in orderOccurences:
-                if not all(
-                    [song.id == occurence["id"], song.uniqueId == occurence["uniqueId"]]
-                ):
-                    if song.id not in checkFile["music_usbsetting.bin"]["MismatchList"]:
-                        checkFile["music_usbsetting.bin"]["Mismatch"] += 1
-                        checkFile["music_usbsetting.bin"]["MismatchList"].append(
-                            {
-                                "id": song.id,
-                                "ExpectedUniqueId": song.uniqueId,
-                                "CurrentUniqueId": occurence["uniqueId"],
-                            }
-                        )
-
-        # Search doublons
-        if findDoubloninList(list=usb, key="id", keyValue=song.id):
-            if song.id not in checkFile["music_usbsetting.bin"]["DoublonsList"]:
-                checkFile["music_usbsetting.bin"]["Doublons"] += 1
-                checkFile["music_usbsetting.bin"]["DoublonsList"].append(song.id)
-        if findDoubloninList(list=usb, key="uniqueId", keyValue=song.uniqueId):
-            if song.id not in checkFile["musicinfo.bin"]["DoublonsList"]:
-                checkFile["music_usbsetting.bin"]["Doublons"] += 1
-                checkFile["music_usbsetting.bin"]["DoublonsList"].append(song.uniqueId)
 
     # music_attribute.bin
     if attributes is not None:
         # Check for missing uniqueIds or id and uniqueId mismatches
-        orderOccurences = findAllObjects(list=attributes, key="id", keyValue=song.id)
+        orderOccurences = findAllObjects(list=attributes, key="id", keyValue=song["id"])
         if len(orderOccurences) == 0:
             checkFile["music_attribute.bin"]["Missing"] += 1
-            checkFile["music_attribute.bin"]["MissingList"].append(song.id)
+            checkFile["music_attribute.bin"]["MissingList"].append(song["id"])
         else:
             for occurence in orderOccurences:
                 if not all(
-                    [song.id == occurence["id"], song.uniqueId == occurence["uniqueId"]]
+                    [
+                        song["id"] == occurence["id"],
+                        song["uniqueId"] == occurence["uniqueId"],
+                    ]
+                ):
+                    if (
+                        song["id"]
+                        not in checkFile["music_attribute.bin"]["MismatchList"]
                     ):
-                    if song.id not in checkFile["music_attribute.bin"]["MismatchList"]:
                         checkFile["music_attribute.bin"]["Mismatch"] += 1
                         checkFile["music_attribute.bin"]["MismatchList"].append(
                             {
-                                "id": song.id,
+                                "id": song["id"],
-                                "ExpectedUniqueId": song.uniqueId,
+                                "ExpectedUniqueId": song["uniqueId"],
                                 "CurrentUniqueId": occurence["uniqueId"],
                             }
                         )
-        if findDoubloninList(list=attributes, key="id", keyValue=song.id):
+        if findDoubloninList(list=attributes, key="id", keyValue=song["id"]):
-            if song.id not in checkFile["music_attribute.bin"]["DoublonsList"]:
+            if song["id"] not in checkFile["music_attribute.bin"]["DoublonsList"]:
                 checkFile["music_attribute.bin"]["Doublons"] += 1
-                checkFile["music_attribute.bin"]["DoublonsList"].append(song.id)
+                checkFile["music_attribute.bin"]["DoublonsList"].append(song["id"])
-        if findDoubloninList(list=attributes, key="uniqueId", keyValue=song.uniqueId):
+        if findDoubloninList(
-            if song.id not in checkFile["musicinfo.bin"]["DoublonsList"]:
+            list=attributes, key="uniqueId", keyValue=song["uniqueId"]
+        ):
+            if song["uniqueId"] not in checkFile["musicinfo.bin"]["DoublonsList"]:
                 checkFile["music_attribute.bin"]["Doublons"] += 1
-                checkFile["music_attribute.bin"]["DoublonsList"].append(song.uniqueId)
+                checkFile["music_attribute.bin"]["DoublonsList"].append(
+                    song["uniqueId"]
+                )
+
+    # music_usbsetting.bin
+    if usbs is not None:
+        # Check for missing uniqueIds or id and uniqueId mismatches
+        orderOccurences = findAllObjects(list=usbs, key="id", keyValue=song["id"])
+        if len(orderOccurences) == 0:
+            checkFile["music_usbsetting.bin"]["Missing"] += 1
+            checkFile["music_usbsetting.bin"]["MissingList"].append(song["id"])
+        else:
+            for occurence in orderOccurences:
+                if not all(
+                    [
+                        song["id"] == occurence["id"],
+                        song["uniqueId"] == occurence["uniqueId"],
+                    ]
+                ):
+                    if (
+                        song["id"]
+                        not in checkFile["music_usbsetting.bin"]["MismatchList"]
+                    ):
+                        checkFile["music_usbsetting.bin"]["Mismatch"] += 1
+                        checkFile["music_usbsetting.bin"]["MismatchList"].append(
+                            {
+                                "id": song["id"],
+                                "ExpectedUniqueId": song["uniqueId"],
+                                "CurrentUniqueId": occurence["uniqueId"],
+                            }
+                        )
+
+        # Search doublons
+        if findDoubloninList(list=usbs, key="id", keyValue=song["id"]):
+            if song["id"] not in checkFile["music_usbsetting.bin"]["DoublonsList"]:
+                checkFile["music_usbsetting.bin"]["Doublons"] += 1
+                checkFile["music_usbsetting.bin"]["DoublonsList"].append(song["id"])
+        if findDoubloninList(list=usbs, key="uniqueId", keyValue=song["uniqueId"]):
+            if song["uniqueId"] not in checkFile["musicinfo.bin"]["DoublonsList"]:
+                checkFile["music_usbsetting.bin"]["Doublons"] += 1
+                checkFile["music_usbsetting.bin"]["DoublonsList"].append(
+                    song["uniqueId"]
+                )
 
     # music_order.bin
-    if order is not None:
+    if orders is not None:
         # Check for missing uniqueIds or id and uniqueId mismatches
-        orderOccurences = findAllObjects(list=order, key="id", keyValue=song.id)
+        orderOccurences = findAllObjects(list=orders, key="id", keyValue=song["id"])
         if len(orderOccurences) == 0:
             checkFile["music_order.bin"]["Missing"] += 1
-            checkFile["music_order.bin"]["MissingList"].append(song.id)
+            checkFile["music_order.bin"]["MissingList"].append(song["id"])
         else:
             songGenres = []
             for occurence in orderOccurences:
                 songGenres.append(occurence["genreNo"])
                 if not all(
-                    [song.id == occurence["id"], song.uniqueId == occurence["uniqueId"]]
+                    [
+                        song["id"] == occurence["id"],
+                        song["uniqueId"] == occurence["uniqueId"],
+                    ]
                 ):
-                    if song.id not in checkFile["music_order.bin"]["MismatchList"]:
+                    if song["id"] not in checkFile["music_order.bin"]["MismatchList"]:
                         checkFile["music_order.bin"]["Mismatch"] += 1
                         checkFile["music_order.bin"]["MismatchList"].append(
                             {
-                                "id": song.id,
+                                "id": song["id"],
-                                "ExpectedUniqueId": song.uniqueId,
+                                "ExpectedUniqueId": song["uniqueId"],
                                 "CurrentUniqueId": occurence["uniqueId"],
                             }
                         )
@@ -330,38 +473,40 @@ for song in songs:
             checkFile["music_order.bin"]["UniqueEntries"] += 1
             checkFile["music_order.bin"]["UniqueEntriesList"].append(
                 {
-                    song.id: songGenres,
+                    song["id"]: songGenres,
                 }
             )
 
     # wordlist.bin
     if words is not None:
-        if song.name == "":
+        if song["name"] == "":
             checkFile["wordlist.bin"]["MissingSongName"] += 1
-            checkFile["wordlist.bin"]["MissingSongNameList"].append(song.id)
+            checkFile["wordlist.bin"]["MissingSongNameList"].append(song["id"])
-        if song.sub == "":
+        if song["sub"] == "":
             checkFile["wordlist.bin"]["MissingSongSub"] += 1
-            checkFile["wordlist.bin"]["MissingSongSubList"].append(song.id)
+            checkFile["wordlist.bin"]["MissingSongSubList"].append(song["id"])
-        if song.detail == "":
+        if song["detail"] == "":
             checkFile["wordlist.bin"]["MissingSongDetail"] += 1
-            checkFile["wordlist.bin"]["MissingSongDetailList"].append(song.id)
+            checkFile["wordlist.bin"]["MissingSongDetailList"].append(song["id"])
 
     # Gamefiles
-    if not doesPathExist("./Data/x64/sound/" + "song_" + song.id + ".nus3bank"):
+    if all([doesPathExist("./Data/x64/fumen"), doesPathExist("./Data/x64/sound")]):
+        if not doesPathExist("./Data/x64/sound/" + "song_" + song["id"] + ".nus3bank"):
             checkFile["GameFiles"]["MissingSound"] += 1
-        checkFile["GameFiles"]["MissingSoundList"].append(song.id)
+            checkFile["GameFiles"]["MissingSoundList"].append(song["id"])
-    if not doesPathExist("./Data/x64/fumen/" + song.id):
+        if not doesPathExist("./Data/x64/fumen/" + song["id"]):
             checkFile["GameFiles"]["MissingFumen"] += 1
-        checkFile["GameFiles"]["MissingFumenList"].append(song.id)
+            checkFile["GameFiles"]["MissingFumenList"].append(song["id"])
 
 # Checking for vacant uniqueIds
-for i in range(max(checkFile["musicinfo.bin"]["MaxId"], 1600)):
+for i in range(max(checkFile["stats"]["MaxId"], 1600)):
-    key = findKeyInList(list=infos, key="uniqueId", keyValue=i)
+    key = findKeyInList(list=songs, key="uniqueId", keyValue=i)
 
     if key is not None:
         # Updating GenreNoList of music_order.bin
+        if orders is not None:
             for song in findAllObjects(
-            list=order, key="uniqueId", keyValue=key["uniqueId"]
+                list=orders, key="uniqueId", keyValue=key["uniqueId"]
             ):
                 genre = {
                     "GenreNo": song["genreNo"],
@@ -377,14 +522,16 @@ for i in range(max(checkFile["musicinfo.bin"]["MaxId"], 1600)):
                     is None
                 ):
                     genre["NumberofSongs"] = len(
-                    findAllObjects(list=order, key="genreNo", keyValue=song["genreNo"])
+                        findAllObjects(
+                            list=orders, key="genreNo", keyValue=song["genreNo"]
+                        )
                     )
                     checkFile["music_order.bin"]["GenreNoList"].append(genre)
     else:
         # Finding unused Ids bellow 1599
         if i < 1600:
-            checkFile["musicinfo.bin"]["UnusedUniqueIds"] += 1
+            checkFile["stats"]["UnusedUniqueIds"] += 1
-            checkFile["musicinfo.bin"]["UnusedUniqueIdsList"].append(i)
+            checkFile["stats"]["UnusedUniqueIdsList"].append(i)
 
 # Checking for doublons in wordlist
 if words is not None:
@@ -394,13 +541,16 @@ if words is not None:
                 checkFile["wordlist.bin"]["Doublons"] += 1
                 checkFile["wordlist.bin"]["DoublonsList"].append(word["key"])
 
+
 # Sorting some values for better readability
-checkFile["musicinfo.bin"]["GenreNoList"].sort(
+if infos is not None:
-    key=lambda x: x["GenreNo"], reverse=False
+    checkFile["musicinfo.bin"]["GenreNoList"].sort(
-)
+        key=lambda x: str(x["GenreNo"]), reverse=False
-checkFile["music_order.bin"]["GenreNoList"].sort(
+    )
-    key=lambda x: x["GenreNo"], reverse=False
+if orders is not None:
-)
+    checkFile["music_order.bin"]["GenreNoList"].sort(
+        key=lambda x: str(x["GenreNo"]), reverse=False
+    )
 
 # Writing everything to checks.json
 json_object = json.dumps(checkFile, ensure_ascii=False, indent="\t")

encryption.py

@@ -68,7 +68,7 @@ def decrypt_file(input_file, key_type: Keys = Keys(Keys.Datatable)):
 
 def isJson(file: bytes):
     try:
-        json.loads(file)["items"]
+        json.loads(file)
         return True
     except:
         return False

helpers.py

@@ -27,10 +27,14 @@ def loadFile(path: str):
         try:
             if not isChn():
                 # Loading files for 08.18
-                return json.load(gzip.open(path, "rb"))["items"]
+                file = json.load(gzip.open(path, "rb"))["items"]
+                print("Successfully loaded", path)
+                return file
             else:
                 # Loading files for 32.09 CHN
-                return json.loads(decrypt_file(input_file=path))["items"]
+                file = json.loads(decrypt_file(input_file=path))["items"]
+                print("Successfully loaded", path)
+                return file
         except Exception as error:
             print(error)
             print("Couldn't load", path)
@@ -40,6 +44,7 @@ def loadFile(path: str):
 
 
 def findKeyInList(list: list, key: str, keyValue, value=None):
+    try:
         for object in list:
             try:
                 if object[key] == keyValue:
@@ -56,6 +61,8 @@ def findKeyInList(list: list, key: str, keyValue, value=None):
                         + ", are you using the right language ?"
                     )
                 exit(0)
+    except Exception as error:
+        return None
 
     if value is not None:
         return ""