StreamingCommunity 2.5.7__py3-none-any.whl → 2.5.8__py3-none-any.whl

StreamingCommunity/Lib/FFmpeg/command.py

@@ -3,7 +3,7 @@
 import sys
 import logging
 import subprocess
-from typing import List, Dict
+from typing import List, Dict, Tuple, Optional
 
 
 # Internal utilities
@@ -34,6 +34,62 @@ USE_LARGE_BAR = not ("android" in sys.platform or "ios" in sys.platform)
 FFMPEG_PATH = os_summary.ffmpeg_path
 
 
+
+def check_subtitle_encoders() -> Tuple[Optional[bool], Optional[bool]]:
+    """
+    Executes 'ffmpeg -encoders' and checks if 'mov_text' and 'webvtt' encoders are available.
+    
+    Returns:
+        Tuple[Optional[bool], Optional[bool]]: A tuple containing (mov_text_supported, webvtt_supported)
+            Returns (None, None) if the FFmpeg command fails
+    """
+    try:
+        result = subprocess.run(
+            [FFMPEG_PATH, '-encoders'],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        
+        # Check for encoder presence in output
+        output = result.stdout
+        mov_text_supported = "mov_text" in output
+        webvtt_supported = "webvtt" in output
+        
+        return mov_text_supported, webvtt_supported
+        
+    except subprocess.CalledProcessError as e:
+        print(f"Error executing 'ffmpeg -encoders': {e}")
+        return None, None
+
+
+def select_subtitle_encoder() -> Optional[str]:
+    """
+    Determines the best available subtitle encoder to use.
+    Prefers mov_text over webvtt if both are available.
+ 
+    Returns:
+        Optional[str]: Name of the best available encoder ('mov_text' or 'webvtt')
+            or None if no supported encoder is found
+    """
+    mov_text_supported, webvtt_supported = check_subtitle_encoders()
+    
+    # Return early if check failed
+    if mov_text_supported is None:
+        return None
+        
+    # Prioritize mov_text over webvtt
+    if mov_text_supported:
+        logging.info("Using 'mov_text' as the subtitle encoder.")
+        return "mov_text"
+    elif webvtt_supported:
+        logging.info("Using 'webvtt' as the subtitle encoder.")
+        return "webvtt"
+    
+    logging.error("No supported subtitle encoder found.")
+    return None
+
+
 def join_video(video_path: str, out_path: str, codec: M3U8_Codec = None):
     """
     Joins single ts video file to mp4
@@ -238,9 +294,9 @@ def join_subtitle(video_path: str, subtitles_list: List[Dict[str, str]], out_pat
 
     # Add output Parameters
     if USE_CODEC:
-        ffmpeg_cmd.extend(['-c:v', 'copy', '-c:a', 'copy', '-c:s', 'mov_text'])
+        ffmpeg_cmd.extend(['-c:v', 'copy', '-c:a', 'copy', '-c:s', select_subtitle_encoder()])
     else:
-        ffmpeg_cmd.extend(['-c', 'copy', '-c:s', 'mov_text'])
+        ffmpeg_cmd.extend(['-c', 'copy', '-c:s', select_subtitle_encoder()])
 
     # Overwrite
     ffmpeg_cmd += [out_path, "-y"]

StreamingCommunity/Lib/M3U8/estimator.py

@@ -127,16 +127,16 @@ class M3U8_Ts_Estimator:
                 retry_count = self.segments_instance.active_retries if self.segments_instance else 0
                 progress_str = (
                     #f"{Colors.WHITE}[ {Colors.GREEN}{number_file_downloaded} {Colors.WHITE}< "
-                    f"{Colors.GREEN}{number_file_total_size} {Colors.RED}{units_file_total_size} "
-                    f"{Colors.WHITE}| {Colors.CYAN}{average_internet_speed} {Colors.RED}{average_internet_unit} "
-                    f"{Colors.WHITE}| {Colors.GREEN}CRR {Colors.RED}{retry_count}"
+                    f"{Colors.GREEN}{number_file_total_size} {Colors.RED}{units_file_total_size}"
+                    f"{Colors.WHITE} {Colors.CYAN}{average_internet_speed} {Colors.RED}{average_internet_unit}"
+                    f"{Colors.WHITE} {Colors.GREEN}CRR {Colors.RED}{retry_count} "
                 )
             else:
                 retry_count = self.segments_instance.active_retries if self.segments_instance else 0
                 progress_str = (
                     #f"{Colors.WHITE}[ {Colors.GREEN}{number_file_downloaded} {Colors.WHITE}< "
-                    f"{Colors.GREEN}{number_file_total_size} {Colors.RED}{units_file_total_size} "
-                    f"{Colors.WHITE}| {Colors.GREEN}CRR {Colors.RED}{retry_count}"
+                    f"{Colors.GREEN}{number_file_total_size} {Colors.RED}{units_file_total_size}"
+                    f"{Colors.WHITE} {Colors.GREEN}CRR {Colors.RED}{retry_count} "
                 )
             
             progress_counter.set_postfix_str(progress_str)

StreamingCommunity/Lib/M3U8/parser.py

@@ -39,12 +39,17 @@ CODEC_MAPPINGS = {
 }
     
 RESOLUTIONS = [
-    (7680, 4320),
-    (3840, 2160),
-    (2560, 1440),
-    (1920, 1080),
-    (1280, 720),
-    (640, 480)
+    (7680, 4320),  # 8K
+    (3840, 2160),  # 4K
+    (2560, 1440),  # 1440p
+    (1920, 1080),  # 1080p
+    (1280, 720),   # 720p
+    (640, 480),    # VGA
+    (640, 360),    # 360p
+    (480, 320),    # HVGA
+    (426, 240),    # 240p
+    (320, 240),    # QVGA
+    (256, 144),    # 144p
 ]
 
 
@@ -377,47 +382,6 @@ class M3U8_Subtitle:
                 return subtitle
         return None
 
-    def download_all(self, custom_subtitle):
-        """
-        Download all subtitles listed in the object's attributes, filtering based on a provided list of custom subtitles.
-
-        Parameters:
-            - custom_subtitle (list): A list of custom subtitles to download.
-
-        Returns:
-            list: A list containing dictionaries with subtitle information including name, language, and URI.
-        """
-            
-        output = []  # Initialize an empty list to store subtitle information
-
-        # Iterate through all available subtitles
-        for obj_subtitle in self.subtitle_get_all_uris_and_names():
-
-            # Check if the subtitle name is not in the list of custom subtitles, and skip if not found
-            if obj_subtitle.get('name') not in custom_subtitle:
-                continue
-
-            # Send a request to retrieve the subtitle content
-            logging.info(f"Download subtitle: {obj_subtitle.get('name')}")
-            response_subitle = httpx.get(obj_subtitle.get('uri'))
-
-            try:
-                # Try to extract the VTT URL from the subtitle content
-                sub_parse = M3U8_Parser()
-                sub_parse.parse_data(obj_subtitle.get('uri'), response_subitle.text)
-                url_subititle = sub_parse.subtitle[0]
-
-                output.append({
-                    'name': obj_subtitle.get('name'),
-                    'language': obj_subtitle.get('language'),
-                    'uri': url_subititle
-                })
-
-            except Exception as e:
-                logging.error(f"Cant download: {obj_subtitle.get('name')}, error: {e}")
-
-        return output
-
 
 class M3U8_Parser:
     def __init__(self):
@@ -555,7 +519,6 @@ class M3U8_Parser:
             - m3u8_obj: The M3U8 object containing encryption keys.
         """
         try:
-
             if m3u8_obj.key is not None:
                 if self.keys is None:
                     self.keys = {
@@ -564,7 +527,6 @@ class M3U8_Parser:
                         'uri': m3u8_obj.key.uri
                     }
 
-
         except Exception as e:
             logging.error(f"Error parsing encryption keys: {e}")
             sys.exit(0)
@@ -629,7 +591,6 @@ class M3U8_Parser:
         """
         Initialize variables for video, audio, and subtitle playlists.
         """
-
         self._video = M3U8_Video(self.video_playlist)
         self._audio = M3U8_Audio(self.audio_playlist)
         self._subtitle = M3U8_Subtitle(self.subtitle_playlist)
@@ -663,4 +624,4 @@ class M3U8_Parser:
         if return_string:
             return f"[yellow]{int(hours)}[red]h [yellow]{int(minutes)}[red]m [yellow]{int(seconds)}[red]s"
         else:
-            return {'h': int(hours), 'm': int(minutes), 's': int(seconds)}
+            return {'h': int(hours), 'm': int(minutes), 's': int(seconds)}

StreamingCommunity/Lib/TMBD/tmdb.py

@@ -6,17 +6,19 @@ from typing import Dict
 
 # External libraries
 import httpx
-from rich.console import Console
 
 
 # Internal utilities
 from .obj_tmbd import Json_film
+from StreamingCommunity.Util.console import console
+from StreamingCommunity.Util._jsonConfig import config_manager
 from StreamingCommunity.Util.table import TVShowManager
 
 
 # Variable
 table_show_manager = TVShowManager()
 api_key = "a800ed6c93274fb857ea61bd9e7256c5"
+MAX_TIMEOUT = config_manager.get_int("REQUESTS", "timeout")
 
 
 
@@ -33,7 +35,7 @@ def get_select_title(table_show_manager, generic_obj):
 
     # Check if the generic_obj list is empty
     if not generic_obj:
-        Console.print("\n[red]No media items available.")
+        console.print("\n[red]No media items available.")
         return None
     
     # Example of available colors for columns
@@ -76,7 +78,7 @@ def get_select_title(table_show_manager, generic_obj):
 
     # Handle user's quit command
     if last_command == "q" or last_command == "quit":
-        Console.print("\n[red]Quit [white]...")
+        console.print("\n[red]Quit [white]...")
         sys.exit(0)
 
     # Check if the selected index is within range
@@ -84,7 +86,7 @@ def get_select_title(table_show_manager, generic_obj):
         return generic_obj[int(last_command)]
     
     else:
-        Console.print("\n[red]Wrong index")
+        console.print("\n[red]Wrong index")
         sys.exit(0)
 
 
@@ -98,8 +100,9 @@ class TheMovieDB:
         """
         self.api_key = api_key
         self.base_url = "https://api.themoviedb.org/3"
-        self.console = Console()
         #self.genres = self._fetch_genres()
+        self._cached_trending_tv = None
+        self._cached_trending_movies = None
 
     def _make_request(self, endpoint, params=None):
         """
@@ -117,7 +120,7 @@ class TheMovieDB:
 
         params['api_key'] = self.api_key
         url = f"{self.base_url}/{endpoint}"
-        response = httpx.get(url, params=params)
+        response = httpx.get(url, params=params, timeout=MAX_TIMEOUT)
         response.raise_for_status()
         
         return response.json()
@@ -132,78 +135,66 @@ class TheMovieDB:
         genres = self._make_request("genre/movie/list")
         return {genre['id']: genre['name'] for genre in genres.get('genres', [])}
 
-    def _process_and_add_tv_shows(self, data, columns):
+    def _display_top_5(self, category: str, data, name_key='title'):
         """
-        Process TV show data and add it to the TV show manager.
+        Display top 5 most popular items in a single line with colors.
         
         Parameters:
-            - data (list): List of dictionaries containing the data to process.
-            - columns (list): A list of tuples, where each tuple contains the column name and the key to fetch the data from the dictionary.
+            - category (str): Category label (e.g., "Trending films", "Trending TV shows")
+            - data (list): List of media items
+            - name_key (str): Key to use for the name ('title' for movies, 'name' for TV shows)
         """
-        # Define column styles with colors
-        tv_show_manager = TVShowManager()
-        column_info = {
-            col[0]: {'color': col[2] if len(col) > 2 else 'white'}
-            for col in columns
-        }
-        tv_show_manager.add_column(column_info)
-
-        # Add each item to the TV show manager, including rank
-        for index, item in enumerate(data):
-            
-            # Convert genre IDs to genre names
-            genre_names = [self.genres.get(genre_id, 'Unknown') for genre_id in item.get('genre_ids', [])]
-            tv_show = {
-                col[0]: str(item.get(col[1], 'N/A')) if col[1] != 'genre_ids' else ', '.join(genre_names)
-                for col in columns
-            }
-
-            tv_show_manager.add_tv_show(tv_show)
+        # Colors for the titles
+        colors = ['cyan', 'magenta', 'yellow', 'green', 'blue']
         
-        # Display the processed TV show data
-        tv_show_manager.display_data(tv_show_manager.tv_shows[tv_show_manager.slice_start:tv_show_manager.slice_end])
+        # Sort by popularity and get top 5
+        sorted_data = sorted(data, key=lambda x: x.get('popularity', 0), reverse=True)[:5]
+        
+        # Create list of colored titles
+        colored_items = []
+        for item, color in zip(sorted_data, colors):
+            title = item.get(name_key, 'Unknown')
+            colored_items.append(f"[{color}]{title}[/]")
+        
+        # Join with colored arrows and print with proper category label
+        console.print(
+            f"[bold purple]{category}:[/] {' [red]→[/] '.join(colored_items)}"
+        )
 
-    def _display_with_title(self, title: str, data, columns):
+    def display_trending_tv_shows(self):
         """
-        Display data with a title.
-
-        Parameters:
-            - title (str): The title to display.
-            - data (list): List of dictionaries containing the data to process.
-            - columns (list): A list of tuples, where each tuple contains the column name and the key to fetch the data from the dictionary.
+        Fetch and display the top 5 trending TV shows of the week.
+        Uses cached data if available, otherwise makes a new request.
         """
-        self.console.print(f"\n{title}", style="bold underline")
-        self._process_and_add_tv_shows(data, columns)
+        if self._cached_trending_tv is None:
+            self._cached_trending_tv = self._make_request("trending/tv/week").get("results", [])
+        
+        self._display_top_5("Trending TV shows", self._cached_trending_tv, name_key='name')
 
-    def display_trending_tv_shows(self):
+    def refresh_trending_tv_shows(self):
         """
-        Fetch and display the trending TV shows of the week.
+        Force a refresh of the trending TV shows cache.
         """
-        data = self._make_request("trending/tv/week").get("results", [])
-        columns = [
-            ("Title", "name", 'cyan'), 
-            ("First Air Date", "first_air_date", 'green'), 
-            ("Popularity", "popularity", 'magenta'),
-            ("Genres", "genre_ids", 'blue'),
-            ("Origin Country", "origin_country", 'red'),
-            ("Vote Average", "vote_average", 'yellow')
-        ]
-        self._display_with_title("Trending TV Shows of the Week", data, columns)
+        self._cached_trending_tv = self._make_request("trending/tv/week").get("results", [])
+        return self._cached_trending_tv
 
     def display_trending_films(self):
         """
-        Fetch and display the trending films of the week.
+        Fetch and display the top 5 trending films of the week.
+        Uses cached data if available, otherwise makes a new request.
         """
-        data = self._make_request("trending/movie/week").get("results", [])
-        columns = [
-            ("Title", "title", 'cyan'), 
-            ("Release Date", "release_date", 'green'), 
-            ("Popularity", "popularity", 'magenta'),
-            ("Genres", "genre_ids", 'blue'),
-            ("Vote Average", "vote_average", 'yellow')
-        ]
-        self._display_with_title("Trending Films of the Week", data, columns)
+        if self._cached_trending_movies is None:
+            self._cached_trending_movies = self._make_request("trending/movie/week").get("results", [])
+        
+        self._display_top_5("Trending films", self._cached_trending_movies, name_key='title')
 
+    def refresh_trending_films(self):
+        """
+        Force a refresh of the trending films cache.
+        """
+        self._cached_trending_movies = self._make_request("trending/movie/week").get("results", [])
+        return self._cached_trending_movies
+      
     def search_movie(self, movie_name: str):
         """
         Search for a movie by name and return its TMDB ID.
@@ -217,10 +208,10 @@ class TheMovieDB:
         generic_obj = []
         data = self._make_request("search/movie", {"query": movie_name}).get("results", [])
         if not data:
-            self.console.print("No movies found with that name.", style="red")
+            console.print("No movies found with that name.", style="red")
             return None
 
-        self.console.print("\nSelect a Movie:")
+        console.print("\nSelect a Movie:")
         for i, movie in enumerate(data, start=1):
             generic_obj.append({
                 'name': movie['title'],
@@ -243,7 +234,7 @@ class TheMovieDB:
         """
         movie = self._make_request(f"movie/{tmdb_id}")
         if not movie:
-            self.console.print("Movie not found.", style="red")
+            console.print("Movie not found.", style="red")
             return None
         
         return Json_film(movie)
@@ -260,12 +251,12 @@ class TheMovieDB:
         """
         data = self._make_request("search/tv", {"query": tv_name}).get("results", [])
         if not data:
-            self.console.print("No TV shows found with that name.", style="red")
+            console.print("No TV shows found with that name.", style="red")
             return None
 
-        self.console.print("\nSelect a TV Show:")
+        console.print("\nSelect a TV Show:")
         for i, show in enumerate(data, start=1):
-            self.console.print(f"{i}. {show['name']} (First Air Date: {show.get('first_air_date', 'N/A')})")
+            console.print(f"{i}. {show['name']} (First Air Date: {show.get('first_air_date', 'N/A')})")
 
         choice = int(input("Enter the number of the show you want: ")) - 1
         selected_show = data[choice]
@@ -283,12 +274,12 @@ class TheMovieDB:
         """
         data = self._make_request(f"tv/{tv_show_id}").get("seasons", [])
         if not data:
-            self.console.print("No seasons found for this TV show.", style="red")
+            console.print("No seasons found for this TV show.", style="red")
             return None
 
-        self.console.print("\nSelect a Season:")
+        console.print("\nSelect a Season:")
         for i, season in enumerate(data, start=1):
-            self.console.print(f"{i}. {season['name']} (Episodes: {season['episode_count']})")
+            console.print(f"{i}. {season['name']} (Episodes: {season['episode_count']})")
 
         choice = int(input("Enter the number of the season you want: ")) - 1
         return data[choice]["season_number"]
@@ -306,12 +297,12 @@ class TheMovieDB:
         """
         data = self._make_request(f"tv/{tv_show_id}/season/{season_number}").get("episodes", [])
         if not data:
-            self.console.print("No episodes found for this season.", style="red")
+            console.print("No episodes found for this season.", style="red")
             return None
 
-        self.console.print("\nSelect an Episode:")
+        console.print("\nSelect an Episode:")
         for i, episode in enumerate(data, start=1):
-            self.console.print(f"{i}. {episode['name']} (Air Date: {episode.get('air_date', 'N/A')})")
+            console.print(f"{i}. {episode['name']} (Air Date: {episode.get('air_date', 'N/A')})")
 
         choice = int(input("Enter the number of the episode you want: ")) - 1
         return data[choice]
@@ -319,28 +310,4 @@ class TheMovieDB:
 
 
 # Output
-tmdb = TheMovieDB(api_key)
-
-
-"""
-Example:
-
-
-@ movie
-movie_name = "Interstellar"
-movie_id = tmdb.search_movie(movie_name)
-
-if movie_id:
-    movie_details = tmdb.get_movie_details(tmdb_id=movie_id)
-    print(movie_details)
-
-
-@ series
-tv_name = "Game of Thrones"
-tv_show_id = tmdb.search_tv_show(tv_name)
-if tv_show_id:
-    season_number = tmdb.get_seasons(tv_show_id=tv_show_id)
-    if season_number:
-        episode = tmdb.get_episodes(tv_show_id=tv_show_id, season_number=season_number)
-        print(episode)
-"""
+tmdb = TheMovieDB(api_key)