0.0.2 V Beta

Dockerfile

@@ -1,38 +0,0 @@
-# Base image
-FROM python:3.9
-
-# Install additional packages and setup
-RUN apt-get update && apt-get install -y \
-    fakeroot \
-    git \
-    git-lfs \
-    ffmpeg \
-    libsm6 \
-    libxext6 \
-    cmake \
-    rsync \
-    libgl1-mesa-glx \
-    && rm -rf /var/lib/apt/lists/* \
-    && mv /usr/bin/apt-get /usr/bin/.apt-get \
-    && echo '#!/usr/bin/env sh\nfakeroot /usr/bin/.apt-get $@' > /usr/bin/apt-get \
-    && chmod +x /usr/bin/apt-get \
-    && useradd -m -u 1000 user \
-    && git lfs install
-
-# Set the working directory
-WORKDIR /home/user/app
-
-# Copy requirements file and install dependencies
-COPY requirements.txt /tmp/requirements.txt
-RUN pip install --no-cache-dir -r /tmp/requirements.txt
-
-# Copy the application code
-COPY --chown=1000:1000 ./ /home/user/app
-
-USER user
-
-# Expose the port the app runs on
-EXPOSE 7860
-
-# Set the entry point to run the Flask application
-ENTRYPOINT ["python", "app.py"]

LoadBalancer.py

@@ -1,17 +1,62 @@
+import os
+import requests
+import json
+import urllib.request
+from tqdm import tqdm
+from indexer import indexer
+import re
+from tvdb import fetch_and_cache_json
+from threading import Event
 import time
 import logging
 from threading import Thread, Event, Timer
 from api import InstancesAPI
 
+
+CACHE_DIR = os.getenv("CACHE_DIR")
+
+download_progress = {}
+
 class LoadBalancer:
-    def __init__(self, polling_interval=10, max_retries=3, initial_delay=1):
-        self.version = "0.0.1 V Beta"
+    def __init__(self, cache_dir, index_file, token, repo, polling_interval=10, max_retries=3, initial_delay=1):
+        self.version = "0.0.2 V Beta"
         self.instances = []
         self.polling_interval = polling_interval
         self.max_retries = max_retries
         self.initial_delay = initial_delay
         self.stop_event = Event()
         self.instances_api = InstancesAPI(self.instances)
+        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.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)
+
+        prefetch_thread = Thread(target=self.start_prefetching)
+        prefetch_thread.daemon = True
+        prefetch_thread.start()
+
 
     def register_instance(self, instance_url):
         if instance_url not in self.instances:
@@ -57,17 +102,225 @@ class LoadBalancer:
         logging.info("Stopping polling.")
         self.stop_event.set()
 
-if __name__ == "__main__":
-    logging.basicConfig(level=logging.INFO)
+######################################################################
+
+    @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(title):
+        """
+        Downloads a film to a specific instance
+
+        Args:
+            title (str): The title of the film.
+        """
+        pass
+
+    @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(title, season, episode):
+        """
+        Downloads a episode to a specific instance
+        """
+
+    @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-720p.mp4'
+
+        # Create the structure if not already present
+        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] = {}
+
+        # Assuming episode_part is unique for each episode within a season
+        tv_store_data[title][season_part][episode_part] = cache_path
+
+        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}.')
+
+    @staticmethod
+    def is_valid_url(url):
+        # Simple URL validation (could be more complex if needed)
+        regex = re.compile(
+            r'^(?:http|ftp)s?://' # http:// or https://
+            r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|' # domain...
+            r'localhost|' # localhost...
+            r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|' # ...or ipv4
+            r'\[?[A-F0-9]*:[A-F0-9:]+\]?)' # ...or ipv6
+            r'(?::\d+)?' # optional port
+            r'(?:/?|[/?]\S+)$', re.IGNORECASE)
+        return re.match(regex, url) is not None
+
+
+    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])
+
+                    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}"
 
-    load_balancer = LoadBalancer()
+    def encode_episodeid(self, title, season, episode):
+        return f"{title}_{season}_{episode}"
 
-    # Example registration (in real use, handle this via an API endpoint)
-    load_balancer.register_instance("http://localhost:5000")
+    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
 
-    # Start polling in a separate thread
-    polling_thread = Thread(target=load_balancer.start_polling)
-    polling_thread.start()
+    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
 
-    # Stop polling after some time for demonstration purposes
-    Timer(300, load_balancer.stop_polling).start()  # Stop after 5 minutes
+    def start_prefetching(self):
+        """Start the metadata prefetching in a separate thread."""
+        self.prefetch_metadata()

app.py

@@ -2,191 +2,33 @@ from flask import Flask, jsonify, request, send_from_directory
 from flask_cors import CORS
 import os
 import json
-import threading
+from threading import Thread
 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
-import logging
 from LoadBalancer import LoadBalancer
+import logging
 
-logging.basicConfig(level=logging.INFO)
-load_balancer = LoadBalancer()
-
-# Start polling in a separate thread
-polling_thread = threading.Thread(target=load_balancer.start_polling)
-polling_thread.start()
 
 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")
-FILM_STORE_JSON_PATH = os.path.join(CACHE_DIR, "film_store.json")
-TV_STORE_JSON_PATH = os.path.join(CACHE_DIR, "tv_store.json")
-INSTANCE_REGISTER_JSON_PATH = os.path.join(CACHE_DIR, "instance_register.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 is_valid_url(url):
-    # Simple URL validation (could be more complex if needed)
-    regex = re.compile(
-        r'^(?:http|ftp)s?://' # http:// or https://
-        r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|' # domain...
-        r'localhost|' # localhost...
-        r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|' # ...or ipv4
-        r'\[?[A-F0-9]*:[A-F0-9:]+\]?)' # ...or ipv6
-        r'(?::\d+)?' # optional port
-        r'(?:/?|[/?]\S+)$', re.IGNORECASE)
-    return re.match(regex, url) is not None
-
-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()
+load_balancer = LoadBalancer(cache_dir=CACHE_DIR, index_file=INDEX_FILE, token=TOKEN, repo=REPO)
 
 # API Endpoints
-
-@app.route('/api/film', methods=['GET'])
-def get_movie_api():
+@app.route('/api/film/<title>', methods=['GET'])
+def get_movie_api(title):
     """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:
+    with open(load_balancer.FILM_STORE_JSON_PATH, 'r') as json_file:
         film_store_data = json.load(json_file)
 
     # Check if the film is already cached
@@ -195,36 +37,32 @@ 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 = load_balancer.find_movie_path(title)
     
     if not movie_path:
         return jsonify({"error": "Movie not found"}), 404
     
     cache_path = os.path.join(CACHE_DIR, movie_path)
     file_url = f"https://huggingface.co/{REPO}/resolve/main/{movie_path}"
-    proxies = get_system_proxies()
-    film_id = get_film_id(title)
+    proxies = load_balancer.get_system_proxies()
+    film_id = load_balancer.get_film_id(title)
     
     # Start the download in a separate thread if not already downloading
-    if film_id not in 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 load_balancer.download_threads or not load_balancer.download_threads[film_id].is_alive():
+        thread = Thread(target=load_balancer.download_film, args=(file_url, TOKEN, cache_path, proxies, film_id, title))
+        load_balancer.download_threads[film_id] = thread
         thread.start()
     
     return jsonify({"status": "Download started", "film_id": film_id})
 
-@app.route('/api/tv', methods=['GET'])
-def get_tv_show_api():
+@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."""
-    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:
+    with open(load_balancer.TV_STORE_JSON_PATH, 'r') as json_file:
         tv_store_data = json.load(json_file)
 
     # Check if the episode is already cached
@@ -232,16 +70,17 @@ def get_tv_show_api():
         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 = find_tv_path(file_structure, title)
+    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 file_structure:
+    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():
@@ -257,24 +96,39 @@ 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 = load_balancer.get_system_proxies()
+    episode_id = load_balancer.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 load_balancer.download_threads or not load_balancer.download_threads[episode_id].is_alive():
+        thread = Thread(target=load_balancer.download_episode, args=(file_url, TOKEN, cache_path, proxies, episode_id, title))
+        load_balancer.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)
+    progress = load_balancer.get_download_progress(id)
     return jsonify({"id": id, "progress": progress})
 
+@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 = load_balancer.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
@@ -282,7 +136,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 = load_balancer.bytes_to_human_readable(total_size)
     return jsonify({"cache_size": readable_size})
 
 @app.route('/api/cache/clear', methods=['POST'])
@@ -296,8 +150,8 @@ 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(load_balancer.TV_STORE_JSON_PATH):
+        with open(load_balancer.TV_STORE_JSON_PATH, 'r') as json_file:
             tv_store_data = json.load(json_file)
         return jsonify(tv_store_data)
     return jsonify({}), 404
@@ -305,39 +159,15 @@ def get_tv_store_api():
 @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:
+    if os.path.exists(load_balancer.FILM_STORE_JSON_PATH):
+        with open(load_balancer.FILM_STORE_JSON_PATH, 'r') as json_file:
             tv_store_data = json.load(json_file)
         return jsonify(tv_store_data)
     return jsonify({}), 404
 
-#################################################
-# No change needed
-
-@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/film/metadata', methods=['GET'])
-def get_film_metadata_api():
+@app.route('/api/film/metadata/<title>', methods=['GET'])
+def get_film_metadata_api(title):
     """Endpoint to get the film metadata by title."""
-    title = request.args.get('title')
     if not title:
         return jsonify({'error': 'No title provided'}), 400
     
@@ -350,10 +180,9 @@ def get_film_metadata_api():
     
     return jsonify({'error': 'Metadata not found'}), 404
 
-@app.route('/api/tv/metadata', methods=['GET'])
-def get_tv_metadata_api():
+@app.route('/api/tv/metadata/<title>', methods=['GET'])
+def get_tv_metadata_api(title):
     """Endpoint to get the TV show metadata by title."""
-    title = request.args.get('title')
     if not title:
         return jsonify({'error': 'No title provided'}), 400
     
@@ -364,7 +193,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 = load_balancer.get_tv_structure(title)
         if tv_structure_data:
             data['file_structure'] = tv_structure_data
         
@@ -375,11 +204,12 @@ def get_tv_metadata_api():
 
 @app.route("/api/film/all")
 def get_all_films_api():
-    return get_all_films(file_structure)
+    return load_balancer.get_all_films()
 
 @app.route("/api/tv/all")
 def get_all_tvshows_api():
-    return get_all_tv_shows(file_structure)
+    return load_balancer.get_all_tv_shows()
+
 
 #############################################################
 # unique api's
@@ -391,7 +221,7 @@ def register_instance():
             return jsonify({"error": "No URL provided"}), 400
         
         url = data["url"]
-        if not is_valid_url(url):
+        if not load_balancer.is_valid_url(url):
             return jsonify({"error": "Invalid URL"}), 400
 
         # Register the instance
@@ -403,16 +233,17 @@ def register_instance():
     except Exception as e:
         logging.error(f"Error registering instance: {e}")
         return jsonify({"error": "Failed to register instance"}), 500
+    
+@app.route('/api/instances',methods=["GET"])
+def get_instances():
+    return load_balancer.instances
+
 #############################################################
 # Routes
 @app.route('/')
 def index():
     return f"Load Balancer is Running {load_balancer.version}"
 
-@app.route('/api/instances',methods=["GET"])
-def get_instances():
-    return load_balancer.instances
-
 # Main entry point
 if __name__ == "__main__":
     app.run(debug=True, host="0.0.0.0", port=7860)

old.LoadBalancer.py

@@ -0,0 +1,73 @@
+import time
+import logging
+from threading import Thread, Event, Timer
+from api import InstancesAPI
+
+class LoadBalancer:
+    def __init__(self, polling_interval=10, max_retries=3, initial_delay=1):
+        self.version = "0.0.1 V Beta"
+        self.instances = []
+        self.polling_interval = polling_interval
+        self.max_retries = max_retries
+        self.initial_delay = initial_delay
+        self.stop_event = Event()
+        self.instances_api = InstancesAPI(self.instances)
+
+    def register_instance(self, instance_url):
+        if instance_url not in self.instances:
+            self.instances.append(instance_url)
+            logging.info(f"Registered instance {instance_url}")
+        else:
+            logging.info(f"Instance {instance_url} is already registered.")
+
+    def remove_instance(self, instance_url):
+        if instance_url in self.instances:
+            self.instances.remove(instance_url)
+            logging.info(f"Removed instance {instance_url}")
+        else:
+            logging.info(f"Instance {instance_url} not found for removal.")
+        
+    def get_reports(self):
+        reports = self.instances_api.fetch_reports()
+        for instance_url in self.instances[:]:  # Copy list to avoid modification during iteration
+            if instance_url in reports:
+                report = reports[instance_url]
+                logging.info(f"Report from {instance_url}: {report}")
+                self.process_report(instance_url, report)
+            else:
+                logging.error(f"Failed to get report from {instance_url}. Removing instance.")
+                self.remove_instance(instance_url)
+
+    def process_report(self, instance_url, report):
+        # Process the report (film_store, tv_store, cache_size) here
+        logging.info(f"Processing report from {instance_url}")
+        # Example: Print the film_store and tv_store
+        logging.info(f"Film Store: {report.get('film_store')}")
+        logging.info(f"TV Store: {report.get('tv_store')}")
+        logging.info(f"Cache Size: {report.get('cache_size')}")
+
+    def start_polling(self):
+        logging.info("Starting polling.")
+        while not self.stop_event.is_set():
+            self.get_reports()
+            time.sleep(self.polling_interval)
+        logging.info("Polling stopped.")
+
+    def stop_polling(self):
+        logging.info("Stopping polling.")
+        self.stop_event.set()
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+
+    load_balancer = LoadBalancer()
+
+    # Example registration (in real use, handle this via an API endpoint)
+    load_balancer.register_instance("http://localhost:5000")
+
+    # Start polling in a separate thread
+    polling_thread = Thread(target=load_balancer.start_polling)
+    polling_thread.start()
+
+    # Stop polling after some time for demonstration purposes
+    Timer(300, load_balancer.stop_polling).start()  # Stop after 5 minutes

old.app.py

@@ -0,0 +1,418 @@
+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
+import logging
+from LoadBalancer import LoadBalancer
+
+logging.basicConfig(level=logging.INFO)
+load_balancer = LoadBalancer()
+
+# Start polling in a separate thread
+polling_thread = threading.Thread(target=load_balancer.start_polling)
+polling_thread.start()
+
+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")
+INSTANCE_REGISTER_JSON_PATH = os.path.join(CACHE_DIR, "instance_register.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 is_valid_url(url):
+    # Simple URL validation (could be more complex if needed)
+    regex = re.compile(
+        r'^(?:http|ftp)s?://' # http:// or https://
+        r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|' # domain...
+        r'localhost|' # localhost...
+        r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|' # ...or ipv4
+        r'\[?[A-F0-9]*:[A-F0-9:]+\]?)' # ...or ipv6
+        r'(?::\d+)?' # optional port
+        r'(?:/?|[/?]\S+)$', re.IGNORECASE)
+    return re.match(regex, url) is not None
+
+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/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
+
+#################################################
+# No change needed
+
+@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/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)
+
+#############################################################
+# unique api's
+@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}"
+
+@app.route('/api/instances',methods=["GET"])
+def get_instances():
+    return load_balancer.instances
+
+# Main entry point
+if __name__ == "__main__":
+    app.run(debug=True, host="0.0.0.0", port=7860)