download a film to best instance

LoadBalancer.py

@@ -148,16 +148,6 @@ class LoadBalancer:
             print(f"Error getting system proxies: {e}")
             return {}
 
-    @staticmethod
-    def download_film(title):
-        """
-        Downloads a film to a specific instance
-
-        Args:
-            title (str): The title of the film.
-        """
-        pass
-
     @staticmethod
     def update_film_store_json(title, url):
         """
@@ -231,6 +221,55 @@ class LoadBalancer:
                                            "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.instance_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 _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 load_json(self, file_path):
         """Load JSON data from a file."""

api.py

@@ -15,3 +15,26 @@ class InstancesAPI:
             except requests.exceptions.RequestException as e:
                 logging.error(f"Error contacting instance {instance_url}: {e}")
         return reports
+
+    def download_film(self, instance_url, title):
+        """
+        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/film/{title}")
+            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

@@ -37,27 +37,18 @@ def get_movie_api(title):
 
     # 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))
-    
+        url = film_store_data[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 = load_balancer.get_system_proxies()
-    film_id = load_balancer.get_film_id(title)
-    
-    # Start the download in a separate thread if not already downloading
-    if film_id not in load_balancer.download_threads or not load_balancer.download_threads[film_id].is_alive():
-        thread = Thread(target=load_balancer.download_film, args=(file_url, TOKEN, cache_path, proxies, film_id, title))
-        load_balancer.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/<title>/<season>/<episode>', methods=['GET'])
 def get_tv_show_api(title, season, episode):