refactoring

src/core/SerieScanner.py

@@ -0,0 +1,131 @@
+import os
+import re
+import logging
+from server.core.entities.series import Serie
+import traceback
+from server.infrastructure.logging.GlobalLogger import error_logger, noKeyFound_logger
+from server.core.exceptions.Exceptions import NoKeyFoundException, MatchNotFoundError
+from server.infrastructure.providers.base_provider import Loader
+
+
+class SerieScanner:
+    def __init__(self, basePath: str, loader: Loader):
+        self.directory = basePath
+        self.folderDict: dict[str, Serie] = {}  # Proper initialization
+        self.loader = loader
+        logging.info(f"Initialized Loader with base path: {self.directory}")
+
+    def Reinit(self):
+        self.folderDict: dict[str, Serie] = {}  # Proper initialization
+
+
+    def is_null_or_whitespace(self, s):
+        return s is None or s.strip() == ""
+
+    def GetTotalToScan(self):
+        result = self.__find_mp4_files()
+        return sum(1 for _ in result)
+
+    def Scan(self, callback):
+        logging.info("Starting process to load missing episodes")
+        result = self.__find_mp4_files()
+        counter = 0
+        for folder, mp4_files in result:
+            try:
+                counter += 1
+                callback(folder, counter)
+                serie = self.__ReadDataFromFile(folder)
+                if (serie != None and not self.is_null_or_whitespace(serie.key)):
+                    missings, site = self.__GetMissingEpisodesAndSeason(serie.key, mp4_files)
+                    serie.episodeDict = missings
+                    serie.folder = folder
+                    serie.save_to_file(os.path.join(os.path.join(self.directory, folder), 'data'))
+                    if (serie.key in self.folderDict):
+                        logging.ERROR(f"dublication found: {serie.key}");
+                        pass
+                    self.folderDict[serie.key] = serie
+                    noKeyFound_logger.info(f"Saved Serie: '{str(serie)}'")
+            except NoKeyFoundException as nkfe:
+                NoKeyFoundException.error(f"Error processing folder '{folder}': {nkfe}")
+            except Exception as e:
+                error_logger.error(f"Folder: '{folder}' - Unexpected error processing folder '{folder}': {e} \n {traceback.format_exc()}")
+                continue
+
+
+    def __find_mp4_files(self):
+        logging.info("Scanning for .mp4 files")
+        for anime_name in os.listdir(self.directory):
+            anime_path = os.path.join(self.directory, anime_name)
+            if os.path.isdir(anime_path):
+                mp4_files = []
+                has_files = False
+                for root, _, files in os.walk(anime_path):
+                    for file in files:
+                        if file.endswith(".mp4"):
+                            mp4_files.append(os.path.join(root, file))
+                            has_files = True
+                yield anime_name, mp4_files if has_files else []
+
+    def __remove_year(self, input_string: str):
+        cleaned_string = re.sub(r'\(\d{4}\)', '', input_string).strip()
+        logging.debug(f"Removed year from '{input_string}' -> '{cleaned_string}'")
+        return cleaned_string
+
+    def __ReadDataFromFile(self, folder_name: str):
+        folder_path = os.path.join(self.directory, folder_name)
+        key = None
+        key_file = os.path.join(folder_path, 'key')
+        serie_file = os.path.join(folder_path, 'data')
+
+        if os.path.exists(key_file):
+            with open(key_file, 'r') as file:
+                key = file.read().strip()
+                logging.info(f"Key found for folder '{folder_name}': {key}")
+                return Serie(key, "", "aniworld.to", folder_name, dict())
+
+        if os.path.exists(serie_file):
+            with open(serie_file, "rb") as file:
+                logging.info(f"load serie_file from '{folder_name}': {serie_file}")
+                return Serie.load_from_file(serie_file)
+
+        return None
+
+
+    def __GetEpisodeAndSeason(self, filename: str):
+        pattern = r'S(\d+)E(\d+)'
+        match = re.search(pattern, filename)
+        if match:
+            season = match.group(1)
+            episode = match.group(2)
+            logging.debug(f"Extracted season {season}, episode {episode} from '{filename}'")
+            return int(season), int(episode)
+        else:
+            logging.error(f"Failed to find season/episode pattern in '{filename}'")
+            raise MatchNotFoundError("Season and episode pattern not found in the filename.")
+
+    def __GetEpisodesAndSeasons(self, mp4_files: []):
+        episodes_dict = {}
+
+        for file in mp4_files:
+            season, episode = self.__GetEpisodeAndSeason(file)
+
+            if season in episodes_dict:
+                episodes_dict[season].append(episode)
+            else:
+                episodes_dict[season] = [episode]
+        return episodes_dict
+
+    def __GetMissingEpisodesAndSeason(self, key: str, mp4_files: []):
+        expected_dict = self.loader.get_season_episode_count(key) # key season , value count of episodes
+        filedict = self.__GetEpisodesAndSeasons(mp4_files)
+        episodes_dict = {}
+        for season, expected_count in expected_dict.items():
+            existing_episodes = filedict.get(season, [])
+            missing_episodes = [ep for ep in range(1, expected_count + 1) if ep not in existing_episodes and self.loader.IsLanguage(season, ep, key)]
+
+            if missing_episodes:
+                episodes_dict[season] = missing_episodes
+
+        return episodes_dict, "aniworld.to"
+
+