music adaptation

LoadBalancer.py

@@ -1,8 +1,5 @@
 import os
 from indexer import indexer
-import re
-import urllib.parse
-from tvdb import fetch_and_cache_json
 from threading import Event, Thread
 import asyncio
 import time
@@ -14,7 +11,7 @@ CACHE_DIR = os.getenv("CACHE_DIR")
 
 class LoadBalancer:
     def __init__(self, cache_dir, token, repo, polling_interval=4, max_retries=3, initial_delay=1):
-        self.version = "0.0.0.4 Alpha"
+        self.version = "0.0.1 Alpha"
         self.instances = []
         self.instances_health = {}
         self.polling_interval = polling_interval
@@ -25,10 +22,8 @@ class LoadBalancer:
         self.CACHE_DIR = cache_dir
         self.TOKEN = token
         self.REPO = repo
-        self.FILM_STORE = {}
-        self.TV_STORE = {}
+        self.MUSIC_STORE = {}
         self.file_structure = None
-        self.previous_file_structure = None  # To keep track of previous content
 
         # Ensure CACHE_DIR exists
         if not os.path.exists(self.CACHE_DIR):
@@ -36,7 +31,6 @@ class LoadBalancer:
 
         # Initialize file structure and start prefetching
         self.file_structure = indexer()
-        self.start_prefetching()
 
         # Start polling and file checking in separate threads
         polling_thread = Thread(target=self.start_polling)
@@ -53,84 +47,33 @@ class LoadBalancer:
             await self.start_prefetching()  # Start prefetching
             await asyncio.sleep(300)  # Sleep for 5 minutes
 
-    def start_prefetching(self):
-        """Start the metadata prefetching in the FastAPI event loop."""
-        return asyncio.create_task(self.prefetch_metadata())
-
-    async def prefetch_metadata(self):
-        """Prefetch metadata for all items in the file structure."""
-        tasks = []
-        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])
-
-                    # Schedule the fetch and cache task
-                    json_cache_path = os.path.join(self.CACHE_DIR, f"{urllib.parse.quote(original_title)}.json")
-                    if not os.path.exists(json_cache_path):
-                        tasks.append(fetch_and_cache_json(original_title, title, media_type, year))
-                logging.info(f"Skipping.. {original_title} metadata already cached")
-        
-        # Run all tasks concurrently
-        await asyncio.gather(*tasks)
-
     def get_reports(self):
         reports = self.instances_api.fetch_reports()
-        temp_film_store = {}
-        temp_tv_store = {}
+        temp_music_store = {}
 
         for instance_url in self.instances[:]:
             if instance_url in reports:
                 report = reports[instance_url]
                 logging.info(f"Report from {instance_url}: {report}")
-                self.process_report(instance_url, report, temp_film_store, temp_tv_store)
+                self.process_report(instance_url, report, temp_music_store)
             else:
                 logging.error(f"Failed to get report from {instance_url}. Removing instance.")
                 self.remove_instance(instance_url)
 
-        self.FILM_STORE = temp_film_store
-        self.TV_STORE = temp_tv_store
+        self.MUSIC_STORE = temp_music_store
 
-    def process_report(self, instance_url, report, temp_film_store, temp_tv_store):
-        film_store = report.get('film_store', {})
-        tv_store = report.get('tv_store', {})
+    def process_report(self, instance_url, report, temp_music_store):
+        music_store = report.get('music_store', {})
         cache_size = report.get('cache_size')
 
         logging.info(f"Processing report from {instance_url}")
 
-        # Update temporary film store
-        for title, path in film_store.items():
-            url = f"{instance_url}/api/get/film/{title.replace(' ', '%20')}"
-            temp_film_store[title] = url
-
-        # Update temporary TV store
-        for title, seasons in tv_store.items():
-            if title not in temp_tv_store:
-                temp_tv_store[title] = {}
-            for season, episodes in seasons.items():
-                if season not in temp_tv_store[title]:
-                    temp_tv_store[title][season] = {}
-                for episode, path in episodes.items():
-                    url = f"{instance_url}/api/get/tv/{title.replace(' ', '%20')}/{season.replace(' ', '%20')}/{episode.replace(' ', '%20')}"
-                    temp_tv_store[title][season][episode] = url
+        # Update temporary music store
+        for title, path in music_store.items():
+            url = f"{instance_url}/api/get/music/{title.replace(' ', '%20')}"
+            temp_music_store[title] = url
 
-        logging.info("Film and TV Stores processed successfully.")
+        logging.info("Music Store processed successfully.")
         self.update_instances_health(instance=instance_url, cache_size=cache_size)
 
     def start_polling(self):
@@ -160,156 +103,60 @@ class LoadBalancer:
             logging.info(f"Instance {instance_url} not found for removal.")
 
     def update_instances_health(self, instance, cache_size):
-        self.instances_health[instance] = {"used":cache_size["cache_size"],
-                                           "total": "50 GB"}
+        self.instances_health[instance] = {"used": cache_size["cache_size"], "total": "50 GB"}
         logging.info(f"Updated instance {instance} with cache size {cache_size}")
 
-    def download_film_to_best_instance(self, title):
+    def download_music_to_best_instance(self, file_name):
         """
-        Downloads a film to the first instance that has more free space on the self.instance_health list variable. 
-        The instance_health looks like this:
-        {
-            "https://unicone-studio-instance1.hf.space": {
-                "total": "50 GB",
-                "used": "3.33 GB"
-            }
-        }
-        Args:
-            title (str): The title of the film.
+        Downloads a music file to the first instance that has more free space on the self.instance_health list variable.
         """
         best_instance = None
         max_free_space = -1
-        
-        # Calculate free space for each instance
-        for instance_url, space_info in self.instances_health.items():
-            total_space = convert_to_gb(space_info['total'])
-            used_space = convert_to_gb(space_info['used'])
-            free_space = total_space - used_space
-            
-            if free_space > max_free_space:
-                max_free_space = free_space
-                best_instance = instance_url
-        
-        if best_instance:
-            result = self.instances_api.download_film(best_instance, title)
-            film_id = result["film_id"]
-            status = result["status"]
-            progress_url = f'{best_instance}/api/get/progress/{film_id}'
-            response = {
-                "film_id":film_id,
-                "status":status,
-                "progress_url":progress_url
-            }
-
-            return response
-        else:
-            logging.error("No suitable instance found for downloading the film.")
-            return {"error": "No suitable instance found for downloading the film."}
 
-    def download_episode_to_best_instance(self, title, season, episode):
-        """
-        Downloads a episode to the first instance that has more free space on the self.instance_health list variable. 
-        The instance_health looks like this:
-        {
-            "https://unicone-studio-instance1.hf.space": {
-                "total": "50 GB",
-                "used": "3.33 GB"
-            }
-        }
-        Args:
-            title (str): The title of the Tv show.
-            season (str): The season of the Tv show.
-            episode (str): The title of the Tv show.
-        """
-        best_instance = None
-        max_free_space = -1
-        
-        # Calculate free space for each instance
         for instance_url, space_info in self.instances_health.items():
             total_space = convert_to_gb(space_info['total'])
             used_space = convert_to_gb(space_info['used'])
             free_space = total_space - used_space
-            
+
             if free_space > max_free_space:
                 max_free_space = free_space
                 best_instance = instance_url
-        
+
         if best_instance:
-            result = self.instances_api.download_episode(best_instance, title, season, episode)
-            episode_id = result["episode_id"]
+            result = self.instances_api.download_music(best_instance, file_name)
+            music_id = result["music_id"]
             status = result["status"]
-            progress_url = f'{best_instance}/api/get/progress/{episode_id}'
+            progress_url = f'{best_instance}/api/get/progress/{music_id}'
             response = {
-                "episode_id":episode_id,
-                "status":status,
-                "progress_url":progress_url
+                "music_id": music_id,
+                "status": status,
+                "progress_url": progress_url
             }
 
             return response
         else:
-            logging.error("No suitable instance found for downloading the film.")
-            return {"error": "No suitable instance found for downloading the film."}
+            logging.error("No suitable instance found for downloading the music.")
+            return {"error": "No suitable instance found for downloading the music."}
 
-    def find_movie_path(self, title):
-        """Find the path of the movie in the JSON data based on the title."""
+    def find_music_path(self, title):
+        """Find the path of the music in the indexed data based on the title."""
         for directory in self.file_structure:
-            if directory['type'] == 'directory' and directory['path'] == 'films':
+            if directory['type'] == 'directory':
                 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():
+                    if sub_directory['type'] == 'file' and title.lower() in sub_directory['path'].lower():
                         return sub_directory['path']
         return None
 
-    def get_tv_structure(self, title):
-        """Find the path of the TV show in the JSON data based on the title."""
-        for directory in self.file_structure:
-            if directory['type'] == 'directory' and directory['path'] == 'tv':
-                for sub_directory in directory['contents']:
-                    if sub_directory['type'] == 'directory' and title.lower() in sub_directory['path'].lower():
-                        return sub_directory
-        return None
-
-    def get_film_id(self, title):
-        """Generate a film ID based on the title."""
+    def get_music_id(self, title):
+        """Generate a unique music ID based on the title."""
         return title.replace(" ", "_").lower()
 
-    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 = []
+    def get_all_music(self):
+        """Get all music files from the indexed file structure."""
+        music_files = []
         for directory in self.file_structure:
-            if directory['type'] == 'directory' and directory['path'] == 'films':
+            if directory['type'] == 'directory':
                 for sub_directory in directory['contents']:
-                    if sub_directory['type'] == 'directory':
-                        films.append(sub_directory['path'])
-        return films
+                    if sub_directory['type'] == 'file':
+                        music_files.append(sub_directory['path'])
+        return music_files

TODO.md

@@ -1,4 +0,0 @@
-create endpoints for
-* /api/get/film/{title} `Endpoint to get the movie by title.`
-
-* /api/get/tv/{title}/{season}/{episode} `Endpoint to get the episode by title, season and episode.`

api.py

@@ -16,43 +16,20 @@ class InstancesAPI:
                 logging.error(f"Error contacting instance {instance_url}: {e}")
         return reports
 
-    def download_film(self, instance_url, title):
+    def download_music(self, instance_url, title):
         """
-        Download a film to an instance.
+        Download a music file to an instance.
 
-        If the download started, it returns a JSON like this:
+        If the download starts, it returns a JSON like this:
         example: 
-            {"film_id": "my_spy_2020",
+            {"music_id": "song_title_2024",
             "status": "Download started"}
 
-        If the film has already been downloaded, it will return the video file. 
+        If the music file has already been downloaded, it will return the audio file.
         """
         data = {}
         try:
-            response = requests.get(f"{instance_url}/api/get/film/{title}")
-            response.raise_for_status()
-            data = response.json()
-            
-        except requests.exceptions.RequestException as e:
-            logging.error(f"Error contacting instance {instance_url}: {e}")
-            data = {"error": str(e)}
-
-        return data
-
-    def download_episode(self, instance_url, title, season, episode):
-        """
-        Download a film to an instance.
-
-        If the download started, it returns a JSON like this:
-        example: 
-            {"film_id": "my_spy_2020",
-            "status": "Download started"}
-
-        If the film has already been downloaded, it will return the video file. 
-        """
-        data = {}
-        try:
-            response = requests.get(f"{instance_url}/api/get/tv/{title}/{season}/{episode}")
+            response = requests.get(f"{instance_url}/api/get/music/{title}")
             response.raise_for_status()
             data = response.json()
             

app.py

@@ -1,12 +1,10 @@
-from fastapi import FastAPI,HTTPException, Request, Query
+from fastapi import FastAPI, HTTPException, Request
 from fastapi.responses import JSONResponse
-from typing import Optional, List
-from LoadBalancer import LoadBalancer
 import logging
 import os
-import urllib.parse
-from utils import read_json_file, is_valid_url
-from tvdb import recent_list, genre_list
+from typing import List
+from LoadBalancer import LoadBalancer
+from utils import is_valid_url
 
 CACHE_DIR = os.getenv("CACHE_DIR")
 TOKEN = os.getenv("TOKEN")
@@ -17,7 +15,6 @@ app = FastAPI()
 @app.on_event("startup")
 async def startup_event():
     global load_balancer
-    
     load_balancer = LoadBalancer(cache_dir=CACHE_DIR, token=TOKEN, repo=REPO)
 
 @app.get("/")
@@ -47,172 +44,15 @@ async def register_instance(request: Request):
 
 @app.get("/api/get/file_structure")
 async def get_file_structure():
-    return  load_balancer.file_structure
-
-@app.get("/api/get/movie/store")
-async def get_movie_store():
-    return  load_balancer.FILM_STORE
-
-@app.get("/api/get/series/store")
-async def get_series_store():
-    return  load_balancer.TV_STORE
-
-@app.get("/api/get/movie/all")
-async def get_all_movies_api():
-    return load_balancer.get_all_films()
-
-@app.get("/api/get/series/all")
-async def get_all_tvshows_api():
-    return load_balancer.get_all_tv_shows()
-
-@app.get("/api/get/recent")
-async def get_recent_items(limit: int = 5):
-    # Get sorted entries
-    recent_films = recent_list.get_sorted_entries('film')
-    recent_series = recent_list.get_sorted_entries('series')
-
-    # Slice the lists to only return the desired number of items
-    limited_films = recent_films[:limit]
-    limited_series = recent_series[:limit]
-
-    # Return combined results
-    return JSONResponse(content={
-        'movies': limited_films,
-        'series': limited_series
-    })
-
-@app.get("/api/get/genre")
-async def get_genre_items(genre: List[str] = Query(...), media_type: Optional[str] = None, limit: int = 5):
-    """
-    Get recent items from specified genres with an optional media type filter and a limit on the number of results.
-
-    :param genre: The genres to filter by (e.g., 'Comedy').
-    :param media_type: Optional. Filter by media type ('movie' or 'series').
-    :param limit: The maximum number of items to return for each media type.
-    :return: A JSON response containing the filtered items.
-    """
-    # Get sorted entries based on genres and media type
-    entries = genre_list.get_entries_by_multiple_genres(genre, media_type=media_type)
-    
-    # Separate entries by media type
-    movies = [entry for entry in entries if entry[4] == 'movie']
-    series = [entry for entry in entries if entry[4] == 'series']
-
-    # Limit the number of items for each media type
-    limited_movies = movies[:limit]
-    limited_series = series[:limit]
-
-    # Organize the results by media type
-    results = {
-        'movies': limited_movies,
-        'series': limited_series
-    }
-
-    # Return the results in a JSON response
-    return JSONResponse(content=results)
-
-@app.get("/api/get/movie/metadata/{title}")
-async def get_movie_metadata_api(title: str):
-    """Endpoint to get the movie metadata by title."""
-    if not title:
-        raise HTTPException(status_code=400, detail="No title provided")
-    
-    full_dir_path = os.path.join(CACHE_DIR, 'movie')
-    json_cache_path = os.path.join(full_dir_path,f"{urllib.parse.quote(title)}.json")
-    
-    if os.path.exists(json_cache_path):
-        data = await read_json_file(json_cache_path)
-        return JSONResponse(content=data)
-    
-    raise HTTPException(status_code=404, detail="Metadata not found")
-
-@app.get("/api/get/movie/card/{title}")
-async def get_movie_card_api(title: str):
-    """Endpoint to get the movie metadata by title."""
-    if not title:
-        raise HTTPException(status_code=400, detail="No title provided")
-    
-    full_dir_path = os.path.join(CACHE_DIR, 'movie')
-    json_cache_path = os.path.join(full_dir_path,f"{urllib.parse.quote(title)}.json")
-    
-    if os.path.exists(json_cache_path):
-        data = await read_json_file(json_cache_path)
-        image = data['data']['image']
-        eng_title = None
-        banner = None
-        if data['data'].get('translations') and data['data']['translations'].get('nameTranslations'):
-            for name in data['data']['translations']['nameTranslations']:
-                if name['language'] == 'eng':
-                    eng_title = name.get('name')
-                    break
-
-        if data['data'].get('artworks'):
-            for artwork in data['data']['artworks']:
-                if artwork['type'] == 15:
-                    banner = artwork
-                    break
-        year = data['data']['year']
-        return JSONResponse(content={'title':eng_title or title, 'year': year, 'image': image, 'banner':banner})
-    
-    raise HTTPException(status_code=404, detail="Card not found")
+    return load_balancer.file_structure
 
-@app.get("/api/get/series/metadata/{title}")
-async def get_series_metadata_api(title: str):
-    """Endpoint to get the TV show metadata by title."""
-    if not title:
-        raise HTTPException(status_code=400, detail="No title provided")
-    full_dir_path = os.path.join(CACHE_DIR, 'series')
-    json_cache_path = os.path.join(full_dir_path,f"{urllib.parse.quote(title)}.json")
-    
-    if os.path.exists(json_cache_path):
-        data = await read_json_file(json_cache_path)
-        # Add the file structure to the metadata
-        tv_structure_data = load_balancer.get_tv_structure(title)
-        if tv_structure_data:
-            data['file_structure'] = tv_structure_data
-        
-        return JSONResponse(content=data)
-    
-    raise HTTPException(status_code=404, detail="Metadata not found")
+@app.get("/api/get/music/store")
+async def get_music_store():
+    return load_balancer.MUSIC_STORE
 
-@app.get("/api/get/series/card/{title}")
-async def get_series_card_api(title: str):
-    """Endpoint to get the TV show metadata by title."""
-    if not title:
-        raise HTTPException(status_code=400, detail="No title provided")
-    full_dir_path = os.path.join(CACHE_DIR, 'series')
-    json_cache_path = os.path.join(full_dir_path,f"{urllib.parse.quote(title)}.json")
-    
-    if os.path.exists(json_cache_path):
-        data = await read_json_file(json_cache_path)
-        image = data['data']['image']
-        eng_title = None
-        if data['data'].get('translations') and data['data']['translations'].get('nameTranslations'):
-            for name in data['data']['translations']['nameTranslations']:
-                if name['language'] == 'eng':
-                    eng_title = name.get('name')
-                    break
-        year = data['data']['year']
-        return JSONResponse(content={'title':eng_title or title, 'year': year, 'image': image})
-    
-    raise HTTPException(status_code=404, detail="Card not found")
-
-
-@app.get("/api/get/series/metadata/{series_id}/{season}")
-async def get_season_metadata_api(series_id: int, season: str):
-    """Endpoint to get the TV show season metadata by id and season."""
-    if not season:
-        raise HTTPException(status_code=400, detail="Season must be provided and cannot be empty")
-    
-    # Convert series_id to string before joining the path
-    json_cache_path = os.path.join(CACHE_DIR, "metadata", str(series_id), f"{season}.json")
-    print(json_cache_path)
-    
-    if os.path.exists(json_cache_path):
-        data = await read_json_file(json_cache_path)
-        return JSONResponse(content=data)
-    
-    raise HTTPException(status_code=404, detail="Metadata not found")
+@app.get("/api/get/music/all")
+async def get_all_music_api():
+    return load_balancer.get_all_music()
 
 @app.get('/api/get/instances')
 async def get_instances():
@@ -222,61 +62,23 @@ async def get_instances():
 async def get_instances_health():
     return load_balancer.instances_health
 
-@app.get("/api/get/movie/{title}")
-async def get_movie_api(title: str):
-    """Endpoint to get the movie by title."""
-    if not title:
-        raise HTTPException(status_code=400, detail="Title parameter is required")
+@app.get("/api/get/music/{file_name}")
+async def get_music_api(file_name: str):
+    """Endpoint to get the music file by title."""
+    if not file_name:
+        raise HTTPException(status_code=400, detail="file_name parameter is required")
     
-    # Check if the movie is already cached
-    if title in load_balancer.FILM_STORE:
-        url = load_balancer.FILM_STORE[title]
+    # Check if the music file is already cached
+    if file_name in load_balancer.MUSIC_STORE:
+        url = load_balancer.MUSIC_STORE[file_name]
         return JSONResponse(content={"url": url})
 
-    movie_path = load_balancer.find_movie_path(title)
+    music_path = load_balancer.find_music_path(file_name)
     
-    if not movie_path:
-        raise HTTPException(status_code=404, detail="Movie not found")
+    if not music_path:
+        raise HTTPException(status_code=404, detail="Music file not found")
     
     # Start the download in an instance
-    response = load_balancer.download_film_to_best_instance(title=title)
+    response = load_balancer.download_music_to_best_instance(file_name=file_name)
     if response:
         return JSONResponse(content=response)
-
-@app.get("/api/get/series/{title}/{season}/{episode}")
-async def get_tv_show_api(title: str, season: str, episode: str):
-    """Endpoint to get the TV show by title, season, and episode."""
-    if not title or not season or not episode:
-        raise HTTPException(status_code=400, detail="Title, season, and episode parameters are required")
-
-    # Check if the episode is already cached
-    if title in load_balancer.TV_STORE and season in load_balancer.TV_STORE[title]:
-        for ep in load_balancer.TV_STORE[title][season]:
-            if episode in ep:
-                url = load_balancer.TV_STORE[title][season][ep]
-                return JSONResponse(content={"url": url})
-
-    tv_path = load_balancer.find_tv_path(title)
-    
-    if not tv_path:
-        raise HTTPException(status_code=404, detail="TV show not found")
-
-    episode_path = None
-    for directory in load_balancer.file_structure:
-        if directory['type'] == 'directory' and directory['path'] == 'tv':
-            for sub_directory in directory['contents']:
-                if sub_directory['type'] == 'directory' and title.lower() in sub_directory['path'].lower():
-                    for season_dir in sub_directory['contents']:
-                        if season_dir['type'] == 'directory' and season in season_dir['path']:
-                            for episode_file in season_dir['contents']:
-                                if episode_file['type'] == 'file' and episode in episode_file['path']:
-                                    episode_path = episode_file['path']
-                                    break
-
-    if not episode_path:
-        raise HTTPException(status_code=404, detail="Episode not found")
-    
-    # Start the download in an instance
-    response = load_balancer.download_episode_to_best_instance(title=title, season=season, episode=episode)
-    if response:
-        return JSONResponse(content=response)

services.py

@@ -1,181 +0,0 @@
-import bisect
-
-class RecentList:
-    def __init__(self):
-        # Initialize dictionaries to store titles and associated data
-        self.films = {}
-        self.series = {}
-        # Initialize lists to keep track of the sorted entries
-        self.sorted_films = []
-        self.sorted_series = []
-
-    def add_entry(self, title, year, description, image_link, media_type):
-        if media_type == 'film':
-            self._update_entry(self.films, self.sorted_films, title, year, description, image_link)
-        elif media_type == 'series':
-            self._update_entry(self.series, self.sorted_series, title, year, description, image_link)
-    
-    def _update_entry(self, dictionary, sorted_list, title, year, description, image_link):
-        try:
-            # Convert year to integer
-            year = int(year)
-        except ValueError:
-            raise ValueError(f"Invalid year: {year}. Year must be an integer.")
-
-        if title in dictionary:
-            # Remove the old entry from the sorted list if it exists
-            old_year = dictionary[title][0]  # Get the old year
-            try:
-                sorted_list.remove((-old_year, title))
-            except ValueError:
-                pass  # Ignore if the old entry does not exist in the sorted list
-        
-        # Update or add the new entry in the dictionary
-        dictionary[title] = (year, description, image_link)
-        
-        # Insert the new year and title into the sorted list
-        bisect.insort(sorted_list, (-year, title))
-
-    def get_sorted_entries(self, media_type):
-        if media_type == 'film':
-            # Get sorted films with details
-            return [(title, -year, self.films[title][1], self.films[title][2]) for year, title in self.sorted_films]
-        elif media_type == 'series':
-            # Get sorted series with details
-            return [(title, -year, self.series[title][1], self.series[title][2]) for year, title in self.sorted_series]
-
-import bisect
-
-class GenreList:
-    def __init__(self):
-        # Initialize a dictionary to store genres and their associated data
-        self.genres = {}
-
-    def add_entry(self, genres, title, year, description, image_link, media_type):
-        """
-        Add an entry to multiple genres.
-
-        :param genres: A list of genre dictionaries, each containing 'id', 'name', and 'slug'.
-        :param title: The title of the media.
-        :param year: The release year of the media.
-        :param description: A brief description of the media.
-        :param image_link: A URL to an image representing the media.
-        :param media_type: The type of media ('movie' or 'series').
-        """
-        for genre in genres:
-            genre_name = genre['name']
-            if genre_name not in self.genres:
-                # Initialize the genre with an empty dictionary and sorted list
-                self.genres[genre_name] = {'entries': {}, 'sorted_entries': []}
-            
-            # Update or add the entry in the specified genre
-            self._update_genre(self.genres[genre_name]['entries'], self.genres[genre_name]['sorted_entries'], title, year, description, image_link, media_type)
-
-    def _update_genre(self, dictionary, sorted_list, title, year, description, image_link, media_type):
-        try:
-            # Convert year to integer
-            year = int(year)
-        except ValueError:
-            raise ValueError(f"Invalid year: {year}. Year must be an integer.")
-
-        if title in dictionary:
-            # Remove the old entry from the sorted list if it exists
-            old_year = dictionary[title][0]  # Get the old year
-            try:
-                sorted_list.remove((-old_year, title))
-            except ValueError:
-                pass  # Ignore if the old entry does not exist in the sorted list
-        
-        # Update or add the new entry in the genre dictionary
-        dictionary[title] = (year, description, image_link, media_type)
-        
-        # Insert the new year and title into the sorted list
-        bisect.insort(sorted_list, (-year, title))
-
-    def get_sorted_entries(self, genre_name, media_type=None):
-        """
-        Get sorted entries for a specified genre and optional media type.
-
-        :param genre_name: The name of the genre to retrieve entries from.
-        :param media_type: Optional. Filter by media type ('movie' or 'series').
-        :return: A list of tuples containing title, year, description, image_link, and media_type.
-        """
-        if genre_name in self.genres:
-            entries = [
-                (title, -year, self.genres[genre_name]['entries'][title][1], 
-                 self.genres[genre_name]['entries'][title][2], self.genres[genre_name]['entries'][title][3])
-                for year, title in self.genres[genre_name]['sorted_entries']
-            ]
-            if media_type:
-                entries = [entry for entry in entries if entry[4] == media_type]
-            return entries
-        else:
-            return []
-
-    def get_entries_by_multiple_genres(self, genre_names, media_type=None):
-        """
-        Get entries that are present in all specified genres.
-
-        :param genre_names: A list of genre names.
-        :param media_type: Optional. Filter by media type ('movie' or 'series').
-        :return: A list of tuples containing title, year, description, image_link, and media_type.
-        """
-        if not genre_names:
-            return []
-
-        # Get entries for the first genre
-        common_entries = set(self.genres[genre_names[0]]['entries'].keys()) if genre_names[0] in self.genres else set()
-
-        # Intersect with entries of the remaining genres
-        for genre_name in genre_names[1:]:
-            if genre_name in self.genres:
-                common_entries.intersection_update(self.genres[genre_name]['entries'].keys())
-            else:
-                return []
-
-        # Collect the sorted entries for the common titles
-        sorted_entries = []
-        for title in common_entries:
-            year = self.genres[genre_names[0]]['entries'][title][0]
-            description = self.genres[genre_names[0]]['entries'][title][1]
-            image_link = self.genres[genre_names[0]]['entries'][title][2]
-            media_type_entry = self.genres[genre_names[0]]['entries'][title][3]
-            if media_type is None or media_type_entry == media_type:
-                sorted_entries.append((title, year, description, image_link, media_type_entry))
-
-        # Sort the entries by year (descending)
-        sorted_entries.sort(key=lambda x: -x[1])
-
-        return sorted_entries
-
-    def remove_genre(self, genre_name):
-        """Remove a genre entirely from the list."""
-        if genre_name in self.genres:
-            del self.genres[genre_name]
-
-    def remove_entry_from_genre(self, genre_name, title):
-        """Remove a specific title from a specific genre."""
-        if genre_name in self.genres and title in self.genres[genre_name]['entries']:
-            old_year = self.genres[genre_name]['entries'][title][0]
-            del self.genres[genre_name]['entries'][title]
-            self.genres[genre_name]['sorted_entries'].remove((-old_year, title))
-
-
-# Example usage:
-# genre_list = GenreList()
-# genres = [
-#     {"id": 15, "name": "Comedy", "slug": "comedy"},
-#     {"id": 17, "name": "Animation", "slug": "animation"},
-#     {"id": 27, "name": "Anime", "slug": "anime"}
-# ]
-# genres2 = [
-#     {"id": 15, "name": "Comedy", "slug": "comedy"},
-#     {"id": 17, "name": "Animation", "slug": "animation"},
-#     {"id": 27, "name": "Anime", "slug": "anime"}
-# ]
-# genre_list.add_entry(genres, 'Movie Title', 2023, 'Description here', 'image_link_here', 'movie')
-# genre_list.add_entry(genres2, 'Series Title', 2022, 'Series Description', 'series_image_link_here', 'movie')
-
-# # Fetch entries that belong to both 'Comedy' and 'Animation'
-# sorted_entries = genre_list.get_entries_by_multiple_genres(['Comedy', 'Animation'], media_type='movie')
-# print(sorted_entries)  # This should return only 'Movie Title' which is in both 'Comedy' and 'Animation'

tvdb.py

@@ -1,193 +0,0 @@
-# tvdb.py
-import os
-import requests
-import urllib.parse
-from datetime import datetime, timedelta
-from dotenv import load_dotenv
-import json
-import asyncio
-import aiofiles
-from tvdbApiClient import fetch_and_cache_seasons, save_to_json
-from services import RecentList, GenreList
-
-load_dotenv()
-THETVDB_API_KEY = os.getenv("THETVDB_API_KEY")
-THETVDB_API_URL = os.getenv("THETVDB_API_URL")
-CACHE_DIR = os.getenv("CACHE_DIR")
-TOKEN_EXPIRY = None
-THETVDB_TOKEN = None
-recent_list = RecentList()
-genre_list = GenreList()
-
-def authenticate_thetvdb():
-    global THETVDB_TOKEN, TOKEN_EXPIRY
-    auth_url = f"{THETVDB_API_URL}/login"
-    auth_data = {
-        "apikey": THETVDB_API_KEY
-    }
-    try:
-        print("Authenticating with TheTVDB API...")
-        response = requests.post(auth_url, json=auth_data)
-        response.raise_for_status()
-        response_data = response.json()
-        THETVDB_TOKEN = response_data['data']['token']
-        TOKEN_EXPIRY = datetime.now() + timedelta(days=30)
-        print("Authentication successful.")
-    except requests.RequestException as e:
-        print(f"Authentication failed: {e}")
-        THETVDB_TOKEN = None
-        TOKEN_EXPIRY = None
-
-def get_thetvdb_token():
-    global THETVDB_TOKEN, TOKEN_EXPIRY
-    if not THETVDB_TOKEN or datetime.now() >= TOKEN_EXPIRY:
-        authenticate_thetvdb()
-    return THETVDB_TOKEN
-
-def clean_data(data):
-    print("Cleaning data...")
-    fields_to_keep = {
-        "data": {
-            'id': None,
-            'name': None,
-            'image': None,
-            'score': None,
-            'runtime': None,
-            'releases': None,
-            'year': None,
-            'contentRatings': None,
-            'originalCountry': None,
-            'originalLanguage': None,
-            'translations': {},
-            'artworks': [],
-            'genres':[],
-            'characters': [],
-            'spoken_languages': [],
-            'translations': {}
-        }
-    }
-    cleaned_data = {}
-    
-    for key, value in fields_to_keep.items():
-        if key in data:
-            cleaned_data[key] = {}
-            for field in fields_to_keep[key]:
-                if field in data[key]:
-                    cleaned_data[key][field] = data[key][field]
-    
-    print("Data cleaned successfully.")
-    return cleaned_data
-
-async def fetch_and_cache_json(original_title, title, media_type, year=None):
-    print(f"Fetching data for: {original_title}")
-    if year:
-        search_url = f"{THETVDB_API_URL}/search?query={urllib.parse.quote(title)}&type={media_type}&year={year}"
-    else:
-        search_url = f"{THETVDB_API_URL}/search?query={urllib.parse.quote(title)}&type={media_type}"
-    
-    token = get_thetvdb_token()
-    if not token:
-        print("Authentication token not available.")
-        return
-    
-    headers = {
-        "Authorization": f"Bearer {token}",
-        "accept": "application/json",
-    }
-    
-    try:
-        print(f"Sending search request to: {search_url}")
-        response = requests.get(search_url, headers=headers)
-        print(f"Search response status code: {response.status_code}")
-        response.raise_for_status()
-        data = response.json()
-        
-        if 'data' in data and data['data']:
-            first_result = data['data'][0]
-            tvdb_id = first_result.get('tvdb_id')
-            media_type = first_result.get('type')
-            print(f"Found TVDB ID: {tvdb_id} with media type: {media_type}")
-            
-            if not tvdb_id:
-                print("TVDB ID not found in the search results")
-                return
-            
-            if media_type == 'movie':
-                extended_url = f"{THETVDB_API_URL}/movies/{tvdb_id}/extended?meta=translations"
-            elif media_type == 'series':
-                extended_url = f"{THETVDB_API_URL}/series/{tvdb_id}/extended?meta=translations"
-                await fetch_and_cache_seasons(tvdb_id)
-            else:
-                print(f"Unsupported media type: {media_type}")
-                return
-
-            response = requests.get(extended_url, headers=headers)
-            print(f"Extended data response status code: {response.status_code}")
-            response.raise_for_status()
-            extended_data = response.json()
-            
-            cleaned_data = clean_data(extended_data)
-            print(f"cleaning.. {original_title}")
-
-            genres = None
-            if cleaned_data['data'].get('genres'):
-                genres = cleaned_data['data'].get('genres')
-            print(f"genres extracted: {genres}")
-            
-            description = None
-            if cleaned_data['data'].get('translations') and cleaned_data['data']['translations'].get('overviewTranslations'):
-                for overview in cleaned_data['data']['translations']['overviewTranslations']:
-                    if overview['language'] == 'eng':
-                        description = overview.get('overview')
-                        break
-            print(f"Description extracted: {description}")
-            
-            image_link = None
-            if cleaned_data['data'].get('artworks'):
-                for artwork in cleaned_data['data']['artworks']:
-                    if artwork['type'] in [15, 3]:
-                        image_link = artwork.get('thumbnail')
-                        break
-            print(f"Image link extracted: {image_link}")
-            
-            if media_type == 'movie':
-                recent_list.add_entry(original_title, cleaned_data['data']['year'], description, image_link, 'film')
-                genre_list.add_entry(genres, original_title, cleaned_data['data']['year'], description, image_link, 'movie')
-            elif media_type == 'series':
-                recent_list.add_entry(original_title, cleaned_data['data']['year'], description, image_link, 'series')
-                genre_list.add_entry(genres, original_title, cleaned_data['data']['year'], description, image_link, 'series')
-            print(f"adding.. {original_title}")
-            
-            # Create the full directory path if it doesn't exist
-            full_dir_path = os.path.join(CACHE_DIR, media_type)
-            os.makedirs(full_dir_path, exist_ok=True)
-
-            # Now create the JSON cache path
-            json_cache_path = os.path.join(full_dir_path, f"{urllib.parse.quote(original_title)}.json")
-            await save_to_json(cleaned_data, json_cache_path)
-            print(f"Data saved to JSON at: {json_cache_path}")
-        else:
-            print(f"No data found for {original_title} in search results.")
-            
-    except requests.RequestException as e:
-        print(f"Error fetching data: {e}")
-    except Exception as e:
-        print(f"An unexpected error occurred: {e}")
-
-def main():
-    entries = [
-        {"original_title": "Funky Monkey (2004)", "title": "Funky Monkey", "media_type": "movie", "year": 2004},
-        {"original_title": "My Spy (2020)", "title": "My Spy", "media_type": "movie", "year": 2020},
-        {"original_title": "My Spy (2024)", "title": "My Spy", "media_type": "movie", "year": 2024},
-        {"original_title": "Yaariayan (2014)", "title": "Yaariayan", "media_type": "movie", "year": 2014},
-        {"original_title": "Yaariyan 2 (2023)", "title": "Yaariyan 2", "media_type": "movie", "year": 2023},
-    ]
-    
-    asyncio.run(process_entries(entries))
-
-async def process_entries(entries):
-    for entry in entries:
-        await fetch_and_cache_json(entry['original_title'], entry['title'], entry['media_type'], entry['year'])
-
-if __name__ == "__main__":
-    main()

tvdbApiClient.py

@@ -1,95 +0,0 @@
-import json
-import os
-import logging
-from pathlib import Path
-import tvdb_v4_official
-from utils import save_to_json
-
-THETVDB_API_KEY = os.getenv("THETVDB_API_KEY")
-CACHE_DIR = os.getenv("CACHE_DIR")
-SAVE_DIR = os.path.join(CACHE_DIR, "metadata")
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-
-# Initialize TVDB client
-tvdb = tvdb_v4_official.TVDB(THETVDB_API_KEY)
-
-def get_series_info(series_id):
-    """Fetch series information including episodes from TVDB."""
-    try:
-        series = tvdb.get_series_extended(series_id, meta="episodes")
-        logging.info("Series info fetched successfully.")
-        return series
-    except Exception as e:
-        logging.error(f"Error fetching series info: {e}")
-        return None
-
-def filter_episode_data(episode):
-    """Filter episode data to include only necessary fields."""
-    return {
-        "id": episode.get("id"),
-        "seriesId": episode.get("seriesId"),
-        "name": episode.get("name"),
-        "aired": episode.get("aired"),
-        "runtime": episode.get("runtime"),
-        "overview": episode.get("overview"),
-        "image": episode.get("image"),
-        "imageType": episode.get("imageType"),
-        "isMovie": episode.get("isMovie"),
-        "number": episode.get("number"),
-        "absoluteNumber": episode.get("absoluteNumber"),
-        "seasonNumber": episode.get("seasonNumber"),
-        "finaleType": episode.get("finaleType"),
-        "year": episode.get("year")
-    }
-
-
-
-async def fetch_and_cache_seasons(series_id):
-    """Fetch and cache episodes for a given series ID asynchronously."""
-    series_info = get_series_info(series_id)
-    if not series_info:
-        logging.error("Series info could not be fetched.")
-        return
-
-    # Fetch all episodes for the series
-    try:
-        all_episodes = tvdb.get_series_episodes(series_id, lang="eng").get('episodes', [])
-    except Exception as e:
-        logging.error(f"Error fetching episodes for series ID {series_id}: {e}")
-        return
-    
-    # Organize episodes by season
-    all_seasons = {}
-    for episode in all_episodes:
-        season_number = episode.get('seasonNumber')
-        
-        if season_number == 0:
-            season_key = "Specials"
-        else:
-            season_key = f"Season {season_number}"
-        
-        if season_key not in all_seasons:
-            all_seasons[season_key] = []
-        
-        filtered_data = filter_episode_data(episode)
-        all_seasons[season_key].append(filtered_data)
-    
-    # Create folder for the series
-    series_folder = Path(SAVE_DIR) / str(series_id)
-    series_folder.mkdir(parents=True, exist_ok=True)
-    
-    # Save episodes for each season in separate JSON files
-    for season_key, episodes in sorted(all_seasons.items()):
-        episodes_sorted = sorted(episodes, key=lambda e: e.get('number'))
-        season_file = series_folder / f"{season_key}.json"
-        await save_to_json(episodes_sorted, season_file)
-
-async def main(series_id):
-    """Main function to fetch and cache episodes asynchronously."""
-    await fetch_and_cache_seasons(series_id)
-
-if __name__ == "__main__":
-    import asyncio
-    # Replace with your series ID
-    SERIES_ID = "315103"
-    asyncio.run(main(SERIES_ID))