0.0.2.8 V Beta

LoadBalancer.py

@@ -1,11 +1,10 @@
 import os
 import json
-from indexer import indexer
+import asyncio
+import logging
 import re
+from indexer import indexer
 from tvdb import fetch_and_cache_json
-from threading import Event, Thread
-import time
-import logging
 from utils import convert_to_gb
 from api import InstancesAPI
 
@@ -15,13 +14,13 @@ 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.7 V Beta"
+        self.version = "0.0.2.8 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.stop_event = asyncio.Event()
         self.instances_api = InstancesAPI(self.instances)
         self.CACHE_DIR = cache_dir
         self.INDEX_FILE = index_file
@@ -42,16 +41,11 @@ class LoadBalancer:
         # 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()
+        # Start polling and file checking in separate tasks
+        asyncio.create_task(self.start_polling())
+        asyncio.create_task(self.check_file_updates())
 
-    def load_file_structure(self):
+    async 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.")
 
@@ -59,23 +53,21 @@ class LoadBalancer:
             self.file_structure = json.load(f)
         logging.info("File structure loaded successfully.")
 
-    def check_file_updates(self):
+    async 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
+                await 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()
+                # Restart prefetching task
+                if hasattr(self, 'prefetch_task') and not self.prefetch_task.done():
+                    await self.prefetch_task
                 
-                self.prefetch_thread = Thread(target=self.start_prefetching)
-                self.prefetch_thread.daemon = True
-                self.prefetch_thread.start()
+                self.prefetch_task = asyncio.create_task(self.start_prefetching())
 
-            time.sleep(120)  # Check every 2 minutes
+            await asyncio.sleep(120)  # Check every 2 minutes
 
     def register_instance(self, instance_url):
         if instance_url not in self.instances:
@@ -92,8 +84,8 @@ class LoadBalancer:
         else:
             logging.info(f"Instance {instance_url} not found for removal.")
         
-    def get_reports(self):
-        reports = self.instances_api.fetch_reports()
+    async def get_reports(self):
+        reports = await self.instances_api.fetch_reports()
 
         # Initialize temporary JSON data holders
         temp_film_store = {}
@@ -137,30 +129,27 @@ class LoadBalancer:
         logging.info("Film and TV Stores processed successfully.")
         self.update_instances_health(instance=instance_url, cache_size=cache_size)
 
-    def start_polling(self):
+    async def start_polling(self):
         logging.info("Starting polling.")
         while not self.stop_event.is_set():
-            self.get_reports()
-            time.sleep(self.polling_interval)
+            await self.get_reports()
+            await asyncio.sleep(self.polling_interval)
         logging.info("Polling stopped.")
 
-    def stop_polling(self):
+    async def stop_polling(self):
         logging.info("Stopping polling.")
         self.stop_event.set()
 
-    def start_prefetching(self):
-        """Start the metadata prefetching in a separate thread."""
-        self.prefetch_metadata()
-
-#################################################################
+    async def start_prefetching(self):
+        """Start the metadata prefetching."""
+        await self.prefetch_metadata()
 
     def update_instances_health(self, instance, cache_size):
-        self.instances_health[instance] = {"used":cache_size["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):
+    async 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:
@@ -187,14 +176,14 @@ class LoadBalancer:
                 best_instance = instance_url
         
         if best_instance:
-            result = self.instances_api.download_film(best_instance, title)
+            result = await 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
+                "film_id": film_id,
+                "status": status,
+                "progress_url": progress_url
             }
 
             return response
@@ -202,9 +191,9 @@ 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):
+    async 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. 
+        Downloads an 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": {
@@ -213,9 +202,9 @@ class LoadBalancer:
             }
         }
         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.
+            title (str): The title of the TV show.
+            season (str): The season of the TV show.
+            episode (str): The episode of the TV show.
         """
         best_instance = None
         max_free_space = -1
@@ -231,23 +220,22 @@ class LoadBalancer:
                 best_instance = instance_url
         
         if best_instance:
-            result = self.instances_api.download_episode(best_instance, title, season, episode)
+            result = await 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
+                "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."}
+            logging.error("No suitable instance found for downloading the episode.")
+            return {"error": "No suitable instance found for downloading the episode."}
 
-#################################################################
-    def find_movie_path(self, title):
+    async 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':
@@ -258,7 +246,7 @@ class LoadBalancer:
                                 return item['path']
         return None
 
-    def find_tv_path(self, title):
+    async 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':
@@ -267,7 +255,7 @@ class LoadBalancer:
                         return sub_directory['path']
         return None
 
-    def get_tv_structure(self, title):
+    async 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':
@@ -276,11 +264,11 @@ class LoadBalancer:
                         return sub_directory
         return None
 
-    def get_film_id(self, title):
+    async def get_film_id(self, title):
         """Generate a film ID based on the title."""
         return title.replace(" ", "_").lower()
 
-    def prefetch_metadata(self):
+    async def prefetch_metadata(self):
         """Prefetch metadata for all items in the file structure."""
         for item in self.file_structure:
             if 'contents' in item:
@@ -303,9 +291,9 @@ class LoadBalancer:
                             title = parts[0].strip()
                             year = int(parts[-1])
 
-                    fetch_and_cache_json(original_title, title, media_type, year)
+                    await fetch_and_cache_json(original_title, title, media_type, year)
 
-    def get_all_tv_shows(self):
+    async 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:
@@ -326,7 +314,7 @@ class LoadBalancer:
                                         })
         return tv_shows
 
-    def get_all_films(self):
+    async def get_all_films(self):
         """Get all films from the indexed cache structure JSON file."""
         films = []
         for directory in self.file_structure:
@@ -334,4 +322,4 @@ class LoadBalancer:
                 for sub_directory in directory['contents']:
                     if sub_directory['type'] == 'directory':
                         films.append(sub_directory['path'])
-        return films
+        return films

app.py

@@ -1,217 +1,22 @@
-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
-import urllib.parse
-from LoadBalancer import LoadBalancer
-import logging
+import subprocess
+import sys
+
+def run_uvicorn():
+    # Command to run the FastAPI app with uvicorn
+    command = [
+        "uvicorn",
+        "main:app",
+        "--host", "0.0.0.0",
+        "--port", "7860",
+        "--reload"
+    ]
+    
+    # Run the command
+    subprocess.run(command, check=True)
 
-
-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")
-REPO = os.getenv("REPO")
-
-load_balancer = LoadBalancer(cache_dir=CACHE_DIR, index_file=INDEX_FILE, token=TOKEN, repo=REPO)
-
-# Start polling in a separate thread
-polling_thread = Thread(target=load_balancer.start_polling)
-polling_thread.start()
-
-# API Endpoints
-@app.route('/api/film/<title>', methods=['GET'])
-def get_movie_api(title):
-    """Endpoint to get the movie by title."""
-    if not title:
-        return jsonify({"error": "Title parameter is required"}), 400
-    
-    # Check if the film is already cached
-    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
-    
-    # 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):
-    """Endpoint to get the TV show by title, season, and episode."""
-    if not title or not season or not episode:
-        return jsonify({"error": "Title, season, and episode parameters are required"}), 400
-
-    # Check if the episode is already cached
-    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:
-                url = load_balancer.TV_STORE[title][season][ep]
-                return jsonify({"url":url})
-
-    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 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():
-                    for season_dir in sub_directory['contents']:
-                        if season_dir['type'] == 'directory' and season in season_dir['path']:
-                            for episode_file in season_dir['contents']:
-                                if episode_file['type'] == 'file' and episode in episode_file['path']:
-                                    episode_path = episode_file['path']
-                                    break
-
-    if not episode_path:
-        return jsonify({"error": "Episode not found"}), 404
-    
-    # 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/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 = encode_episodeid(title,season,episode)
-    return jsonify({"episode_id": episode_id})
-
-@app.route('/api/cache/size', methods=['GET'])
-def get_cache_size_api():
-    total_size = 0
-    for dirpath, dirnames, filenames in os.walk(CACHE_DIR):
-        for f in filenames:
-            fp = os.path.join(dirpath, f)
-            total_size += os.path.getsize(fp)
-    readable_size = bytes_to_human_readable(total_size)
-    return jsonify({"cache_size": readable_size})
-
-@app.route('/api/cache/clear', methods=['POST'])
-def clear_cache_api():
-    for dirpath, dirnames, filenames in os.walk(CACHE_DIR):
-        for f in filenames:
-            fp = os.path.join(dirpath, f)
-            os.remove(fp)
-    return jsonify({"status": "Cache cleared"})
-
-@app.route('/api/tv/store', methods=['GET'])
-def get_tv_store_api():
-    """Endpoint to get the TV store JSON."""
-    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."""
-    return jsonify(load_balancer.FILM_STORE)
-
-
-@app.route('/api/film/metadata/<title>', methods=['GET'])
-def get_film_metadata_api(title):
-    """Endpoint to get the film metadata by title."""
-    if not title:
-        return jsonify({'error': 'No title provided'}), 400
-    
-    json_cache_path = os.path.join(CACHE_DIR, f"{urllib.parse.quote(title)}.json")
-    
-    if os.path.exists(json_cache_path):
-        with open(json_cache_path, 'r') as f:
-            data = json.load(f)
-        return jsonify(data)
-    
-    return jsonify({'error': 'Metadata not found'}), 404
-
-@app.route('/api/tv/metadata/<title>', methods=['GET'])
-def get_tv_metadata_api(title):
-    """Endpoint to get the TV show metadata by title."""
-    if not title:
-        return jsonify({'error': 'No title provided'}), 400
-    
-    json_cache_path = os.path.join(CACHE_DIR, f"{urllib.parse.quote(title)}.json")
-    
-    if os.path.exists(json_cache_path):
-        with open(json_cache_path, 'r') as f:
-            data = json.load(f)
-        
-        # Add the file structure to the metadata
-        tv_structure_data = load_balancer.get_tv_structure(title)
-        if tv_structure_data:
-            data['file_structure'] = tv_structure_data
-        
-        return jsonify(data)
-    
-    return jsonify({'error': 'Metadata not found'}), 404
-
-
-@app.route("/api/film/all")
-def get_all_films_api():
-    return load_balancer.get_all_films()
-
-@app.route("/api/tv/all")
-def get_all_tvshows_api():
-    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
-#############################################################
-#  This API is only for instances
-@app.route('/api/register', methods=['POST'])
-def register_instance():
-    try:
-        data = request.json
-        if not data or "url" not in data:
-            return jsonify({"error": "No URL provided"}), 400
-        
-        url = data["url"]
-        if not is_valid_url(url):
-            return jsonify({"error": "Invalid URL"}), 400
-
-        # Register the instance
-        load_balancer.register_instance(url)
-        logging.info(f"Instance registered: {url}")
-
-        return jsonify({"message": f"Instance {url} registered successfully"}), 200
-
-    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}"
-
-# Main entry point
 if __name__ == "__main__":
-    app.run(debug=True, host="0.0.0.0", port=7860)
+    try:
+        run_uvicorn()
+    except subprocess.CalledProcessError as e:
+        print(f"Error running uvicorn: {e}", file=sys.stderr)
+        sys.exit(1)

main.py

@@ -0,0 +1,219 @@
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from utils import is_valid_url, bytes_to_human_readable, encode_episodeid
+import os
+import json
+import urllib.parse
+from threading import Thread
+from LoadBalancer import LoadBalancer
+import logging
+
+app = FastAPI()
+
+# CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+logging.basicConfig(level=logging.INFO)
+
+# Constants and Configuration
+CACHE_DIR = os.getenv("CACHE_DIR")
+INDEX_FILE = os.getenv("INDEX_FILE")
+TOKEN = os.getenv("TOKEN")
+REPO = os.getenv("REPO")
+
+load_balancer = LoadBalancer(cache_dir=CACHE_DIR, index_file=INDEX_FILE, token=TOKEN, repo=REPO)
+
+# Start polling in a separate thread
+polling_thread = Thread(target=load_balancer.start_polling)
+polling_thread.start()
+
+# API Endpoints
+@app.get("/api/film/{title}")
+async def get_movie_api(title: str):
+    """Endpoint to get the movie by title."""
+    if not title:
+        raise HTTPException(status_code=400, detail="Title parameter is required")
+    
+    # Check if the film is already cached
+    if title in load_balancer.FILM_STORE:
+        url = load_balancer.FILM_STORE[title]
+        return JSONResponse(content={"url": url})
+
+    movie_path = await load_balancer.find_movie_path(title)
+    
+    if not movie_path:
+        raise HTTPException(status_code=404, detail="Movie not found")
+    
+    # Start the download in an instance
+    response = await load_balancer.download_film_to_best_instance(title=title)
+    if response:
+        return JSONResponse(content=response)
+
+@app.get("/api/tv/{title}/{season}/{episode}")
+async def get_tv_show_api(title: str, season: str, episode: str):
+    """Endpoint to get the TV show by title, season, and episode."""
+    if not title or not season or not episode:
+        raise HTTPException(status_code=400, detail="Title, season, and episode parameters are required")
+
+    # Check if the episode is already cached
+    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:
+                url = load_balancer.TV_STORE[title][season][ep]
+                return JSONResponse(content={"url": url})
+
+    tv_path = await load_balancer.find_tv_path(title)
+    
+    if not tv_path:
+        raise HTTPException(status_code=404, detail="TV show not found")
+
+    episode_path = None
+    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():
+                    for season_dir in sub_directory['contents']:
+                        if season_dir['type'] == 'directory' and season in season_dir['path']:
+                            for episode_file in season_dir['contents']:
+                                if episode_file['type'] == 'file' and episode in episode_file['path']:
+                                    episode_path = episode_file['path']
+                                    break
+
+    if not episode_path:
+        raise HTTPException(status_code=404, detail="Episode not found")
+    
+    # Start the download in an instance
+    response = await load_balancer.download_episode_to_best_instance(title=title, season=season, episode=episode)
+    if response:
+        return JSONResponse(content=response)
+
+@app.get("/api/filmid/{title}")
+async def get_film_id_by_title_api(title: str):
+    """Endpoint to get the film ID by providing the movie title."""
+    if not title:
+        raise HTTPException(status_code=400, detail="Title parameter is required")
+    film_id = await load_balancer.get_film_id(title)
+    return JSONResponse(content={"film_id": film_id})
+
+@app.get("/api/episodeid/{title}/{season}/{episode}")
+async def get_episode_id_api(title: str, season: str, episode: str):
+    """Endpoint to get the episode ID by providing the TV show title, season, and episode."""
+    if not title or not season or not episode:
+        raise HTTPException(status_code=400, detail="Title, season, and episode parameters are required")
+    episode_id = encode_episodeid(title, season, episode)
+    return JSONResponse(content={"episode_id": episode_id})
+
+@app.get("/api/cache/size")
+async def get_cache_size_api():
+    total_size = 0
+    for dirpath, dirnames, filenames in os.walk(CACHE_DIR):
+        for f in filenames:
+            fp = os.path.join(dirpath, f)
+            total_size += os.path.getsize(fp)
+    readable_size = bytes_to_human_readable(total_size)
+    return JSONResponse(content={"cache_size": readable_size})
+
+@app.post("/api/cache/clear")
+async def clear_cache_api():
+    for dirpath, dirnames, filenames in os.walk(CACHE_DIR):
+        for f in filenames:
+            fp = os.path.join(dirpath, f)
+            os.remove(fp)
+    return JSONResponse(content={"status": "Cache cleared"})
+
+@app.get("/api/tv/store")
+async def get_tv_store_api():
+    """Endpoint to get the TV store JSON."""
+    return JSONResponse(content=load_balancer.TV_STORE)
+
+
+@app.get("/api/film/store")
+async def get_film_store_api():
+    """Endpoint to get the film store JSON."""
+    return JSONResponse(content=load_balancer.FILM_STORE)
+
+@app.get("/api/film/metadata/{title}")
+async def get_film_metadata_api(title: str):
+    """Endpoint to get the film metadata by title."""
+    if not title:
+        raise HTTPException(status_code=400, detail="No title provided")
+    
+    json_cache_path = os.path.join(CACHE_DIR, f"{urllib.parse.quote(title)}.json")
+    
+    if os.path.exists(json_cache_path):
+        with open(json_cache_path, 'r') as f:
+            data = json.load(f)
+        return JSONResponse(content=data)
+    
+    raise HTTPException(status_code=404, detail="Metadata not found")
+
+@app.get("/api/tv/metadata/{title}")
+async def get_tv_metadata_api(title: str):
+    """Endpoint to get the TV show metadata by title."""
+    if not title:
+        raise HTTPException(status_code=400, detail="No title provided")
+    
+    json_cache_path = os.path.join(CACHE_DIR, f"{urllib.parse.quote(title)}.json")
+    
+    if os.path.exists(json_cache_path):
+        with open(json_cache_path, 'r') as f:
+            data = json.load(f)
+        
+        # Add the file structure to the metadata
+        tv_structure_data = await load_balancer.get_tv_structure(title)
+        if tv_structure_data:
+            data['file_structure'] = tv_structure_data
+        
+        return JSONResponse(content=data)
+    
+    raise HTTPException(status_code=404, detail="Metadata not found")
+
+@app.get("/api/film/all")
+async def get_all_films_api():
+    return JSONResponse(content=await load_balancer.get_all_films())
+
+@app.get("/api/tv/all")
+async def get_all_tvshows_api():
+    return JSONResponse(content=await load_balancer.get_all_tv_shows())
+
+@app.get("/api/instances")
+async def get_instances():
+    return JSONResponse(content=load_balancer.instances)
+
+@app.get("/api/instances/health")
+async def get_instances_health():
+    return JSONResponse(content=load_balancer.instances_health)
+
+# This API is only for instances
+@app.post("/api/register")
+async def register_instance(request: Request):
+    try:
+        data = await request.json()
+        if not data or "url" not in data:
+            raise HTTPException(status_code=400, detail="No URL provided")
+        
+        url = data["url"]
+        if not is_valid_url(url):
+            raise HTTPException(status_code=400, detail="Invalid URL")
+
+        # Register the instance
+        load_balancer.register_instance(url)
+        logging.info(f"Instance registered: {url}")
+
+        return JSONResponse(content={"message": f"Instance {url} registered successfully"}, status_code=200)
+
+    except Exception as e:
+        logging.error(f"Error registering instance: {e}")
+        raise HTTPException(status_code=500, detail="Failed to register instance")
+    
+# Routes
+@app.get("/")
+async def index():
+    return f"Load Balancer is Running {load_balancer.version}"

requirements.txt

@@ -1,5 +1,6 @@
-Flask
-Flask-Cors
+fastapi
+aiofiles
+uvicorn
 requests
 python-dotenv
 tqdm