0.0.2.3 V Beta. added download episode.

LoadBalancer.py

@@ -19,7 +19,7 @@ download_progress = {}
 
 class LoadBalancer:
     def __init__(self, cache_dir, index_file, token, repo, polling_interval=10, max_retries=3, initial_delay=1):
-        self.version = "0.0.2.2 V Beta"
+        self.version = "0.0.2.3 V Beta"
         self.instances = []
         self.instances_health = {}
         self.polling_interval = polling_interval
@@ -264,6 +264,50 @@ class LoadBalancer:
             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 = {
+                "film_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.

api.py

@@ -38,3 +38,26 @@ class InstancesAPI:
             data = {"error": str(e)}
 
         return data
+
+    def download_episode(self, instance_url, title, season, episode):
+        """
+        Download a film to an instance.
+
+        If the download started, it returns a JSON like this:
+        example: 
+            {"film_id": "my_spy_2020",
+            "status": "Download started"}
+
+        If the film has already been downloaded, it will return the video file. 
+        """
+        data = {}
+        try:
+            response = requests.get(f"{instance_url}/api/tv/{title}/{season}/{episode}")
+            response.raise_for_status()
+            data = response.json()
+            
+        except requests.exceptions.RequestException as e:
+            logging.error(f"Error contacting instance {instance_url}: {e}")
+            data = {"error": str(e)}
+
+        return data

app.py

@@ -64,10 +64,8 @@ def get_tv_show_api(title, season, episode):
     if title in tv_store_data and season in tv_store_data[title]:
         for ep in tv_store_data[title][season]:
             if episode in ep:
-                cache_path = tv_store_data[title][season][ep]
-                print(cache_path)
-                if os.path.exists(cache_path):
-                    return send_from_directory(os.path.dirname(cache_path), os.path.basename(cache_path))
+                url = tv_store_data[title][season][ep]
+                return jsonify({"url":url})
 
     tv_path = load_balancer.find_tv_path(title)
     
@@ -89,18 +87,10 @@ def get_tv_show_api(title, season, episode):
     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 = load_balancer.get_system_proxies()
-    episode_id = load_balancer.encode_episodeid(title, season, episode)
-    
-    # Start the download in a separate thread if not already downloading
-    if episode_id not in load_balancer.download_threads or not load_balancer.download_threads[episode_id].is_alive():
-        thread = Thread(target=load_balancer.download_episode, args=(file_url, TOKEN, cache_path, proxies, episode_id, title))
-        load_balancer.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/progress/<id>', methods=['GET'])
 def get_progress_api(id):