add recent

app.py

@@ -5,6 +5,7 @@ import logging
 import os
 import urllib.parse
 from utils import read_json_file, is_valid_url
+from tvdb import recent_list
 
 CACHE_DIR = os.getenv("CACHE_DIR")
 TOKEN = os.getenv("TOKEN")
@@ -15,6 +16,7 @@ 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("/")
@@ -62,6 +64,14 @@ async def get_all_films_api():
 async def get_all_tvshows_api():
     return load_balancer.get_all_tv_shows()
 
+@app.get("/api/get/film/recent")
+async def get_recent_films():
+    return  recent_list.get_sorted_entries('film')
+
+@app.get("/api/get/tv/recent")
+async def get_recent_shows():
+    return  recent_list.get_sorted_entries('series')
+
 @app.get("/api/get/film/metadata/{title}")
 async def get_film_metadata_api(title: str):
     """Endpoint to get the film metadata by title."""

indexer.py

@@ -1,6 +1,7 @@
 from hf_scrapper import get_file_structure
 from dotenv import load_dotenv
 import os
+import json
 
 load_dotenv()
 
@@ -19,7 +20,7 @@ def index_repository(token, repo, current_path=""):
             file_item = {
                 "type": item['type'],
                 "size": item['size'],
-                "path": item['path']
+                "path": item['path'],
             }
             full_structure.append(file_item)
     return full_structure
@@ -31,4 +32,14 @@ def indexer():
     print(f"Full file structure for repository '{repo}' has been indexed.")
     return full_structure
 
-indexer()
+if __name__ == '__main__':
+    files = indexer()
+    
+    # Define the output file name based on the repository name
+    output_file = f"{os.getenv('CACHE_DIR')}file_structure.json"
+    
+    # Save the structure to a JSON file
+    with open(output_file, 'w') as f:
+        json.dump(files, f, indent=4)
+    
+    print(f"File structure saved to {output_file}")

services.py

@@ -0,0 +1,67 @@
+import bisect
+
+class RecentList:
+    def __init__(self):
+        # Initialize dictionaries to store titles and years
+        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, media_type):
+        if media_type == 'film':
+            self._update_entry(self.films, self.sorted_films, title, year)
+        
+        elif media_type == 'series':
+            self._update_entry(self.series, self.sorted_series, title, year)
+    
+    def _update_entry(self, dictionary, sorted_list, title, year):
+        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 year from the sorted list if it exists
+            old_year = dictionary[title]
+            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
+        
+        # Insert the new year into the sorted list
+        bisect.insort(sorted_list, (-year, title))
+
+    def get_sorted_entries(self, media_type):
+        if media_type == 'film':
+            # Convert sorted list back to the correct format with positive years
+            return [ (title, -year) for year, title in self.sorted_films ]
+        
+        elif media_type == 'series':
+            # Convert sorted list back to the correct format with positive years
+            return [ (title, -year) for year, title in self.sorted_series ]
+
+# Example usage:
+if __name__ == "__main__":
+    media_list = RecentList()
+
+    # Adding entries
+    media_list.add_entry("Film A", 2022, 'film')
+    media_list.add_entry("Series A", 2023, 'series')
+    media_list.add_entry("Film B", 2021, 'film')
+    media_list.add_entry("Film A", 2024, 'film')  # Updating the year of "Film A"
+    media_list.add_entry("Series B", 2021, 'series')
+
+    # Retrieving and printing sorted entries
+    print("Sorted Films:")
+    for title, year in media_list.get_sorted_entries('film'):
+        print(f"Title: {title}, Year: {year}")
+
+    print("\nSorted Series:")
+    for title, year in media_list.get_sorted_entries('series'):
+        print(f"Title: {title}, Year: {year}")

tvdb.py

@@ -8,6 +8,7 @@ import json
 import asyncio
 import aiofiles
 from tvdbApiClient import fetch_and_cache_seasons, save_to_json
+from services import RecentList
 
 load_dotenv()
 THETVDB_API_KEY = os.getenv("THETVDB_API_KEY")
@@ -15,6 +16,7 @@ THETVDB_API_URL = os.getenv("THETVDB_API_URL")
 CACHE_DIR = os.getenv("CACHE_DIR")
 TOKEN_EXPIRY = None
 THETVDB_TOKEN = None
+recent_list = RecentList()
 
 def authenticate_thetvdb():
     global THETVDB_TOKEN, TOKEN_EXPIRY
@@ -39,6 +41,38 @@ def get_thetvdb_token():
         authenticate_thetvdb()
     return THETVDB_TOKEN
 
+def clean_data(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': [],
+        'characters': [],
+        'spoken_languages': [],
+        'translations': {}
+    }
+}
+    """Clean up the data to retain only necessary fields."""
+    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]
+    
+    return cleaned_data
+
 async def fetch_and_cache_json(original_title, title, media_type, year=None):
     if year:
         search_url = f"{THETVDB_API_URL}/search?query={urllib.parse.quote(title)}&type={media_type}&year={year}"
@@ -76,7 +110,7 @@ async def fetch_and_cache_json(original_title, title, media_type, year=None):
                 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)  # Using await for the async function
+                await fetch_and_cache_seasons(tvdb_id)
             else:
                 print(f"Unsupported media type: {media_type}")
                 return
@@ -85,10 +119,14 @@ async def fetch_and_cache_json(original_title, title, media_type, year=None):
             response = requests.get(extended_url, headers=headers)
             response.raise_for_status()
             extended_data = response.json()
-            
+            cleaned_data=clean_data(extended_data)
+            if media_type == 'movie':
+                recent_list.add_entry(original_title, cleaned_data['data']['year'], 'film')
+            elif media_type == 'series':
+                recent_list.add_entry(original_title,  cleaned_data['data']['year'], 'series')
             # Cache the extended JSON response
             json_cache_path = os.path.join(CACHE_DIR, f"{urllib.parse.quote(original_title)}.json")
-            await save_to_json(extended_data, json_cache_path)
+            await save_to_json(cleaned_data, json_cache_path)
                 
     except requests.RequestException as e:
         print(f"Error fetching data: {e}")