0.0.2.7 V Beta

LoadBalancer.py

@@ -1,25 +1,21 @@
 import os
 import json
-import urllib.request
-import concurrent.futures
-from tqdm import tqdm
 from indexer import indexer
 import re
 from tvdb import fetch_and_cache_json
-from threading import Event
+from threading import Event, Thread
 import time
 import logging
-from threading import Thread, Event
+from utils import convert_to_gb
 from api import InstancesAPI
 
-
 CACHE_DIR = os.getenv("CACHE_DIR")
 
 download_progress = {}
 
 class LoadBalancer:
     def __init__(self, cache_dir, index_file, token, repo, polling_interval=4, max_retries=3, initial_delay=1):
-        self.version = "0.0.2.6 V Beta"
+        self.version = "0.0.2.7 V Beta"
         self.instances = []
         self.instances_health = {}
         self.polling_interval = polling_interval
@@ -34,24 +30,52 @@ class LoadBalancer:
         self.FILM_STORE = {}
         self.TV_STORE = {}
         self.file_structure = None
+        self.index_file_last_modified = None
 
         # Ensure CACHE_DIR exists
         if not os.path.exists(self.CACHE_DIR):
             os.makedirs(self.CACHE_DIR)
 
-        # Index the file structure
+        # Index the file structure initially
         indexer()
 
         # Load the file structure JSON
+        self.load_file_structure()
+
+        # Start polling and file checking in separate threads
+        polling_thread = Thread(target=self.start_polling)
+        polling_thread.daemon = True
+        polling_thread.start()
+
+        file_checking_thread = Thread(target=self.check_file_updates)
+        file_checking_thread.daemon = True
+        file_checking_thread.start()
+
+    def load_file_structure(self):
         if not os.path.exists(self.INDEX_FILE):
             raise FileNotFoundError(f"{self.INDEX_FILE} not found. Please make sure the file exists.")
 
         with open(self.INDEX_FILE, 'r') as f:
             self.file_structure = json.load(f)
+        logging.info("File structure loaded successfully.")
 
-        prefetch_thread = Thread(target=self.start_prefetching)
-        prefetch_thread.daemon = True
-        prefetch_thread.start()
+    def check_file_updates(self):
+        while not self.stop_event.is_set():
+            if self.index_file_last_modified != os.path.getmtime(self.INDEX_FILE):
+                logging.info(f"{self.INDEX_FILE} has been updated. Re-indexing...")
+                indexer()  # Re-run the indexer
+                self.load_file_structure()  # Reload the file structure
+                self.index_file_last_modified = os.path.getmtime(self.INDEX_FILE)
+
+                # Restart prefetching thread
+                if hasattr(self, 'prefetch_thread') and self.prefetch_thread.is_alive():
+                    self.prefetch_thread.join()
+                
+                self.prefetch_thread = Thread(target=self.start_prefetching)
+                self.prefetch_thread.daemon = True
+                self.prefetch_thread.start()
+
+            time.sleep(120)  # Check every 2 minutes
 
     def register_instance(self, instance_url):
         if instance_url not in self.instances:
@@ -124,38 +148,9 @@ class LoadBalancer:
         logging.info("Stopping polling.")
         self.stop_event.set()
 
-######################################################################
-    @staticmethod
-    def get_system_proxies():
-        """
-        Retrieves the system's HTTP and HTTPS proxies.
-
-        Returns:
-            dict: A dictionary containing the proxies.
-        """
-        try:
-            proxies = urllib.request.getproxies()
-            print("System proxies:", proxies)
-            return {
-                "http": proxies.get("http"),
-                "https": proxies.get("http")
-            }
-        except Exception as e:
-            print(f"Error getting system proxies: {e}")
-            return {}
-
-    @staticmethod
-    def is_valid_url(url):
-        # Simple URL validation (could be more complex if needed)
-        regex = re.compile(
-            r'^(?:http|ftp)s?://' # http:// or https://
-            r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|' # domain...
-            r'localhost|' # localhost...
-            r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|' # ...or ipv4
-            r'\[?[A-F0-9]*:[A-F0-9:]+\]?)' # ...or ipv6
-            r'(?::\d+)?' # optional port
-            r'(?:/?|[/?]\S+)$', re.IGNORECASE)
-        return re.match(regex, url) is not None
+    def start_prefetching(self):
+        """Start the metadata prefetching in a separate thread."""
+        self.prefetch_metadata()
 
 #################################################################
 
@@ -183,8 +178,8 @@ class LoadBalancer:
         
         # Calculate free space for each instance
         for instance_url, space_info in self.instances_health.items():
-            total_space = self._convert_to_gb(space_info['total'])
-            used_space = self._convert_to_gb(space_info['used'])
+            total_space = convert_to_gb(space_info['total'])
+            used_space = convert_to_gb(space_info['used'])
             free_space = total_space - used_space
             
             if free_space > max_free_space:
@@ -227,8 +222,8 @@ class LoadBalancer:
         
         # Calculate free space for each instance
         for instance_url, space_info in self.instances_health.items():
-            total_space = self._convert_to_gb(space_info['total'])
-            used_space = self._convert_to_gb(space_info['used'])
+            total_space = convert_to_gb(space_info['total'])
+            used_space = convert_to_gb(space_info['used'])
             free_space = total_space - used_space
             
             if free_space > max_free_space:
@@ -251,12 +246,6 @@ class LoadBalancer:
             logging.error("No suitable instance found for downloading the film.")
             return {"error": "No suitable instance found for downloading the film."}
 
-    def _convert_to_gb(self, space_str):
-        """
-        Converts a space string like '50 GB' or '3.33 GB' to a float representing the number of GB.
-        """
-        return float(space_str.split()[0])
-
 #################################################################
     def find_movie_path(self, title):
         """Find the path of the movie in the JSON data based on the title."""
@@ -316,16 +305,6 @@ class LoadBalancer:
 
                     fetch_and_cache_json(original_title, title, media_type, year)
 
-    def bytes_to_human_readable(self, num, suffix="B"):
-        for unit in ["", "K", "M", "G", "T", "P", "E", "Z"]:
-            if abs(num) < 1024.0:
-                return f"{num:3.1f} {unit}{suffix}"
-            num /= 1024.0
-        return f"{num:.1f} Y{suffix}"
-
-    def encode_episodeid(self, title, season, episode):
-        return f"{title}_{season}_{episode}"
-
     def get_all_tv_shows(self):
         """Get all TV shows from the indexed cache structure JSON file."""
         tv_shows = {}
@@ -355,8 +334,4 @@ class LoadBalancer:
                 for sub_directory in directory['contents']:
                     if sub_directory['type'] == 'directory':
                         films.append(sub_directory['path'])
-        return films
-
-    def start_prefetching(self):
-        """Start the metadata prefetching in a separate thread."""
-        self.prefetch_metadata()
+        return films

TODO.md

@@ -1 +1 @@
-# implement a better way to collect store jsons
+# implement a better way clear instance cache and refresh

app.py

@@ -1,5 +1,6 @@
 from flask import Flask, jsonify, request, send_from_directory
 from flask_cors import CORS
+from utils import is_valid_url, bytes_to_human_readable, encode_episodeid
 import os
 import json
 from threading import Thread
@@ -97,7 +98,7 @@ def get_episode_id_api(title,season,episode):
     """Endpoint to get the episode ID by providing the TV show title, season, and episode."""
     if not title or not season or not episode:
         return jsonify({"error": "Title, season, and episode parameters are required"}), 400
-    episode_id = load_balancer.encode_episodeid(title,season,episode)
+    episode_id = encode_episodeid(title,season,episode)
     return jsonify({"episode_id": episode_id})
 
 @app.route('/api/cache/size', methods=['GET'])
@@ -107,7 +108,7 @@ def get_cache_size_api():
         for f in filenames:
             fp = os.path.join(dirpath, f)
             total_size += os.path.getsize(fp)
-    readable_size = load_balancer.bytes_to_human_readable(total_size)
+    readable_size = bytes_to_human_readable(total_size)
     return jsonify({"cache_size": readable_size})
 
 @app.route('/api/cache/clear', methods=['POST'])
@@ -192,7 +193,7 @@ def register_instance():
             return jsonify({"error": "No URL provided"}), 400
         
         url = data["url"]
-        if not load_balancer.is_valid_url(url):
+        if not is_valid_url(url):
             return jsonify({"error": "Invalid URL"}), 400
 
         # Register the instance

hf_scrapper.py

@@ -29,178 +29,6 @@ def get_system_proxies():
         print(f"Error getting system proxies: {e}")
         return {}
 
-def download_film(file_url, token, cache_path, proxies, film_id, title, chunk_size=100 * 1024 * 1024):
-    """
-    Downloads a file from the specified URL and saves it to the cache path.
-    Tracks the download progress.
-
-    Args:
-        file_url (str): The URL of the file to download.
-        token (str): The authorization token for the request.
-        cache_path (str): The path to save the downloaded file.
-        proxies (dict): Proxies for the request.
-        film_id (str): Unique identifier for the film download.
-        title (str): The title of the film.
-        chunk_size (int): Size of each chunk to download.
-    """
-    print(f"Downloading file from URL: {file_url} to {cache_path} with proxies: {proxies}")
-    headers = {'Authorization': f'Bearer {token}'}
-    try:
-        response = requests.get(file_url, headers=headers, proxies=proxies, stream=True)
-        response.raise_for_status()
-        
-        total_size = int(response.headers.get('content-length', 0))
-        download_progress[film_id] = {"total": total_size, "downloaded": 0, "status": "Downloading", "start_time": time.time()}
-
-        os.makedirs(os.path.dirname(cache_path), exist_ok=True)
-        with open(cache_path, 'wb') as file, tqdm(total=total_size, unit='B', unit_scale=True, desc=cache_path) as pbar:
-            for data in response.iter_content(chunk_size=chunk_size):
-                file.write(data)
-                pbar.update(len(data))
-                download_progress[film_id]["downloaded"] += len(data)
-        
-        print(f'File cached to {cache_path} successfully.')
-        update_film_store_json(title, cache_path)
-        download_progress[film_id]["status"] = "Completed"
-    except RequestException as e:
-        print(f"Error downloading file: {e}")
-        download_progress[film_id]["status"] = "Failed"
-    except IOError as e:
-        print(f"Error writing file {cache_path}: {e}")
-        download_progress[film_id]["status"] = "Failed"
-    finally:
-        if download_progress[film_id]["status"] != "Downloading":
-            download_progress[film_id]["end_time"] = time.time()
-
-def get_download_progress(id):
-    """
-    Gets the download progress for a specific film.
-
-    Args:
-        film_id (str): The unique identifier for the film download.
-
-    Returns:
-        dict: A dictionary containing the total size, downloaded size, progress percentage, status, and ETA.
-    """
-    if id in download_progress:
-        total = download_progress[id]["total"]
-        downloaded = download_progress[id]["downloaded"]
-        status = download_progress[id].get("status", "In Progress")
-        progress = (downloaded / total) * 100 if total > 0 else 0
-
-        eta = None
-        if status == "Downloading" and downloaded > 0:
-            elapsed_time = time.time() - download_progress[id]["start_time"]
-            estimated_total_time = elapsed_time * (total / downloaded)
-            eta = estimated_total_time - elapsed_time
-        elif status == "Completed":
-            eta = 0
-
-        return {"total": total, "downloaded": downloaded, "progress": progress, "status": status, "eta": eta}
-    return {"total": 0, "downloaded": 0, "progress": 0, "status": "Not Found", "eta": None}
-
-def update_film_store_json(title, cache_path):
-    """
-    Updates the film store JSON with the new file.
-
-    Args:
-        title (str): The title of the film.
-        cache_path (str): The local path where the file is saved.
-    """
-    FILM_STORE_JSON_PATH = os.path.join(CACHE_DIR, "film_store.json")
-
-    film_store_data = {}
-    if os.path.exists(FILM_STORE_JSON_PATH):
-        with open(FILM_STORE_JSON_PATH, 'r') as json_file:
-            film_store_data = json.load(json_file)
-
-    film_store_data[title] = cache_path
-
-    with open(FILM_STORE_JSON_PATH, 'w') as json_file:
-        json.dump(film_store_data, json_file, indent=2)
-    print(f'Film store updated with {title}.')
-
-
-###############################################################################
-def download_episode(file_url, token, cache_path, proxies, episode_id, title, chunk_size=100 * 1024 * 1024):
-    """
-    Downloads a file from the specified URL and saves it to the cache path.
-    Tracks the download progress.
-
-    Args:
-        file_url (str): The URL of the file to download.
-        token (str): The authorization token for the request.
-        cache_path (str): The path to save the downloaded file.
-        proxies (dict): Proxies for the request.
-        film_id (str): Unique identifier for the film download.
-        title (str): The title of the film.
-        chunk_size (int): Size of each chunk to download.
-    """
-    print(f"Downloading file from URL: {file_url} to {cache_path} with proxies: {proxies}")
-    headers = {'Authorization': f'Bearer {token}'}
-    try:
-        response = requests.get(file_url, headers=headers, proxies=proxies, stream=True)
-        response.raise_for_status()
-        
-        total_size = int(response.headers.get('content-length', 0))
-        download_progress[episode_id] = {"total": total_size, "downloaded": 0, "status": "Downloading", "start_time": time.time()}
-
-        os.makedirs(os.path.dirname(cache_path), exist_ok=True)
-        with open(cache_path, 'wb') as file, tqdm(total=total_size, unit='B', unit_scale=True, desc=cache_path) as pbar:
-            for data in response.iter_content(chunk_size=chunk_size):
-                file.write(data)
-                pbar.update(len(data))
-                download_progress[episode_id]["downloaded"] += len(data)
-        
-        print(f'File cached to {cache_path} successfully.')
-        update_tv_store_json(title, cache_path)
-        download_progress[episode_id]["status"] = "Completed"
-    except RequestException as e:
-        print(f"Error downloading file: {e}")
-        download_progress[episode_id]["status"] = "Failed"
-    except IOError as e:
-        print(f"Error writing file {cache_path}: {e}")
-        download_progress[episode_id]["status"] = "Failed"
-    finally:
-        if download_progress[episode_id]["status"] != "Downloading":
-            download_progress[episode_id]["end_time"] = time.time()
-
-
-def update_tv_store_json(title, cache_path):
-    """
-    Updates the TV store JSON with the new file, organizing by title, season, and episode.
-
-    Args:
-        title (str): The title of the TV show.
-        cache_path (str): The local path where the file is saved.
-    """
-    TV_STORE_JSON_PATH = os.path.join(CACHE_DIR, "tv_store.json")
-
-    tv_store_data = {}
-    if os.path.exists(TV_STORE_JSON_PATH):
-        with open(TV_STORE_JSON_PATH, 'r') as json_file:
-            tv_store_data = json.load(json_file)
-
-    # Extract season and episode information from the cache_path
-    season_part = os.path.basename(os.path.dirname(cache_path))  # Extracts 'Season 1'
-    episode_part = os.path.basename(cache_path)  # Extracts 'Grand Blue Dreaming - S01E01 - Deep Blue HDTV-720p.mp4'
-
-    # Create the structure if not already present
-    if title not in tv_store_data:
-        tv_store_data[title] = {}
-    
-    if season_part not in tv_store_data[title]:
-        tv_store_data[title][season_part] = {}
-
-    # Assuming episode_part is unique for each episode within a season
-    tv_store_data[title][season_part][episode_part] = cache_path
-
-    with open(TV_STORE_JSON_PATH, 'w') as json_file:
-        json.dump(tv_store_data, json_file, indent=2)
-
-    print(f'TV store updated with {title}, {season_part}, {episode_part}.')
-
-###############################################################################
 def get_file_structure(repo, token, path="", proxies=None):
     """
     Fetches the file structure of a specified Hugging Face repository.
@@ -242,8 +70,4 @@ def write_file_structure_to_json(file_structure, file_path):
 
 if __name__ == "__main__":
     file_url = "https://huggingface.co/Unicone-Studio/jellyfin_media/resolve/main/films/Funky%20Monkey%202004/Funky%20Monkey%20(2004)%20Web-dl%201080p.mp4"
-    token = os.getenv("TOKEN")
-    cache_path = os.path.join(CACHE_DIR, "films/Funky Monkey 2004/Funky Monkey (2004) Web-dl 1080p.mp4")
-    proxies = get_system_proxies()
-    film_id = "funky_monkey_2004"  # Unique identifier for the film download
-    download_film(file_url, token, cache_path, proxies=proxies, film_id=film_id)
+    token = os.getenv("TOKEN")

indexer.py

@@ -24,7 +24,6 @@ def indexer():
     token = os.getenv("TOKEN")
     repo = os.getenv("REPO")
     output_path = os.getenv("INDEX_FILE")
-    
     proxies = get_system_proxies()
     full_structure = index_repository(token, repo, "", proxies)
     write_file_structure_to_json(full_structure, output_path)

old.LoadBalancer.py

@@ -1,17 +1,56 @@
+import os
+import json
+import urllib.request
+from tqdm import tqdm
+from indexer import indexer
+import re
+from tvdb import fetch_and_cache_json
+from threading import Event
 import time
 import logging
-from threading import Thread, Event, Timer
+from threading import Thread, Event
 from api import InstancesAPI
 
+
+CACHE_DIR = os.getenv("CACHE_DIR")
+
+download_progress = {}
+
 class LoadBalancer:
-    def __init__(self, polling_interval=10, max_retries=3, initial_delay=1):
-        self.version = "0.0.1 V Beta"
+    def __init__(self, cache_dir, index_file, token, repo, polling_interval=4, max_retries=3, initial_delay=1):
+        self.version = "0.0.2.6 V Beta"
         self.instances = []
+        self.instances_health = {}
         self.polling_interval = polling_interval
         self.max_retries = max_retries
         self.initial_delay = initial_delay
         self.stop_event = Event()
         self.instances_api = InstancesAPI(self.instances)
+        self.CACHE_DIR = cache_dir
+        self.INDEX_FILE = index_file
+        self.TOKEN = token
+        self.REPO = repo
+        self.FILM_STORE = {}
+        self.TV_STORE = {}
+        self.file_structure = None
+
+        # Ensure CACHE_DIR exists
+        if not os.path.exists(self.CACHE_DIR):
+            os.makedirs(self.CACHE_DIR)
+
+        # Index the file structure
+        indexer()
+
+        # Load the file structure JSON
+        if not os.path.exists(self.INDEX_FILE):
+            raise FileNotFoundError(f"{self.INDEX_FILE} not found. Please make sure the file exists.")
+
+        with open(self.INDEX_FILE, 'r') as f:
+            self.file_structure = json.load(f)
+
+        prefetch_thread = Thread(target=self.start_prefetching)
+        prefetch_thread.daemon = True
+        prefetch_thread.start()
 
     def register_instance(self, instance_url):
         if instance_url not in self.instances:
@@ -23,28 +62,55 @@ class LoadBalancer:
     def remove_instance(self, instance_url):
         if instance_url in self.instances:
             self.instances.remove(instance_url)
+            self.instances_health.pop(instance_url, None)
             logging.info(f"Removed instance {instance_url}")
         else:
             logging.info(f"Instance {instance_url} not found for removal.")
         
     def get_reports(self):
         reports = self.instances_api.fetch_reports()
+
+        # Initialize temporary JSON data holders
+        temp_film_store = {}
+        temp_tv_store = {}
+
         for instance_url in self.instances[:]:  # Copy list to avoid modification during iteration
             if instance_url in reports:
                 report = reports[instance_url]
                 logging.info(f"Report from {instance_url}: {report}")
-                self.process_report(instance_url, report)
+                self.process_report(instance_url, report, temp_film_store, temp_tv_store)
             else:
                 logging.error(f"Failed to get report from {instance_url}. Removing instance.")
                 self.remove_instance(instance_url)
 
-    def process_report(self, instance_url, report):
-        # Process the report (film_store, tv_store, cache_size) here
+        self.FILM_STORE = temp_film_store
+        self.TV_STORE = temp_tv_store
+
+    def process_report(self, instance_url, report, temp_film_store, temp_tv_store):
+        film_store = report.get('film_store', {})
+        tv_store = report.get('tv_store', {})
+        cache_size = report.get('cache_size')
+
         logging.info(f"Processing report from {instance_url}")
-        # Example: Print the film_store and tv_store
-        logging.info(f"Film Store: {report.get('film_store')}")
-        logging.info(f"TV Store: {report.get('tv_store')}")
-        logging.info(f"Cache Size: {report.get('cache_size')}")
+
+        # Update temporary film store
+        for title, path in film_store.items():
+            url = f"{instance_url}/api/film/{title.replace(' ', '%20')}"
+            temp_film_store[title] = url
+
+        # Update temporary TV store
+        for title, seasons in tv_store.items():
+            if title not in temp_tv_store:
+                temp_tv_store[title] = {}
+            for season, episodes in seasons.items():
+                if season not in temp_tv_store[title]:
+                    temp_tv_store[title][season] = {}
+                for episode, path in episodes.items():
+                    url = f"{instance_url}/api/tv/{title.replace(' ', '%20')}/{season.replace(' ', '%20')}/{episode.replace(' ', '%20')}"
+                    temp_tv_store[title][season][episode] = url
+
+        logging.info("Film and TV Stores processed successfully.")
+        self.update_instances_health(instance=instance_url, cache_size=cache_size)
 
     def start_polling(self):
         logging.info("Starting polling.")
@@ -57,17 +123,239 @@ class LoadBalancer:
         logging.info("Stopping polling.")
         self.stop_event.set()
 
-if __name__ == "__main__":
-    logging.basicConfig(level=logging.INFO)
+######################################################################
+    @staticmethod
+    def get_system_proxies():
+        """
+        Retrieves the system's HTTP and HTTPS proxies.
+
+        Returns:
+            dict: A dictionary containing the proxies.
+        """
+        try:
+            proxies = urllib.request.getproxies()
+            print("System proxies:", proxies)
+            return {
+                "http": proxies.get("http"),
+                "https": proxies.get("http")
+            }
+        except Exception as e:
+            print(f"Error getting system proxies: {e}")
+            return {}
+
+    @staticmethod
+    def is_valid_url(url):
+        # Simple URL validation (could be more complex if needed)
+        regex = re.compile(
+            r'^(?:http|ftp)s?://' # http:// or https://
+            r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|' # domain...
+            r'localhost|' # localhost...
+            r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|' # ...or ipv4
+            r'\[?[A-F0-9]*:[A-F0-9:]+\]?)' # ...or ipv6
+            r'(?::\d+)?' # optional port
+            r'(?:/?|[/?]\S+)$', re.IGNORECASE)
+        return re.match(regex, url) is not None
+
+#################################################################
+
+    def update_instances_health(self, instance, cache_size):
+        self.instances_health[instance] = {"used":cache_size["cache_size"],
+                                           "total": "50 GB"}
+        logging.info(f"Updated instance {instance} with cache size {cache_size}")
+
+
+    def download_film_to_best_instance(self, title):
+        """
+        Downloads a film to the first instance that has more free space on the self.instance_health list variable. 
+        The instance_health looks like this:
+        {
+            "https://unicone-studio-instance1.hf.space": {
+                "total": "50 GB",
+                "used": "3.33 GB"
+            }
+        }
+        Args:
+            title (str): The title of the film.
+        """
+        best_instance = None
+        max_free_space = -1
+        
+        # Calculate free space for each instance
+        for instance_url, space_info in self.instances_health.items():
+            total_space = self._convert_to_gb(space_info['total'])
+            used_space = self._convert_to_gb(space_info['used'])
+            free_space = total_space - used_space
+            
+            if free_space > max_free_space:
+                max_free_space = free_space
+                best_instance = instance_url
+        
+        if best_instance:
+            result = self.instances_api.download_film(best_instance, title)
+            film_id = result["film_id"]
+            status = result["status"]
+            progress_url = f'{best_instance}/api/progress/{film_id}'
+            response = {
+                "film_id":film_id,
+                "status":status,
+                "progress_url":progress_url
+            }
+
+            return response
+        else:
+            logging.error("No suitable instance found for downloading the film.")
+            return {"error": "No suitable instance found for downloading the film."}
+
+    def download_episode_to_best_instance(self, title, season, episode):
+        """
+        Downloads a episode to the first instance that has more free space on the self.instance_health list variable. 
+        The instance_health looks like this:
+        {
+            "https://unicone-studio-instance1.hf.space": {
+                "total": "50 GB",
+                "used": "3.33 GB"
+            }
+        }
+        Args:
+            title (str): The title of the Tv show.
+            season (str): The season of the Tv show.
+            episode (str): The title of the Tv show.
+        """
+        best_instance = None
+        max_free_space = -1
+        
+        # Calculate free space for each instance
+        for instance_url, space_info in self.instances_health.items():
+            total_space = self._convert_to_gb(space_info['total'])
+            used_space = self._convert_to_gb(space_info['used'])
+            free_space = total_space - used_space
+            
+            if free_space > max_free_space:
+                max_free_space = free_space
+                best_instance = instance_url
+        
+        if best_instance:
+            result = self.instances_api.download_episode(best_instance, title, season, episode)
+            episode_id = result["episode_id"]
+            status = result["status"]
+            progress_url = f'{best_instance}/api/progress/{episode_id}'
+            response = {
+                "episode_id":episode_id,
+                "status":status,
+                "progress_url":progress_url
+            }
+
+            return response
+        else:
+            logging.error("No suitable instance found for downloading the film.")
+            return {"error": "No suitable instance found for downloading the film."}
+
+    def _convert_to_gb(self, space_str):
+        """
+        Converts a space string like '50 GB' or '3.33 GB' to a float representing the number of GB.
+        """
+        return float(space_str.split()[0])
+
+#################################################################
+    def find_movie_path(self, title):
+        """Find the path of the movie in the JSON data based on the title."""
+        for directory in self.file_structure:
+            if directory['type'] == 'directory' and directory['path'] == 'films':
+                for sub_directory in directory['contents']:
+                    if sub_directory['type'] == 'directory':
+                        for item in sub_directory['contents']:
+                            if item['type'] == 'file' and title.lower() in item['path'].lower():
+                                return item['path']
+        return None
+
+    def find_tv_path(self, title):
+        """Find the path of the TV show in the JSON data based on the title."""
+        for directory in self.file_structure:
+            if directory['type'] == 'directory' and directory['path'] == 'tv':
+                for sub_directory in directory['contents']:
+                    if sub_directory['type'] == 'directory' and title.lower() in sub_directory['path'].lower():
+                        return sub_directory['path']
+        return None
+
+    def get_tv_structure(self, title):
+        """Find the path of the TV show in the JSON data based on the title."""
+        for directory in self.file_structure:
+            if directory['type'] == 'directory' and directory['path'] == 'tv':
+                for sub_directory in directory['contents']:
+                    if sub_directory['type'] == 'directory' and title.lower() in sub_directory['path'].lower():
+                        return sub_directory
+        return None
+
+    def get_film_id(self, title):
+        """Generate a film ID based on the title."""
+        return title.replace(" ", "_").lower()
+
+    def prefetch_metadata(self):
+        """Prefetch metadata for all items in the file structure."""
+        for item in self.file_structure:
+            if 'contents' in item:
+                for sub_item in item['contents']:
+                    original_title = sub_item['path'].split('/')[-1]
+                    media_type = 'series' if item['path'].startswith('tv') else 'movie'
+                    title = original_title
+                    year = None
+
+                    # Extract year from the title if available
+                    match = re.search(r'\((\d{4})\)', original_title)
+                    if match:
+                        year_str = match.group(1)
+                        if year_str.isdigit() and len(year_str) == 4:
+                            title = original_title[:match.start()].strip()
+                            year = int(year_str)
+                    else:
+                        parts = original_title.rsplit(' ', 1)
+                        if len(parts) > 1 and parts[-1].isdigit() and len(parts[-1]) == 4:
+                            title = parts[0].strip()
+                            year = int(parts[-1])
+
+                    fetch_and_cache_json(original_title, title, media_type, year)
+
+    def bytes_to_human_readable(self, num, suffix="B"):
+        for unit in ["", "K", "M", "G", "T", "P", "E", "Z"]:
+            if abs(num) < 1024.0:
+                return f"{num:3.1f} {unit}{suffix}"
+            num /= 1024.0
+        return f"{num:.1f} Y{suffix}"
 
-    load_balancer = LoadBalancer()
+    def encode_episodeid(self, title, season, episode):
+        return f"{title}_{season}_{episode}"
 
-    # Example registration (in real use, handle this via an API endpoint)
-    load_balancer.register_instance("http://localhost:5000")
+    def get_all_tv_shows(self):
+        """Get all TV shows from the indexed cache structure JSON file."""
+        tv_shows = {}
+        for directory in self.file_structure:
+            if directory['type'] == 'directory' and directory['path'] == 'tv':
+                for sub_directory in directory['contents']:
+                    if sub_directory['type'] == 'directory':
+                        show_title = sub_directory['path'].split('/')[-1]
+                        tv_shows[show_title] = []
+                        for season_directory in sub_directory['contents']:
+                            if season_directory['type'] == 'directory':
+                                season = season_directory['path'].split('/')[-1]
+                                for episode in season_directory['contents']:
+                                    if episode['type'] == 'file':
+                                        tv_shows[show_title].append({
+                                            "season": season,
+                                            "episode": episode['path'].split('/')[-1],
+                                            "path": episode['path']
+                                        })
+        return tv_shows
 
-    # Start polling in a separate thread
-    polling_thread = Thread(target=load_balancer.start_polling)
-    polling_thread.start()
+    def get_all_films(self):
+        """Get all films from the indexed cache structure JSON file."""
+        films = []
+        for directory in self.file_structure:
+            if directory['type'] == 'directory' and directory['path'] == 'films':
+                for sub_directory in directory['contents']:
+                    if sub_directory['type'] == 'directory':
+                        films.append(sub_directory['path'])
+        return films
 
-    # Stop polling after some time for demonstration purposes
-    Timer(300, load_balancer.stop_polling).start()  # Stop after 5 minutes
+    def start_prefetching(self):
+        """Start the metadata prefetching in a separate thread."""
+        self.prefetch_metadata()

old.app.py

@@ -2,246 +2,70 @@ from flask import Flask, jsonify, request, send_from_directory
 from flask_cors import CORS
 import os
 import json
-import threading
+from threading import Thread
 import urllib.parse
-from hf_scrapper import download_film, download_episode, get_system_proxies, get_download_progress
-from indexer import indexer
-from tvdb import fetch_and_cache_json
-import re
-import logging
 from LoadBalancer import LoadBalancer
+import logging
 
-logging.basicConfig(level=logging.INFO)
-load_balancer = LoadBalancer()
-
-# Start polling in a separate thread
-polling_thread = threading.Thread(target=load_balancer.start_polling)
-polling_thread.start()
 
 app = Flask(__name__)
 CORS(app)
 
+logging.basicConfig(level=logging.INFO)
 # Constants and Configuration
 CACHE_DIR = os.getenv("CACHE_DIR")
 INDEX_FILE = os.getenv("INDEX_FILE")
 TOKEN = os.getenv("TOKEN")
-FILM_STORE_JSON_PATH = os.path.join(CACHE_DIR, "film_store.json")
-TV_STORE_JSON_PATH = os.path.join(CACHE_DIR, "tv_store.json")
-INSTANCE_REGISTER_JSON_PATH = os.path.join(CACHE_DIR, "instance_register.json")
 REPO = os.getenv("REPO")
-download_threads = {}
-
-# Ensure CACHE_DIR exists
-if not os.path.exists(CACHE_DIR):
-    os.makedirs(CACHE_DIR)
-
-for path in [FILM_STORE_JSON_PATH, TV_STORE_JSON_PATH]:
-    if not os.path.exists(path):
-        with open(path, 'w') as json_file:
-            json.dump({}, json_file)
-
-# Index the file structure
-indexer()
 
-# Load the file structure JSON
-if not os.path.exists(INDEX_FILE):
-    raise FileNotFoundError(f"{INDEX_FILE} not found. Please make sure the file exists.")
+load_balancer = LoadBalancer(cache_dir=CACHE_DIR, index_file=INDEX_FILE, token=TOKEN, repo=REPO)
 
-with open(INDEX_FILE, 'r') as f:
-    file_structure = json.load(f)
-
-# Function Definitions
-def load_json(file_path):
-    """Load JSON data from a file."""
-    with open(file_path, 'r') as file:
-        return json.load(file)
-
-def find_movie_path(json_data, title):
-    """Find the path of the movie in the JSON data based on the title."""
-    for directory in json_data:
-        if directory['type'] == 'directory' and directory['path'] == 'films':
-            for sub_directory in directory['contents']:
-                if sub_directory['type'] == 'directory':
-                    for item in sub_directory['contents']:
-                        if item['type'] == 'file' and title.lower() in item['path'].lower():
-                            return item['path']
-    return None
-
-def find_tv_path(json_data, title):
-    """Find the path of the TV show in the JSON data based on the title."""
-    for directory in json_data:
-        if directory['type'] == 'directory' and directory['path'] == 'tv':
-            for sub_directory in directory['contents']:
-                if sub_directory['type'] == 'directory' and title.lower() in sub_directory['path'].lower():
-                    return sub_directory['path']
-    return None
-
-def get_tv_structure(json_data,title):
-    """Find the path of the TV show in the JSON data based on the title."""
-    for directory in json_data:
-        if directory['type'] == 'directory' and directory['path'] == 'tv':
-            for sub_directory in directory['contents']:
-                if sub_directory['type'] == 'directory' and title.lower() in sub_directory['path'].lower():
-                    return sub_directory
-    return None
-
-def get_film_id(title):
-    """Generate a film ID based on the title."""
-    return title.replace(" ", "_").lower()
-
-def prefetch_metadata():
-    """Prefetch metadata for all items in the file structure."""
-    for item in file_structure:
-        if 'contents' in item:
-            for sub_item in item['contents']:
-                original_title = sub_item['path'].split('/')[-1]
-                media_type = 'series' if item['path'].startswith('tv') else 'movie'
-                title = original_title
-                year = None
-                
-                # Extract year from the title if available
-                match = re.search(r'\((\d{4})\)', original_title)
-                if match:
-                    year_str = match.group(1)
-                    if year_str.isdigit() and len(year_str) == 4:
-                        title = original_title[:match.start()].strip()
-                        year = int(year_str)
-                else:
-                    parts = original_title.rsplit(' ', 1)
-                    if len(parts) > 1 and parts[-1].isdigit() and len(parts[-1]) == 4:
-                        title = parts[0].strip()
-                        year = int(parts[-1])
-                
-                fetch_and_cache_json(original_title, title, media_type, year)
-
-def bytes_to_human_readable(num, suffix="B"):
-    for unit in ["", "K", "M", "G", "T", "P", "E", "Z"]:
-        if abs(num) < 1024.0:
-            return f"{num:3.1f} {unit}{suffix}"
-        num /= 1024.0
-    return f"{num:.1f} Y{suffix}"
-
-def encode_episodeid(title,season,episode):
-    return f"{title}_{season}_{episode}"
-
-def is_valid_url(url):
-    # Simple URL validation (could be more complex if needed)
-    regex = re.compile(
-        r'^(?:http|ftp)s?://' # http:// or https://
-        r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|' # domain...
-        r'localhost|' # localhost...
-        r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|' # ...or ipv4
-        r'\[?[A-F0-9]*:[A-F0-9:]+\]?)' # ...or ipv6
-        r'(?::\d+)?' # optional port
-        r'(?:/?|[/?]\S+)$', re.IGNORECASE)
-    return re.match(regex, url) is not None
-
-def get_all_tv_shows(indexed_cache):
-    """Get all TV shows from the indexed cache structure JSON file."""
-    tv_shows = {}
-    for directory in indexed_cache:
-        if directory['type'] == 'directory' and directory['path'] == 'tv':
-            for sub_directory in directory['contents']:
-                if sub_directory['type'] == 'directory':
-                    show_title = sub_directory['path'].split('/')[-1]
-                    tv_shows[show_title] = []
-                    for season_directory in sub_directory['contents']:
-                        if season_directory['type'] == 'directory':
-                            season = season_directory['path'].split('/')[-1]
-                            for episode in season_directory['contents']:
-                                if episode['type'] == 'file':
-                                    tv_shows[show_title].append({
-                                        "season": season,
-                                        "episode": episode['path'].split('/')[-1],
-                                        "path": episode['path']
-                                    })
-    return tv_shows
-
-def get_all_films(indexed_cache):
-    """Get all films from the indexed cache structure JSON file."""
-    films = []
-    for directory in indexed_cache:
-        if directory['type'] == 'directory' and directory['path'] == 'films':
-            for sub_directory in directory['contents']:
-                if sub_directory['type'] == 'directory':
-                    films.append(sub_directory['path'])
-    return films
-
-def start_prefetching():
-    """Start the metadata prefetching in a separate thread."""
-    prefetch_metadata()
-
-# Start prefetching metadata
-thread = threading.Thread(target=start_prefetching)
-thread.daemon = True
-thread.start()
+# Start polling in a separate thread
+polling_thread = Thread(target=load_balancer.start_polling)
+polling_thread.start()
 
 # API Endpoints
-
-@app.route('/api/film', methods=['GET'])
-def get_movie_api():
+@app.route('/api/film/<title>', methods=['GET'])
+def get_movie_api(title):
     """Endpoint to get the movie by title."""
-    title = request.args.get('title')
     if not title:
         return jsonify({"error": "Title parameter is required"}), 400
     
-    # Load the film store JSON
-    with open(FILM_STORE_JSON_PATH, 'r') as json_file:
-        film_store_data = json.load(json_file)
-
     # Check if the film is already cached
-    if title in film_store_data:
-        cache_path = film_store_data[title]
-        if os.path.exists(cache_path):
-            return send_from_directory(os.path.dirname(cache_path), os.path.basename(cache_path))
-    
-    movie_path = find_movie_path(file_structure, title)
+    if title in load_balancer.FILM_STORE:
+        url = load_balancer.FILM_STORE[title]
+        return jsonify({"url":url})
+
+    movie_path = load_balancer.find_movie_path(title)
     
     if not movie_path:
         return jsonify({"error": "Movie not found"}), 404
     
-    cache_path = os.path.join(CACHE_DIR, movie_path)
-    file_url = f"https://huggingface.co/{REPO}/resolve/main/{movie_path}"
-    proxies = get_system_proxies()
-    film_id = get_film_id(title)
-    
-    # Start the download in a separate thread if not already downloading
-    if film_id not in download_threads or not download_threads[film_id].is_alive():
-        thread = threading.Thread(target=download_film, args=(file_url, TOKEN, cache_path, proxies, film_id, title))
-        download_threads[film_id] = thread
-        thread.start()
-    
-    return jsonify({"status": "Download started", "film_id": film_id})
+    # Start the download in a instance
+    response = load_balancer.download_film_to_best_instance(title=title)
+    if response:
+        return jsonify(response)
 
-@app.route('/api/tv', methods=['GET'])
-def get_tv_show_api():
+@app.route('/api/tv/<title>/<season>/<episode>', methods=['GET'])
+def get_tv_show_api(title, season, episode):
     """Endpoint to get the TV show by title, season, and episode."""
-    title = request.args.get('title')
-    season = request.args.get('season')
-    episode = request.args.get('episode')
-    
     if not title or not season or not episode:
         return jsonify({"error": "Title, season, and episode parameters are required"}), 400
 
-    # Load the TV store JSON
-    with open(TV_STORE_JSON_PATH, 'r') as json_file:
-        tv_store_data = json.load(json_file)
-
     # Check if the episode is already cached
-    if title in tv_store_data and season in tv_store_data[title]:
-        for ep in tv_store_data[title][season]:
+    if title in load_balancer.TV_STORE and season in load_balancer.TV_STORE[title]:
+        for ep in load_balancer.TV_STORE[title][season]:
             if episode in ep:
-                cache_path = tv_store_data[title][season][ep]
-                if os.path.exists(cache_path):
-                    return send_from_directory(os.path.dirname(cache_path), os.path.basename(cache_path))
+                url = load_balancer.TV_STORE[title][season][ep]
+                return jsonify({"url":url})
 
-    tv_path = find_tv_path(file_structure, title)
+    tv_path = load_balancer.find_tv_path(title)
     
     if not tv_path:
         return jsonify({"error": "TV show not found"}), 404
 
     episode_path = None
-    for directory in file_structure:
+    for directory in load_balancer.file_structure:
         if directory['type'] == 'directory' and directory['path'] == 'tv':
             for sub_directory in directory['contents']:
                 if sub_directory['type'] == 'directory' and title.lower() in sub_directory['path'].lower():
@@ -255,25 +79,26 @@ def get_tv_show_api():
     if not episode_path:
         return jsonify({"error": "Episode not found"}), 404
     
-    cache_path = os.path.join(CACHE_DIR, episode_path)
-    file_url = f"https://huggingface.co/{REPO}/resolve/main/{episode_path}"
-    proxies = get_system_proxies()
-    episode_id = encode_episodeid(title,season,episode)
-    
-    # Start the download in a separate thread if not already downloading
-    if episode_id not in download_threads or not download_threads[episode_id].is_alive():
-        thread = threading.Thread(target=download_episode, args=(file_url, TOKEN, cache_path, proxies, episode_id, title))
-        download_threads[episode_id] = thread
-        thread.start()
-    
-    return jsonify({"status": "Download started", "episode_id": episode_id})
+    # Start the download in a instance
+    response = load_balancer.download_episode_to_best_instance(title=title, season=season, episode=episode)
+    if response:
+        return jsonify(response)
 
+@app.route('/api/filmid/<title>', methods=['GET'])
+def get_film_id_by_title_api(title):
+    """Endpoint to get the film ID by providing the movie title."""
+    if not title:
+        return jsonify({"error": "Title parameter is required"}), 400
+    film_id = load_balancer.get_film_id(title)
+    return jsonify({"film_id": film_id})
 
-@app.route('/api/progress/<id>', methods=['GET'])
-def get_progress_api(id):
-    """Endpoint to get the download progress of a movie or TV show episode."""
-    progress = get_download_progress(id)
-    return jsonify({"id": id, "progress": progress})
+@app.route('/api/episodeid/<title>/<season>/<episode>', methods=['GET'])
+def get_episode_id_api(title,season,episode):
+    """Endpoint to get the episode ID by providing the TV show title, season, and episode."""
+    if not title or not season or not episode:
+        return jsonify({"error": "Title, season, and episode parameters are required"}), 400
+    episode_id = load_balancer.encode_episodeid(title,season,episode)
+    return jsonify({"episode_id": episode_id})
 
 @app.route('/api/cache/size', methods=['GET'])
 def get_cache_size_api():
@@ -282,7 +107,7 @@ def get_cache_size_api():
         for f in filenames:
             fp = os.path.join(dirpath, f)
             total_size += os.path.getsize(fp)
-    readable_size = bytes_to_human_readable(total_size)
+    readable_size = load_balancer.bytes_to_human_readable(total_size)
     return jsonify({"cache_size": readable_size})
 
 @app.route('/api/cache/clear', methods=['POST'])
@@ -296,48 +121,18 @@ def clear_cache_api():
 @app.route('/api/tv/store', methods=['GET'])
 def get_tv_store_api():
     """Endpoint to get the TV store JSON."""
-    if os.path.exists(TV_STORE_JSON_PATH):
-        with open(TV_STORE_JSON_PATH, 'r') as json_file:
-            tv_store_data = json.load(json_file)
-        return jsonify(tv_store_data)
-    return jsonify({}), 404
+    return jsonify(load_balancer.TV_STORE)
+
 
 @app.route('/api/film/store', methods=['GET'])
 def get_film_store_api():
     """Endpoint to get the film store JSON."""
-    if os.path.exists(FILM_STORE_JSON_PATH):
-        with open(FILM_STORE_JSON_PATH, 'r') as json_file:
-            tv_store_data = json.load(json_file)
-        return jsonify(tv_store_data)
-    return jsonify({}), 404
-
-#################################################
-# No change needed
+    return jsonify(load_balancer.FILM_STORE)
 
-@app.route('/api/filmid', methods=['GET'])
-def get_film_id_by_title_api():
-    """Endpoint to get the film ID by providing the movie title."""
-    title = request.args.get('title')
-    if not title:
-        return jsonify({"error": "Title parameter is required"}), 400
-    film_id = get_film_id(title)
-    return jsonify({"film_id": film_id})
-
-@app.route('/api/episodeid', methods=['GET'])
-def get_episode_id_api():
-    """Endpoint to get the episode ID by providing the TV show title, season, and episode."""
-    title = request.args.get('title')
-    season = request.args.get('season')
-    episode = request.args.get('episode')
-    if not title or not season or not episode:
-        return jsonify({"error": "Title, season, and episode parameters are required"}), 400
-    episode_id = encode_episodeid(title,season,episode)
-    return jsonify({"episode_id": episode_id})
 
-@app.route('/api/film/metadata', methods=['GET'])
-def get_film_metadata_api():
+@app.route('/api/film/metadata/<title>', methods=['GET'])
+def get_film_metadata_api(title):
     """Endpoint to get the film metadata by title."""
-    title = request.args.get('title')
     if not title:
         return jsonify({'error': 'No title provided'}), 400
     
@@ -350,10 +145,9 @@ def get_film_metadata_api():
     
     return jsonify({'error': 'Metadata not found'}), 404
 
-@app.route('/api/tv/metadata', methods=['GET'])
-def get_tv_metadata_api():
+@app.route('/api/tv/metadata/<title>', methods=['GET'])
+def get_tv_metadata_api(title):
     """Endpoint to get the TV show metadata by title."""
-    title = request.args.get('title')
     if not title:
         return jsonify({'error': 'No title provided'}), 400
     
@@ -364,7 +158,7 @@ def get_tv_metadata_api():
             data = json.load(f)
         
         # Add the file structure to the metadata
-        tv_structure_data = get_tv_structure(file_structure, title)
+        tv_structure_data = load_balancer.get_tv_structure(title)
         if tv_structure_data:
             data['file_structure'] = tv_structure_data
         
@@ -375,14 +169,21 @@ def get_tv_metadata_api():
 
 @app.route("/api/film/all")
 def get_all_films_api():
-    return get_all_films(file_structure)
+    return load_balancer.get_all_films()
 
 @app.route("/api/tv/all")
 def get_all_tvshows_api():
-    return get_all_tv_shows(file_structure)
+    return load_balancer.get_all_tv_shows()
 
+@app.route('/api/instances',methods=["GET"])
+def get_instances():
+    return load_balancer.instances
+
+@app.route('/api/instances/health',methods=["GET"])
+def get_instances_health():
+    return load_balancer.instances_health
 #############################################################
-# unique api's
+#  This API is only for instances
 @app.route('/api/register', methods=['POST'])
 def register_instance():
     try:
@@ -391,7 +192,7 @@ def register_instance():
             return jsonify({"error": "No URL provided"}), 400
         
         url = data["url"]
-        if not is_valid_url(url):
+        if not load_balancer.is_valid_url(url):
             return jsonify({"error": "Invalid URL"}), 400
 
         # Register the instance
@@ -403,16 +204,13 @@ def register_instance():
     except Exception as e:
         logging.error(f"Error registering instance: {e}")
         return jsonify({"error": "Failed to register instance"}), 500
+    
 #############################################################
 # Routes
 @app.route('/')
 def index():
     return f"Load Balancer is Running {load_balancer.version}"
 
-@app.route('/api/instances',methods=["GET"])
-def get_instances():
-    return load_balancer.instances
-
 # Main entry point
 if __name__ == "__main__":
     app.run(debug=True, host="0.0.0.0", port=7860)

utils.py

@@ -0,0 +1,64 @@
+import re
+
+def is_valid_url(url):
+    """
+    Validates the URL.
+
+    Args:
+        url (str): The URL to validate.
+
+    Returns:
+        bool: True if the URL is valid, False otherwise.
+    """
+    regex = re.compile(
+        r'^(?:http|ftp)s?://'  # http:// or https://
+        r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|'  # domain...
+        r'localhost|'  # localhost...
+        r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|'  # ...or ipv4
+        r'\[?[A-F0-9]*:[A-F0-9:]+\]?)'  # ...or ipv6
+        r'(?::\d+)?'  # optional port
+        r'(?:/?|[/?]\S+)$', re.IGNORECASE)
+    return re.match(regex, url) is not None
+
+def convert_to_gb(space_str):
+    """
+    Converts a space string like '50 GB' or '3.33 GB' to a float representing the number of GB.
+
+    Args:
+        space_str (str): The space string to convert.
+
+    Returns:
+        float: The space in GB.
+    """
+    return float(space_str.split()[0])
+
+def bytes_to_human_readable(num, suffix="B"):
+    """
+    Converts bytes to a human-readable format.
+
+    Args:
+        num (int): The number of bytes.
+        suffix (str): The suffix to use (default is 'B').
+
+    Returns:
+        str: The human-readable string.
+    """
+    for unit in ["", "K", "M", "G", "T", "P", "E", "Z"]:
+        if abs(num) < 1024.0:
+            return f"{num:3.1f} {unit}{suffix}"
+        num /= 1024.0
+    return f"{num:.1f} Y{suffix}"
+
+def encode_episodeid(title, season, episode):
+    """
+    Encodes the episode ID based on title, season, and episode.
+
+    Args:
+        title (str): The title of the TV show.
+        season (str): The season of the TV show.
+        episode (str): The episode number.
+
+    Returns:
+        str: The encoded episode ID.
+    """
+    return f"{title}_{season}_{episode}"