major update not sure if works

app.py

@@ -17,6 +17,7 @@ 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")
 REPO = os.getenv("REPO")
 download_threads = {}
 
@@ -24,9 +25,10 @@ download_threads = {}
 if not os.path.exists(CACHE_DIR):
     os.makedirs(CACHE_DIR)
 
-if not os.path.exists(FILM_STORE_JSON_PATH):
-    with open(FILM_STORE_JSON_PATH, 'w') as json_file:
-        json.dump({}, json_file)
+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()
@@ -56,6 +58,15 @@ def find_movie_path(json_data, title):
                             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_film_id(title):
     """Generate a film ID based on the title."""
     return title.replace(" ", "_").lower()
@@ -138,11 +149,60 @@ def get_movie():
     
     return jsonify({"status": "Download started", "film_id": film_id})
 
-@app.route('/api/progress/<film_id>', methods=['GET'])
-def get_progress(film_id):
-    """Endpoint to get the download progress of a movie."""
-    progress = get_download_progress(film_id)
-    return jsonify({"film_id": film_id, "progress": progress})
+@app.route('/api/tv', methods=['GET'])
+def get_tv_show():
+    """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
+    episode_key = f"{title}_S{season}_E{episode}"
+    if episode_key in tv_store_data:
+        cache_path = tv_store_data[episode_key]
+        if os.path.exists(cache_path):
+            return send_from_directory(os.path.dirname(cache_path), os.path.basename(cache_path))
+    
+    tv_path = find_tv_path(file_structure, title)
+    
+    if not tv_path:
+        return jsonify({"error": "TV show not found"}), 404
+
+    episode_path = None
+    for season_dir in file_structure['contents']:
+        if season_dir['type'] == 'directory' and season_dir['path'].endswith(f'Season {season}'):
+            for episode_file in season_dir['contents']:
+                if episode_file['type'] == 'file' and episode_file['path'].endswith(f'Episode {episode}.mp4'):
+                    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 = get_system_proxies()
+    episode_id = f"{title}_S{season}_E{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_file, 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})
+
+@app.route('/api/progress/<id>', methods=['GET'])
+def get_progress(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/filmid', methods=['GET'])
 def get_film_id_by_title():
@@ -153,18 +213,52 @@ def get_film_id_by_title():
     film_id = get_film_id(title)
     return jsonify({"film_id": film_id})
 
-@app.route('/api/film_store', methods=['GET'])
-def get_film_store():
-    """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:
-            film_store_data = json.load(json_file)
-        return jsonify(film_store_data)
+@app.route('/api/episodeid', methods=['GET'])
+def get_episode_id():
+    """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 = f"{title}_S{season}_E{episode}"
+    return jsonify({"episode_id": episode_id})
+
+@app.route('/api/proxy', methods=['GET'])
+def get_proxy():
+    proxies = get_system_proxies()
+    return jsonify({"proxies": proxies})
+
+@app.route('/api/size', methods=['GET'])
+def get_cache_size():
+    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/clear_cache', methods=['POST'])
+def clear_cache():
+    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/store/tv', methods=['GET'])
+def get_tv_store():
+    """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
 
-@app.route('/api/metadata', methods=['GET'])
-def get_metadata():
-    """Endpoint to get the metadata by title."""
+@app.route('/api/film/metadata', methods=['GET'])
+def get_film_metadata():
+    """Endpoint to get the film metadata by title."""
     title = request.args.get('title')
     if not title:
         return jsonify({'error': 'No title provided'}), 400
@@ -178,45 +272,27 @@ def get_metadata():
     
     return jsonify({'error': 'Metadata not found'}), 404
 
-@app.route('/api/stats', methods=['GET'])
-def get_server_stats():
-    """Endpoint to get server statistics like RAM usage, CPU usage, and storage details."""
-    # RAM usage
-    ram = psutil.virtual_memory()
-    ram_total = bytes_to_human_readable(ram.total)
-    ram_available = bytes_to_human_readable(ram.available)
-    ram_used = bytes_to_human_readable(ram.used)
-    ram_percent = f"{ram.percent:.2f}%"
-    
-    # CPU usage
-    cpu_percent = f"{psutil.cpu_percent(interval=1):.2f}%"
-    
-    # Disk usage
-    disk = shutil.disk_usage("/")
-    disk_total = bytes_to_human_readable(disk.total)
-    disk_used = bytes_to_human_readable(disk.used)
-    disk_free = bytes_to_human_readable(disk.free)
-    disk_percent = f"{(disk.used / disk.total) * 100:.2f}%"
-
-    stats = {
-        "ram": {
-            "total": ram_total,
-            "available": ram_available,
-            "used": ram_used,
-            "percent": ram_percent
-        },
-        "cpu": {
-            "percent": cpu_percent
-        },
-        "disk": {
-            "total": disk_total,
-            "used": disk_used,
-            "free": disk_free,
-            "percent": disk_percent
-        }
-    }
-
-    return jsonify(stats)
+@app.route('/api/tv/metadata', methods=['GET'])
+def get_tv_metadata():
+    """Endpoint to get the TV show metadata by title."""
+    title = request.args.get('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_path = find_tv_path(file_structure, title)
+        if tv_path:
+            data['file_structure'] = tv_path
+        
+        return jsonify(data)
+    
+    return jsonify({'error': 'Metadata not found'}), 404
 
 # Routes
 @app.route('/')