major update v0.2

Instance.py

@@ -0,0 +1,376 @@
+import os
+import requests
+import json
+import urllib.request
+import time
+from threading import Thread
+from requests.exceptions import RequestException
+from tqdm import tqdm
+from indexer import indexer
+import re
+
+CACHE_DIR = os.getenv("CACHE_DIR")
+
+download_progress = {}
+
+class Instance:
+    def __init__(self, id, url, cache_dir, index_file, token, repo):
+        self.id = id
+        self.url = url
+        self.CACHE_DIR = cache_dir
+        self.INDEX_FILE = index_file
+        self.TOKEN = token
+        self.REPO = repo
+        self.FILM_STORE_JSON_PATH = os.path.join(cache_dir, "film_store.json")
+        self.TV_STORE_JSON_PATH = os.path.join(cache_dir, "tv_store.json")
+        self.download_threads = {}
+        self.file_structure = None
+
+        # Ensure CACHE_DIR exists
+        if not os.path.exists(self.CACHE_DIR):
+            os.makedirs(self.CACHE_DIR)
+
+        for path in [self.FILM_STORE_JSON_PATH, self.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()
+
+        # Load the file structure JSON
+        if not os.path.exists(self.INDEX_FILE):
+            raise FileNotFoundError(f"{self.INDEX_FILE} not found. Please make sure the file exists.")
+
+        with open(self.INDEX_FILE, 'r') as f:
+            self.file_structure = json.load(f)
+
+        # Start prefetching metadata
+        thread = Thread(target=self.start_prefetching)
+        thread.daemon = True
+        thread.start()
+
+    def compile_report(self):
+        film_store_path = os.path.join(CACHE_DIR, "film_store.json")
+        tv_store_path = os.path.join(CACHE_DIR, "tv_store.json")
+        cache_size = self.get_cache_size()
+
+        report = {
+            "id": self.id,
+            "film_store": self.read_json(film_store_path),
+            "tv_store": self.read_json(tv_store_path),
+            "cache_size": cache_size
+        }
+        return report
+
+    def get_cache_size(self):
+        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)
+        return {"cache_size": f"{total_size / (1024 * 1024 * 1024):.2f} GB"}
+
+    @staticmethod
+    def read_json(file_path):
+        if os.path.exists(file_path):
+            with open(file_path, 'r') as json_file:
+                return json.load(json_file)
+        return {}
+
+    @staticmethod
+    def get_system_proxies():
+        """
+        Retrieves the system's HTTP and HTTPS proxies.
+
+        Returns:
+            dict: A dictionary containing the proxies.
+        """
+        try:
+            proxies = urllib.request.getproxies()
+            print("System proxies:", proxies)
+            return {
+                "http": proxies.get("http"),
+                "https": proxies.get("http")
+            }
+        except Exception as e:
+            print(f"Error getting system proxies: {e}")
+            return {}
+
+    @staticmethod
+    def download_film(file_url, token, cache_path, proxies, 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.
+            proxies (dict): Proxies for the request.
+            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.
+        """
+        print(f"Downloading file from URL: {file_url} to {cache_path} with proxies: {proxies}")
+        headers = {'Authorization': f'Bearer {token}'}
+        try:
+            response = requests.get(file_url, headers=headers, proxies=proxies, stream=True)
+            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()}
+
+            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)
+            
+            print(f'File cached to {cache_path} successfully.')
+            Instance.update_film_store_json(title, cache_path)
+            download_progress[film_id]["status"] = "Completed"
+        except RequestException as e:
+            print(f"Error downloading file: {e}")
+            download_progress[film_id]["status"] = "Failed"
+        except IOError as e:
+            print(f"Error writing file {cache_path}: {e}")
+            download_progress[film_id]["status"] = "Failed"
+        finally:
+            if download_progress[film_id]["status"] != "Downloading":
+                download_progress[film_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"]
+            status = download_progress[id].get("status", "In Progress")
+            progress = (downloaded / total) * 100 if total > 0 else 0
+
+            eta = None
+            if status == "Downloading" and downloaded > 0:
+                elapsed_time = time.time() - download_progress[id]["start_time"]
+                estimated_total_time = elapsed_time * (total / downloaded)
+                eta = estimated_total_time - elapsed_time
+            elif status == "Completed":
+                eta = 0
+
+            return {"total": total, "downloaded": downloaded, "progress": progress, "status": status, "eta": eta}
+        return {"total": 0, "downloaded": 0, "progress": 0, "status": "Not Found", "eta": None}
+
+    @staticmethod
+    def update_film_store_json(title, cache_path):
+        """
+        Updates the film store JSON with the new file.
+
+        Args:
+            title (str): The title of the film.
+            cache_path (str): The local path where the file is saved.
+        """
+        FILM_STORE_JSON_PATH = os.path.join(CACHE_DIR, "film_store.json")
+
+        film_store_data = {}
+        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)
+
+        film_store_data[title] = cache_path
+
+        with open(FILM_STORE_JSON_PATH, 'w') as json_file:
+            json.dump(film_store_data, json_file, indent=2)
+        print(f'Film store updated with {title}.')
+
+    @staticmethod
+    def download_episode(file_url, token, cache_path, proxies, 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.
+            proxies (dict): Proxies for the request.
+            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} with proxies: {proxies}")
+        headers = {'Authorization': f'Bearer {token}'}
+        try:
+            response = requests.get(file_url, headers=headers, proxies=proxies, 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.')
+            Instance.update_tv_store_json(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()
+
+    @staticmethod
+    def update_tv_store_json(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.
+        """
+        TV_STORE_JSON_PATH = os.path.join(CACHE_DIR, "tv_store.json")
+
+        tv_store_data = {}
+        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)
+
+        # 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-1080p.mkv'
+
+        # Organize the data by title, season, and episode
+        if title not in tv_store_data:
+            tv_store_data[title] = {}
+        if season_part not in tv_store_data[title]:
+            tv_store_data[title][season_part] = []
+        tv_store_data[title][season_part].append(episode_part)
+
+        with open(TV_STORE_JSON_PATH, 'w') as json_file:
+            json.dump(tv_store_data, json_file, indent=2)
+        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."""
+        for directory in self.file_structure:
+            if directory['type'] == 'directory' and directory['path'] == 'films':
+                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."""
+        return title.replace(" ", "_").lower()
+
+    def prefetch_metadata(self):
+        """Prefetch metadata for all items in the file structure."""
+        for item in self.file_structure:
+            if 'contents' in item:
+                for sub_item in item['contents']:
+                    original_title = sub_item['path'].split('/')[-1]
+                    media_type = 'series' if item['path'].startswith('tv') else 'movie'
+                    title = original_title
+                    year = None
+
+                    # Extract year from the title if available
+                    match = re.search(r'\((\d{4})\)', original_title)
+                    if match:
+                        year_str = match.group(1)
+                        if year_str.isdigit() and len(year_str) == 4:
+                            title = original_title[:match.start()].strip()
+                            year = int(year_str)
+                    else:
+                        parts = original_title.rsplit(' ', 1)
+                        if len(parts) > 1 and parts[-1].isdigit() and len(parts[-1]) == 4:
+                            title = parts[0].strip()
+                            year = int(parts[-1])
+
+                    self.fetch_and_cache_json(original_title, title, media_type, year)
+
+    def bytes_to_human_readable(self, num, suffix="B"):
+        for unit in ["", "K", "M", "G", "T", "P", "E", "Z"]:
+            if abs(num) < 1024.0:
+                return f"{num:3.1f} {unit}{suffix}"
+            num /= 1024.0
+        return f"{num:.1f} Y{suffix}"
+
+    def encode_episodeid(self, title, season, episode):
+        return f"{title}_{season}_{episode}"
+
+    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:
+            if directory['type'] == 'directory' and directory['path'] == 'tv':
+                for sub_directory in directory['contents']:
+                    if sub_directory['type'] == 'directory':
+                        show_title = sub_directory['path'].split('/')[-1]
+                        tv_shows[show_title] = []
+                        for season_directory in sub_directory['contents']:
+                            if season_directory['type'] == 'directory':
+                                season = season_directory['path'].split('/')[-1]
+                                for episode in season_directory['contents']:
+                                    if episode['type'] == 'file':
+                                        tv_shows[show_title].append({
+                                            "season": season,
+                                            "episode": episode['path'].split('/')[-1],
+                                            "path": episode['path']
+                                        })
+        return tv_shows
+
+    def get_all_films(self):
+        """Get all films from the indexed cache structure JSON file."""
+        films = []
+        for directory in self.file_structure:
+            if directory['type'] == 'directory' and directory['path'] == 'films':
+                for sub_directory in directory['contents']:
+                    if sub_directory['type'] == 'directory':
+                        films.append(sub_directory['path'])
+        return films
+
+    def start_prefetching(self):
+        """Start the metadata prefetching in a separate thread."""
+        self.prefetch_metadata()

TODO.md

@@ -0,0 +1,5 @@
+## TODO
+* Create Instance class
+* add a method to register the instance to Load Balancer on ```[POST]<load_balancer_url>/api/register``` route
+* add `[GET] /api/get/report` route to return a report consist of film_store.json, tv_store.json, cache_size
+* add two api routes to delete a certain film or episode

app.backup.py

@@ -0,0 +1,368 @@
+from flask import Flask, jsonify, request, send_from_directory
+from flask_cors import CORS
+import os
+import json
+import threading
+import urllib.parse
+from hf_scrapper import download_film, download_episode, get_system_proxies, get_download_progress
+from indexer import indexer
+from tvdb import fetch_and_cache_json
+import re
+
+app = Flask(__name__)
+CORS(app)
+
+# Constants and Configuration
+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 = {}
+
+# Ensure CACHE_DIR exists
+if not os.path.exists(CACHE_DIR):
+    os.makedirs(CACHE_DIR)
+
+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()
+
+# Load the file structure JSON
+if not os.path.exists(INDEX_FILE):
+    raise FileNotFoundError(f"{INDEX_FILE} not found. Please make sure the file exists.")
+
+with open(INDEX_FILE, 'r') as f:
+    file_structure = json.load(f)
+
+# Function Definitions
+
+def load_json(file_path):
+    """Load JSON data from a file."""
+    with open(file_path, 'r') as file:
+        return json.load(file)
+
+def find_movie_path(json_data, title):
+    """Find the path of the movie in the JSON data based on the title."""
+    for directory in json_data:
+        if directory['type'] == 'directory' and directory['path'] == 'films':
+            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(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_tv_structure(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
+    return None
+
+def get_film_id(title):
+    """Generate a film ID based on the title."""
+    return title.replace(" ", "_").lower()
+
+def prefetch_metadata():
+    """Prefetch metadata for all items in the file structure."""
+    for item in file_structure:
+        if 'contents' in item:
+            for sub_item in item['contents']:
+                original_title = sub_item['path'].split('/')[-1]
+                media_type = 'series' if item['path'].startswith('tv') else 'movie'
+                title = original_title
+                year = None
+                
+                # Extract year from the title if available
+                match = re.search(r'\((\d{4})\)', original_title)
+                if match:
+                    year_str = match.group(1)
+                    if year_str.isdigit() and len(year_str) == 4:
+                        title = original_title[:match.start()].strip()
+                        year = int(year_str)
+                else:
+                    parts = original_title.rsplit(' ', 1)
+                    if len(parts) > 1 and parts[-1].isdigit() and len(parts[-1]) == 4:
+                        title = parts[0].strip()
+                        year = int(parts[-1])
+                
+                fetch_and_cache_json(original_title, title, media_type, year)
+
+def bytes_to_human_readable(num, suffix="B"):
+    for unit in ["", "K", "M", "G", "T", "P", "E", "Z"]:
+        if abs(num) < 1024.0:
+            return f"{num:3.1f} {unit}{suffix}"
+        num /= 1024.0
+    return f"{num:.1f} Y{suffix}"
+
+def encode_episodeid(title,season,episode):
+    return f"{title}_{season}_{episode}"
+
+def get_all_tv_shows(indexed_cache):
+    """Get all TV shows from the indexed cache structure JSON file."""
+    tv_shows = {}
+    for directory in indexed_cache:
+        if directory['type'] == 'directory' and directory['path'] == 'tv':
+            for sub_directory in directory['contents']:
+                if sub_directory['type'] == 'directory':
+                    show_title = sub_directory['path'].split('/')[-1]
+                    tv_shows[show_title] = []
+                    for season_directory in sub_directory['contents']:
+                        if season_directory['type'] == 'directory':
+                            season = season_directory['path'].split('/')[-1]
+                            for episode in season_directory['contents']:
+                                if episode['type'] == 'file':
+                                    tv_shows[show_title].append({
+                                        "season": season,
+                                        "episode": episode['path'].split('/')[-1],
+                                        "path": episode['path']
+                                    })
+    return tv_shows
+
+def get_all_films(indexed_cache):
+    """Get all films from the indexed cache structure JSON file."""
+    films = []
+    for directory in indexed_cache:
+        if directory['type'] == 'directory' and directory['path'] == 'films':
+            for sub_directory in directory['contents']:
+                if sub_directory['type'] == 'directory':
+                    films.append(sub_directory['path'])
+    return films
+
+def start_prefetching():
+    """Start the metadata prefetching in a separate thread."""
+    prefetch_metadata()
+
+# Start prefetching metadata
+thread = threading.Thread(target=start_prefetching)
+thread.daemon = True
+thread.start()
+
+# API Endpoints
+
+@app.route('/api/film', methods=['GET'])
+def get_movie_api():
+    """Endpoint to get the movie by title."""
+    title = request.args.get('title')
+    if not title:
+        return jsonify({"error": "Title parameter is required"}), 400
+    
+    # Load the film store JSON
+    with open(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 = find_movie_path(file_structure, 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 = get_system_proxies()
+    film_id = get_film_id(title)
+    
+    # Start the download in a separate thread if not already downloading
+    if film_id not in download_threads or not download_threads[film_id].is_alive():
+        thread = threading.Thread(target=download_film, args=(file_url, TOKEN, cache_path, proxies, film_id, title))
+        download_threads[film_id] = thread
+        thread.start()
+    
+    return jsonify({"status": "Download started", "film_id": film_id})
+
+@app.route('/api/tv', methods=['GET'])
+def get_tv_show_api():
+    """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
+    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]
+                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 directory in 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 = get_system_proxies()
+    episode_id = encode_episodeid(title,season,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_episode, 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_api(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_api():
+    """Endpoint to get the film ID by providing the movie title."""
+    title = request.args.get('title')
+    if not title:
+        return jsonify({"error": "Title parameter is required"}), 400
+    film_id = get_film_id(title)
+    return jsonify({"film_id": film_id})
+
+@app.route('/api/episodeid', methods=['GET'])
+def get_episode_id_api():
+    """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 = 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."""
+    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/film/store', methods=['GET'])
+def get_film_store_api():
+    """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:
+            tv_store_data = json.load(json_file)
+        return jsonify(tv_store_data)
+    return jsonify({}), 404
+
+@app.route('/api/film/metadata', methods=['GET'])
+def get_film_metadata_api():
+    """Endpoint to get the film 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)
+        return jsonify(data)
+    
+    return jsonify({'error': 'Metadata not found'}), 404
+
+@app.route('/api/tv/metadata', methods=['GET'])
+def get_tv_metadata_api():
+    """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_structure_data = get_tv_structure(file_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 get_all_films(file_structure)
+
+@app.route("/api/tv/all")
+def get_all_tvshows_api():
+    return get_all_tv_shows(file_structure)
+
+
+# Routes
+@app.route('/')
+def index():
+    return "Server Running ..."
+
+# Main entry point
+if __name__ == "__main__":
+    app.run(debug=True, host="0.0.0.0", port=7860)

app.py

@@ -4,10 +4,7 @@ import os
 import json
 import threading
 import urllib.parse
-from hf_scrapper import download_film, download_episode, get_system_proxies, get_download_progress
-from indexer import indexer
-from tvdb import fetch_and_cache_json
-import re
+from Instance import Instance
 
 app = Flask(__name__)
 CORS(app)
@@ -16,144 +13,11 @@ CORS(app)
 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 = {}
+ID = os.getenv("ID")
+URL = os.getenv("URL")
 
-# Ensure CACHE_DIR exists
-if not os.path.exists(CACHE_DIR):
-    os.makedirs(CACHE_DIR)
-
-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()
-
-# Load the file structure JSON
-if not os.path.exists(INDEX_FILE):
-    raise FileNotFoundError(f"{INDEX_FILE} not found. Please make sure the file exists.")
-
-with open(INDEX_FILE, 'r') as f:
-    file_structure = json.load(f)
-
-# Function Definitions
-
-def load_json(file_path):
-    """Load JSON data from a file."""
-    with open(file_path, 'r') as file:
-        return json.load(file)
-
-def find_movie_path(json_data, title):
-    """Find the path of the movie in the JSON data based on the title."""
-    for directory in json_data:
-        if directory['type'] == 'directory' and directory['path'] == 'films':
-            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(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_tv_structure(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
-    return None
-
-def get_film_id(title):
-    """Generate a film ID based on the title."""
-    return title.replace(" ", "_").lower()
-
-def prefetch_metadata():
-    """Prefetch metadata for all items in the file structure."""
-    for item in file_structure:
-        if 'contents' in item:
-            for sub_item in item['contents']:
-                original_title = sub_item['path'].split('/')[-1]
-                media_type = 'series' if item['path'].startswith('tv') else 'movie'
-                title = original_title
-                year = None
-                
-                # Extract year from the title if available
-                match = re.search(r'\((\d{4})\)', original_title)
-                if match:
-                    year_str = match.group(1)
-                    if year_str.isdigit() and len(year_str) == 4:
-                        title = original_title[:match.start()].strip()
-                        year = int(year_str)
-                else:
-                    parts = original_title.rsplit(' ', 1)
-                    if len(parts) > 1 and parts[-1].isdigit() and len(parts[-1]) == 4:
-                        title = parts[0].strip()
-                        year = int(parts[-1])
-                
-                fetch_and_cache_json(original_title, title, media_type, year)
-
-def bytes_to_human_readable(num, suffix="B"):
-    for unit in ["", "K", "M", "G", "T", "P", "E", "Z"]:
-        if abs(num) < 1024.0:
-            return f"{num:3.1f} {unit}{suffix}"
-        num /= 1024.0
-    return f"{num:.1f} Y{suffix}"
-
-def encode_episodeid(title,season,episode):
-    return f"{title}_{season}_{episode}"
-
-def get_all_tv_shows(indexed_cache):
-    """Get all TV shows from the indexed cache structure JSON file."""
-    tv_shows = {}
-    for directory in indexed_cache:
-        if directory['type'] == 'directory' and directory['path'] == 'tv':
-            for sub_directory in directory['contents']:
-                if sub_directory['type'] == 'directory':
-                    show_title = sub_directory['path'].split('/')[-1]
-                    tv_shows[show_title] = []
-                    for season_directory in sub_directory['contents']:
-                        if season_directory['type'] == 'directory':
-                            season = season_directory['path'].split('/')[-1]
-                            for episode in season_directory['contents']:
-                                if episode['type'] == 'file':
-                                    tv_shows[show_title].append({
-                                        "season": season,
-                                        "episode": episode['path'].split('/')[-1],
-                                        "path": episode['path']
-                                    })
-    return tv_shows
-
-def get_all_films(indexed_cache):
-    """Get all films from the indexed cache structure JSON file."""
-    films = []
-    for directory in indexed_cache:
-        if directory['type'] == 'directory' and directory['path'] == 'films':
-            for sub_directory in directory['contents']:
-                if sub_directory['type'] == 'directory':
-                    films.append(sub_directory['path'])
-    return films
-
-def start_prefetching():
-    """Start the metadata prefetching in a separate thread."""
-    prefetch_metadata()
-
-# Start prefetching metadata
-thread = threading.Thread(target=start_prefetching)
-thread.daemon = True
-thread.start()
+instance = Instance(id=ID, url=URL, cache_dir=CACHE_DIR, index_file=INDEX_FILE, token=TOKEN, repo=REPO)
 
 # API Endpoints
 
@@ -165,7 +29,7 @@ def get_movie_api():
         return jsonify({"error": "Title parameter is required"}), 400
     
     # Load the film store JSON
-    with open(FILM_STORE_JSON_PATH, 'r') as json_file:
+    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
@@ -174,20 +38,20 @@ def get_movie_api():
         if os.path.exists(cache_path):
             return send_from_directory(os.path.dirname(cache_path), os.path.basename(cache_path))
     
-    movie_path = find_movie_path(file_structure, title)
+    movie_path = instance.find_movie_path(instance.file_structure, 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 = get_system_proxies()
-    film_id = get_film_id(title)
+    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 download_threads or not download_threads[film_id].is_alive():
-        thread = threading.Thread(target=download_film, args=(file_url, TOKEN, cache_path, proxies, film_id, title))
-        download_threads[film_id] = thread
+    if film_id not in instance.download_threads or not instance.download_threads[film_id].is_alive():
+        thread = threading.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})
@@ -203,7 +67,7 @@ def get_tv_show_api():
         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:
+    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
@@ -214,13 +78,13 @@ def get_tv_show_api():
                 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)
+    tv_path = instance.find_tv_path(instance.file_structure, title)
     
     if not tv_path:
         return jsonify({"error": "TV show not found"}), 404
 
     episode_path = None
-    for directory in file_structure:
+    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():
@@ -236,13 +100,13 @@ def get_tv_show_api():
     
     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 = encode_episodeid(title,season,episode)
+    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 download_threads or not download_threads[episode_id].is_alive():
-        thread = threading.Thread(target=download_episode, args=(file_url, TOKEN, cache_path, proxies, episode_id, title))
-        download_threads[episode_id] = thread
+    if episode_id not in instance.download_threads or not instance.download_threads[episode_id].is_alive():
+        thread = threading.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})
@@ -251,7 +115,7 @@ def get_tv_show_api():
 @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 = get_download_progress(id)
+    progress = instance.get_download_progress(id)
     return jsonify({"id": id, "progress": progress})
 
 @app.route('/api/filmid', methods=['GET'])
@@ -260,7 +124,7 @@ def get_film_id_by_title_api():
     title = request.args.get('title')
     if not title:
         return jsonify({"error": "Title parameter is required"}), 400
-    film_id = get_film_id(title)
+    film_id = instance.get_film_id(title)
     return jsonify({"film_id": film_id})
 
 @app.route('/api/episodeid', methods=['GET'])
@@ -271,7 +135,7 @@ def get_episode_id_api():
     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 = encode_episodeid(title,season,episode)
+    episode_id = instance.encode_episodeid(title,season,episode)
     return jsonify({"episode_id": episode_id})
 
 @app.route('/api/cache/size', methods=['GET'])
@@ -281,7 +145,7 @@ def get_cache_size_api():
         for f in filenames:
             fp = os.path.join(dirpath, f)
             total_size += os.path.getsize(fp)
-    readable_size = bytes_to_human_readable(total_size)
+    readable_size = instance.bytes_to_human_readable(total_size)
     return jsonify({"cache_size": readable_size})
 
 @app.route('/api/cache/clear', methods=['POST'])
@@ -295,17 +159,17 @@ def clear_cache_api():
 @app.route('/api/tv/store', methods=['GET'])
 def get_tv_store_api():
     """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:
+    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 TV store JSON."""
-    if os.path.exists(FILM_STORE_JSON_PATH):
-        with open(FILM_STORE_JSON_PATH, 'r') as json_file:
+    """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
@@ -340,7 +204,7 @@ def get_tv_metadata_api():
             data = json.load(f)
         
         # Add the file structure to the metadata
-        tv_structure_data = get_tv_structure(file_structure, title)
+        tv_structure_data = instance.get_tv_structure(instance.file_structure, title)
         if tv_structure_data:
             data['file_structure'] = tv_structure_data
         
@@ -351,17 +215,17 @@ def get_tv_metadata_api():
 
 @app.route("/api/film/all")
 def get_all_films_api():
-    return get_all_films(file_structure)
+    return instance.get_all_films(instance.file_structure)
 
 @app.route("/api/tv/all")
 def get_all_tvshows_api():
-    return get_all_tv_shows(file_structure)
+    return instance.get_all_tv_shows(instance.file_structure)
 
 
 # Routes
 @app.route('/')
 def index():
-    return "Server Running"
+    return "Server Running ..."
 
 # Main entry point
 if __name__ == "__main__":