music adaptation

Instance.py

@@ -8,28 +8,24 @@ from tqdm import tqdm
 import logging
 
 CACHE_DIR = os.getenv("CACHE_DIR")
-
 download_progress = {}
 
 class Instance:
-    def __init__(self, id, url, cache_dir, token, repo, load_balancer_api, max_retries=20, initial_delay=1):
-        self.version = "0.0.0.1 Alpha"
+    def __init__(self, id, url, cache_dir, token, repo, load_balancer_api, initial_delay=1):
+        self.version = "0.0.1 Alpha"
         self.id = id
         self.url = url
         self.CACHE_DIR = cache_dir
         self.TOKEN = token
         self.REPO = repo
-        self.FILM_STORE = {}
-        self.TV_STORE = {}
+        self.MUSIC_STORE = {}
         self.download_threads = {}
         self.file_structure = None
         self.load_balancer_api = load_balancer_api
-        self.max_retries = max_retries
         self.initial_delay = initial_delay
         self.last_report_time = time.time()
         self.re_register_event = Event()
 
-        # Ensure CACHE_DIR exists
         if not os.path.exists(self.CACHE_DIR):
             os.makedirs(self.CACHE_DIR)
 
@@ -39,31 +35,27 @@ class Instance:
         registration_thread.daemon = True
         registration_thread.start()
 
-        # Start the thread to re-index every 2 minutes
         indexer_thread = Thread(target=self.get_file_structure_periodically)
         indexer_thread.daemon = True
         indexer_thread.start()
 
     def reload_file_structure(self):
-        """Runs the indexer and loads the file structure from INDEX_FILE."""
         self.file_structure = self.load_balancer_api.get_file_structure()
         logging.info("File structure reloaded successfully.")
 
     def get_file_structure_periodically(self):
-        """Periodically reruns the indexer and reloads the file structure."""
         while True:
-            time.sleep(300)  # Wait for 5 minutes
+            time.sleep(300)  # Every 5 minutes
             logging.info("Re-running indexer and reloading file structure.")
             self.reload_file_structure()
 
     def compile_report(self):
-        self.last_report_time = time.time()  # Update the last report time
+        self.last_report_time = time.time()
         cache_size = self.get_cache_size()
         report = {
             "instance_id": self.id,
             "instance_url": self.url,
-            "film_store": self.FILM_STORE,
-            "tv_store": self.TV_STORE,
+            "music_store": self.MUSIC_STORE,
             "cache_size": cache_size
         }
         return report
@@ -77,11 +69,11 @@ class Instance:
 
     def monitor_registration(self):
         while True:
-            if time.time() - self.last_report_time > 60:  # Check if 1 minute has passed
+            if time.time() - self.last_report_time > 60:
                 logging.info('1 minute passed since last report. Re-registering...')
                 self.register_to_load_balancer()
-                self.last_report_time = time.time()  # Reset the last report time
-            time.sleep(30)  # Check every 30 seconds
+                self.last_report_time = time.time()
+            time.sleep(30)
 
     def get_cache_size(self):
         total_size = 0
@@ -98,19 +90,7 @@ class Instance:
                 return json.load(json_file)
         return {}
 
-    def download_film(self, file_url, token, cache_path, 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.
-            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.
-        """
+    def download_music(self, file_url, token, cache_path, music_id, title, chunk_size=100 * 1024 * 1024):
         print(f"Downloading file from URL: {file_url} to {cache_path}")
         headers = {'Authorization': f'Bearer {token}'}
         try:
@@ -118,39 +98,30 @@ class Instance:
             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()}
+            download_progress[music_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)
+                    download_progress[music_id]["downloaded"] += len(data)
             
             print(f'File cached to {cache_path} successfully.')
-            self.FILM_STORE[title] = cache_path
-            download_progress[film_id]["status"] = "Completed"
+            self.MUSIC_STORE[title] = cache_path
+            download_progress[music_id]["status"] = "Completed"
         except RequestException as e:
             print(f"Error downloading file: {e}")
-            download_progress[film_id]["status"] = "Failed"
+            download_progress[music_id]["status"] = "Failed"
         except IOError as e:
             print(f"Error writing file {cache_path}: {e}")
-            download_progress[film_id]["status"] = "Failed"
+            download_progress[music_id]["status"] = "Failed"
         finally:
-            if download_progress[film_id]["status"] != "Downloading":
-                download_progress[film_id]["end_time"] = time.time()
+            if download_progress[music_id]["status"] != "Downloading":
+                download_progress[music_id]["end_time"] = time.time()
 
     @staticmethod
     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"]
@@ -168,112 +139,21 @@ class Instance:
             return {"total": total, "downloaded": downloaded, "progress": progress, "status": status, "eta": eta}
         return {"total": 0, "downloaded": 0, "progress": 0, "status": "Not Found", "eta": None}
 
-
-
-    def download_episode(self, file_url, token, cache_path, 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.
-            episode_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}")
-        headers = {'Authorization': f'Bearer {token}'}
-        try:
-            response = requests.get(file_url, headers=headers, 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.')
-            self.update_tv_store(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(self, 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.
-        """
-
-        # 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 self.TV_STORE:
-            self.TV_STORE[title] = {}
-        
-        if season_part not in self.TV_STORE[title]:
-            self.TV_STORE[title][season_part] = {}
-
-        # Assuming episode_part is unique for each episode within a season
-        self.TV_STORE[title][season_part][episode_part] = cache_path
-
-        print(f'TV store updated with {title}, {season_part}, {episode_part}.')
-
-
     def load_json(self, file_path):
-        """Load JSON data from a file."""
         with open(file_path, 'r') as file:
             return json.load(file)
 
-    def find_movie_path(self, title):
-        """Find the path of the movie in the JSON data based on the title."""
+    def find_music_path(self, title):
         for directory in self.file_structure:
-            if directory['type'] == 'directory' and directory['path'] == 'films':
+            if directory['type'] == 'directory' and directory['path'] == 'music':
                 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."""
+    
+    def get_music_id(self, title):
         return title.replace(" ", "_").lower()
 
     def bytes_to_human_readable(self, num, suffix="B"):
@@ -283,9 +163,6 @@ class Instance:
             num /= 1024.0
         return f"{num:.1f} Y{suffix}"
 
-    def encode_episodeid(self, title, season, episode):
-        return f"{title}_{season}_{episode}"
-
     def register_to_load_balancer(self):
         retries = 0
         delay = self.initial_delay
@@ -304,4 +181,4 @@ class Instance:
             retries += 1
             logging.warning(f'Attempt {retries} to register instance {self.id} failed. Retrying in {delay} seconds...')
             time.sleep(delay)
-            delay = min(delay * 2, max_delay)  # Exponential backoff with maximum delay
+            delay = min(delay * 2, max_delay)

app.py

@@ -5,7 +5,6 @@ from threading import Thread
 from Instance import Instance
 from api import LoadBalancerAPI
 import os
-import re
 import aiofiles
 
 # Constants and Configuration
@@ -21,10 +20,16 @@ instance = Instance(id=ID, url=URL, cache_dir=CACHE_DIR, token=TOKEN, repo=REPO,
 
 app = FastAPI()
 
-async def serve_video(file_path: str, request: Request):
-    """Serve video file with support for range requests."""
+from fastapi import HTTPException, Request
+from fastapi.responses import Response, FileResponse
+import os
+import mimetypes
+import aiofiles
+
+async def serve_media(file_path: str, request: Request):
+    """Serve any media file with support for range requests."""
     if not os.path.isfile(file_path):
-        raise HTTPException(status_code=404, detail="Video file not found")
+        raise HTTPException(status_code=404, detail="Media file not found")
     
     file_size = os.path.getsize(file_path)
     range_header = request.headers.get('range', None)
@@ -34,8 +39,8 @@ async def serve_video(file_path: str, request: Request):
     if mime_type is None:
         mime_type = 'application/octet-stream'  # Fallback MIME type
 
+    # Handle range requests
     if range_header:
-        # Simple parsing for range values
         range_specifier = range_header.replace('bytes=', '').strip()
         start, end = (None, None)
 
@@ -44,7 +49,7 @@ async def serve_video(file_path: str, request: Request):
             start = int(start_str)
             end = int(end_str) if end_str else file_size - 1
 
-        # Validate range
+        # Validate the range
         if start is None or start >= file_size or (end is not None and end >= file_size) or (end is not None and start > end):
             raise HTTPException(status_code=416, detail="Requested range not satisfiable")
 
@@ -65,114 +70,60 @@ async def serve_video(file_path: str, request: Request):
                 read_size = min(chunk_size, remaining)
                 chunk = await f.read(read_size)
 
-                if not chunk:  # EOF
+                if not chunk:  # End of file
                     break
                 
                 data.extend(chunk)
                 start += read_size
 
-            return Response(content=bytes(data), status_code=206, headers=headers)  # Convert bytearray to bytes
+            return Response(content=bytes(data), status_code=206, headers=headers)
 
-    # Fallback for serving the whole file if no range requested
+    # Fallback for serving the entire file if no range requested
     return FileResponse(file_path, media_type=mime_type)
 
-
 @app.get("/")
 async def index():
     return instance.version
 
 @app.get("/api/get/report")
 async def get_report():
-    report=instance.compile_report()
+    report = instance.compile_report()
     return JSONResponse(report)
 
-@app.get('/api/get/tv/store')
-async def get_tv_store_api():
-    """Endpoint to get the TV store JSON."""
-    return JSONResponse(instance.TV_STORE)
-
-@app.get('/api/get/film/store')
-async def get_film_store_api():
-    """Endpoint to get the TV store JSON."""
-    return JSONResponse(instance.FILM_STORE)
+@app.get('/api/get/music/store')
+async def get_media_store_api():
+    """Endpoint to get the music store JSON."""
+    return JSONResponse(instance.MUSIC_STORE)
 
-@app.get("/api/get/film/{title}")
-async def get_movie_api(request: Request, title: str):
-    """Endpoint to get the movie by title with support for range requests."""
+@app.get("/api/get/music/{title}")
+async def get_media_api(request: Request, title: str):
+    """Endpoint to get the music file (audio or video) by title with support for range requests."""
     if not title:
         raise HTTPException(status_code=400, detail="Title parameter is required")
     
-    # Check if the film is already cached
-    if title in instance.FILM_STORE:
-        cache_path = instance.FILM_STORE[title]
+    if title in instance.MUSIC_STORE:
+        cache_path = instance.MUSIC_STORE[title]
         if os.path.exists(cache_path):
-            return await serve_video(cache_path, request)
-    
-    movie_path = instance.find_movie_path(title)
-    
-    if not movie_path:
-        raise HTTPException(status_code=404, detail="Movie not found")
-    
-    cache_path = os.path.join(CACHE_DIR, movie_path)
-    file_url = f"https://huggingface.co/{REPO}/resolve/main/{movie_path}"
-    film_id = instance.get_film_id(title)
-    
-    # Start the download in a separate thread if not already downloading
-    if film_id not in instance.download_threads or not instance.download_threads[film_id].is_alive():
-        thread = Thread(target=instance.download_film, args=(file_url, TOKEN, cache_path, film_id, title))
-        instance.download_threads[film_id] = thread
-        thread.start()
+            return await serve_media(cache_path, request)
     
-    return JSONResponse({"status": "Download started", "film_id": film_id})
-
-@app.get("/api/get/tv/{title}/{season}/{episode}")
-async def get_tv_show_api(request: Request, 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 instance.TV_STORE and season in instance.TV_STORE[title]:
-        for ep in instance.TV_STORE[title][season]:
-            if episode in ep:
-                cache_path = instance.TV_STORE[title][season][ep]
-                if os.path.exists(cache_path):
-                    return await serve_video(cache_path, request)
-
-    tv_path = instance.find_tv_path(title)
+    media_path = instance.find_music_path(title)
     
-    if not tv_path:
-        raise HTTPException(status_code=404, detail="TV show not found")
-
-    episode_path = None
-    for directory in instance.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")
+    if not media_path:
+        raise HTTPException(status_code=404, detail="Media not found")
     
-    cache_path = os.path.join(CACHE_DIR, episode_path)
-    file_url = f"https://huggingface.co/{REPO}/resolve/main/{episode_path}"
-    episode_id = instance.encode_episodeid(title, season, episode)
+    cache_path = os.path.join(CACHE_DIR, media_path)
+    file_url = f"https://huggingface.co/{REPO}/resolve/main/{media_path}"
+    media_id = instance.get_music_id(title)
     
-    # Start the download in a separate thread if not already downloading
-    if episode_id not in instance.download_threads or not instance.download_threads[episode_id].is_alive():
-        thread = Thread(target=instance.download_episode, args=(file_url, TOKEN, cache_path, episode_id, title))
-        instance.download_threads[episode_id] = thread
+    if media_id not in instance.download_threads or not instance.download_threads[media_id].is_alive():
+        thread = Thread(target=instance.download_music, args=(file_url, TOKEN, cache_path, media_id, title))
+        instance.download_threads[media_id] = thread
         thread.start()
     
-    return JSONResponse({"status": "Download started", "episode_id": episode_id})
+    return JSONResponse({"status": "Download started", "music_id": media_id})
 
 @app.get("/api/get/progress/{id}")
 async def get_progress_api(id: str):
-    """Endpoint to get the download progress of a movie or TV show episode."""
+    """Endpoint to get the download progress of a media file."""
     progress = instance.get_download_progress(id)
     return JSONResponse({"id": id, "progress": progress})

old.app.py

@@ -1,174 +0,0 @@
-from flask import Flask, jsonify, request, send_from_directory
-from flask_cors import CORS
-import os
-import json
-from threading import Thread
-import urllib.parse
-from Instance import Instance
-from api import LoadBalancerAPI
-
-app = Flask(__name__)
-CORS(app)
-
-# Constants and Configuration
-CACHE_DIR = os.getenv("CACHE_DIR")
-INDEX_FILE = os.getenv("INDEX_FILE")
-TOKEN = os.getenv("TOKEN")
-REPO = os.getenv("REPO")
-ID = os.getenv("ID")
-URL = os.getenv("URL")
-LOAD_BALANCER_URL = os.getenv("LOAD_BALANCER_URL")
-
-load_balancer_api = LoadBalancerAPI(base_url=LOAD_BALANCER_URL)
-instance = Instance(id=ID, url=URL, cache_dir=CACHE_DIR, index_file=INDEX_FILE, token=TOKEN, repo=REPO, load_balancer_api=load_balancer_api)
-
-# 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
-    
-    # Load the film store JSON
-    with open(instance.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 = instance.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 = instance.get_system_proxies()
-    film_id = instance.get_film_id(title)
-    
-    # Start the download in a separate thread if not already downloading
-    if film_id not in instance.download_threads or not instance.download_threads[film_id].is_alive():
-        thread = Thread(target=instance.download_film, args=(file_url, TOKEN, cache_path, proxies, film_id, title))
-        instance.download_threads[film_id] = thread
-        thread.start()
-    
-    return jsonify({"status": "Download started", "film_id": film_id})
-
-@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
-
-    # Load the TV store JSON
-    with open(instance.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 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))
-
-    tv_path = instance.find_tv_path(title)
-    
-    if not tv_path:
-        return jsonify({"error": "TV show not found"}), 404
-
-    episode_path = None
-    for directory in instance.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
-    
-    cache_path = os.path.join(CACHE_DIR, episode_path)
-    file_url = f"https://huggingface.co/{REPO}/resolve/main/{episode_path}"
-    proxies = instance.get_system_proxies()
-    episode_id = instance.encode_episodeid(title, season, episode)
-    
-    # Start the download in a separate thread if not already downloading
-    if episode_id not in instance.download_threads or not instance.download_threads[episode_id].is_alive():
-        thread = Thread(target=instance.download_episode, args=(file_url, TOKEN, cache_path, proxies, episode_id, title))
-        instance.download_threads[episode_id] = thread
-        thread.start()
-    
-    return jsonify({"status": "Download started", "episode_id": episode_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 = instance.get_download_progress(id)
-    return jsonify({"id": id, "progress": progress})
-
-@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 = instance.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."""
-    if os.path.exists(instance.TV_STORE_JSON_PATH):
-        with open(instance.TV_STORE_JSON_PATH, 'r') as json_file:
-            tv_store_data = json.load(json_file)
-        return jsonify(tv_store_data)
-    return jsonify({}), 404
-
-@app.route('/api/film/store', methods=['GET'])
-def get_film_store_api():
-    """Endpoint to get the film store JSON."""
-    if os.path.exists(instance.FILM_STORE_JSON_PATH):
-        with open(instance.FILM_STORE_JSON_PATH, 'r') as json_file:
-            tv_store_data = json.load(json_file)
-        return jsonify(tv_store_data)
-    return jsonify({}), 404
-
-@app.route("/api/film/all")
-def get_all_films_api():
-    return instance.get_all_films()
-
-@app.route("/api/tv/all")
-def get_all_tvshows_api():
-    return instance.get_all_tv_shows()
-
-@app.route("/api/get/report",methods=["GET"])
-def get_report():
-    report=instance.compile_report()
-    return jsonify(report)
-
-# Routes
-@app.route('/')
-def index():
-    return jsonify(instance.version)
-
-# Main entry point
-if __name__ == "__main__":
-    app.run(debug=True, host="0.0.0.0", port=7860)