0.0.0.3 Alpha

LoadBalancer.py

@@ -14,7 +14,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.2 Alpha"
+        self.version = "0.0.0.3 Alpha"
         self.instances = []
         self.instances_health = {}
         self.polling_interval = polling_interval

app.py

@@ -1,11 +1,12 @@
-from fastapi import FastAPI,HTTPException, Request
+from fastapi import FastAPI,HTTPException, Request, Query
 from fastapi.responses import JSONResponse
+from typing import Optional
 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
+from tvdb import recent_list, genre_list
 
 CACHE_DIR = os.getenv("CACHE_DIR")
 TOKEN = os.getenv("TOKEN")
@@ -48,19 +49,19 @@ async def register_instance(request: Request):
 async def get_file_structure():
     return  load_balancer.file_structure
 
-@app.get("/api/get/film/store")
-async def get_film_store():
+@app.get("/api/get/movie/store")
+async def get_movie_store():
     return  load_balancer.FILM_STORE
 
-@app.get("/api/get/tv/store")
-async def get_tv_store():
+@app.get("/api/get/series/store")
+async def get_series_store():
     return  load_balancer.TV_STORE
 
-@app.get("/api/get/film/all")
-async def get_all_films_api():
+@app.get("/api/get/movie/all")
+async def get_all_movies_api():
     return load_balancer.get_all_films()
 
-@app.get("/api/get/tv/all")
+@app.get("/api/get/series/all")
 async def get_all_tvshows_api():
     return load_balancer.get_all_tv_shows()
 
@@ -76,17 +77,43 @@ async def get_recent_items(limit: int = 5):
 
     # Return combined results
     return JSONResponse(content={
-        'films': limited_films,
+        'movies': limited_films,
         'series': limited_series
     })
 
-@app.get("/api/get/film/metadata/{title}")
-async def get_film_metadata_api(title: str):
-    """Endpoint to get the film metadata by title."""
+@app.get("/api/get/genre")
+async def get_genre_items(genre: str, media_type: Optional[str] = None, limit: int = 5):
+    """
+    Get recent items from a specified genre with an optional media type filter and a limit on the number of results.
+
+    :param genre: The genre 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.
+    :return: A JSON response containing the filtered items.
+    """
+    # Get sorted entries based on genre and media type
+    entries = genre_list.get_sorted_entries(genre, media_type=media_type)
+
+    # Slice the list to only return the desired number of items
+    limited_entries = entries[:limit]
+
+    # Organize the results by media type
+    results = {
+        'movies': [entry for entry in limited_entries if entry[4] == 'movie'],
+        'series': [entry for entry in limited_entries if entry[4] == '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")
     
-    json_cache_path = os.path.join(CACHE_DIR, f"{urllib.parse.quote(title)}.json")
+    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)
@@ -94,17 +121,39 @@ async def get_film_metadata_api(title: str):
     
     raise HTTPException(status_code=404, detail="Metadata not found")
 
-@app.get("/api/get/tv/metadata/{title}")
-async def get_tv_metadata_api(title: str):
-    """Endpoint to get the TV show metadata by title."""
+@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")
     
-    json_cache_path = os.path.join(CACHE_DIR, f"{urllib.parse.quote(title)}.json")
+    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
+        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, 'year': year, 'image': image})
+    
+    raise HTTPException(status_code=404, detail="Card not found")
+
+@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:
@@ -114,8 +163,30 @@ async def get_tv_metadata_api(title: str):
     
     raise HTTPException(status_code=404, detail="Metadata not found")
 
+@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, 'year': year, 'image': image})
+    
+    raise HTTPException(status_code=404, detail="Card not found")
+
 
-@app.get("/api/get/tv/metadata/{series_id}/{season}")
+@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:
@@ -139,13 +210,13 @@ async def get_instances():
 async def get_instances_health():
     return load_balancer.instances_health
 
-@app.get("/api/get/film/{title}")
+@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")
     
-    # Check if the film is already cached
+    # Check if the movie is already cached
     if title in load_balancer.FILM_STORE:
         url = load_balancer.FILM_STORE[title]
         return JSONResponse(content={"url": url})
@@ -160,7 +231,7 @@ async def get_movie_api(title: str):
     if response:
         return JSONResponse(content=response)
 
-@app.get("/api/get/tv/{title}/{season}/{episode}")
+@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:

services.py

@@ -44,22 +44,94 @@ class RecentList:
             # Get sorted series with details
             return [(title, -year, self.series[title][1], self.series[title][2]) for year, title in self.sorted_series]
 
-# Example usage:
-if __name__ == "__main__":
-    media_list = RecentList()
+class GenreList:
+    def __init__(self):
+        # Initialize a dictionary to store genres and their associated data
+        self.genres = {}
 
-    # Adding entries
-    media_list.add_entry("Film A", 2022, "Description A", "http://link-to-image-a.com", 'film')
-    media_list.add_entry("Series A", 2023, "Description B", "http://link-to-image-b.com", 'series')
-    media_list.add_entry("Film B", 2021, "Description C", "http://link-to-image-c.com", 'film')
-    media_list.add_entry("Film A", 2024, "Updated Description A", "http://updated-link-to-image-a.com", 'film')  # Updating the year of "Film A"
-    media_list.add_entry("Series B", 2021, "Description D", "http://link-to-image-d.com", 'series')
+    def add_entry(self, genres, title, year, description, image_link, media_type):
+        """
+        Add an entry to multiple genres.
 
-    # Retrieving and printing sorted entries
-    print("Sorted Films:")
-    for title, year, description, image_link in media_list.get_sorted_entries('film'):
-        print(f"Title: {title}, Year: {year}, Description: {description}, Image Link: {image_link}")
+        :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)
 
-    print("\nSorted Series:")
-    for title, year, description, image_link in media_list.get_sorted_entries('series'):
-        print(f"Title: {title}, Year: {year}, Description: {description}, Image Link: {image_link}")
+    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 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"}
+# ]
+# genre_list.add_entry(genres, 'Movie Title', 2023, 'Description here', 'image_link_here', 'movie')
+# genre_list.add_entry(genres, 'Series Title', 2022, 'Series Description', 'series_image_link_here', 'series')
+# sorted_comedy_movies = genre_list.get_sorted_entries('Comedy', media_type='movie')
+# sorted_comedy_series = genre_list.get_sorted_entries('Comedy')
+# print(sorted_comedy_movies)
+# print(sorted_comedy_series)

tvdb.py

@@ -8,7 +8,7 @@ import json
 import asyncio
 import aiofiles
 from tvdbApiClient import fetch_and_cache_seasons, save_to_json
-from services import RecentList
+from services import RecentList, GenreList
 
 load_dotenv()
 THETVDB_API_KEY = os.getenv("THETVDB_API_KEY")
@@ -17,6 +17,7 @@ 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
@@ -59,6 +60,7 @@ def clean_data(data):
             'originalLanguage': None,
             'translations': {},
             'artworks': [],
+            'genres':[],
             'characters': [],
             'spoken_languages': [],
             'translations': {}
@@ -126,6 +128,11 @@ async def fetch_and_cache_json(original_title, title, media_type, year=None):
             
             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'):
@@ -145,11 +152,18 @@ async def fetch_and_cache_json(original_title, title, media_type, year=None):
             
             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}")
             
-            json_cache_path = os.path.join(CACHE_DIR, f"{urllib.parse.quote(original_title)}.json")
+            # 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:

tvdbApiClient.py

@@ -3,7 +3,7 @@ import os
 import logging
 from pathlib import Path
 import tvdb_v4_official
-import aiofiles
+from utils import save_to_json
 
 THETVDB_API_KEY = os.getenv("THETVDB_API_KEY")
 CACHE_DIR = os.getenv("CACHE_DIR")
@@ -42,14 +42,7 @@ def filter_episode_data(episode):
         "year": episode.get("year")
     }
 
-async def save_to_json(data, path):
-    """Save data to a JSON file asynchronously."""
-    try:
-        async with aiofiles.open(path, 'w', encoding='utf-8') as f:
-            await f.write(json.dumps(data, indent=4, ensure_ascii=False))
-        logging.info(f"Data saved to {path}")
-    except IOError as e:
-        logging.error(f"Error saving data to {path}: {e}")
+
 
 async def fetch_and_cache_seasons(series_id):
     """Fetch and cache episodes for a given series ID asynchronously."""

utils.py

@@ -1,6 +1,7 @@
 import re
 import aiofiles
 import json
+import logging
 
 def is_valid_url(url):
     """
@@ -72,4 +73,21 @@ async def read_json_file(file_path: str):
             data = await f.read()
         return json.loads(data)
     except Exception as e:
-        raise e
+        raise e
+    
+async def read_json_file(file_path):
+    try:
+        async with aiofiles.open(file_path, 'r', encoding='utf-8') as f:
+            data = await f.read()
+        return json.loads(data)
+    except Exception as e:
+        raise e
+
+async def save_to_json(data, path):
+    """Save data to a JSON file asynchronously."""
+    try:
+        async with aiofiles.open(path, 'w', encoding='utf-8') as f:
+            await f.write(json.dumps(data, indent=4, ensure_ascii=False))
+        logging.info(f"Data saved to {path}")
+    except IOError as e:
+        logging.error(f"Error saving data to {path}: {e}")