StreamingCommunity 3.3.5__py3-none-any.whl → 3.3.6__py3-none-any.whl

StreamingCommunity/Api/Site/mediasetinfinity/util/ScrapeSerie.py

@@ -5,16 +5,15 @@ from urllib.parse import urlparse
 
 
 # External libraries
-from curl_cffi import requests
+import httpx
 from bs4 import BeautifulSoup
 
 
 # Internal utilities
-from StreamingCommunity.Util.headers import get_headers, get_userAgent
 from StreamingCommunity.Util.config_json import config_manager
+from StreamingCommunity.Util.headers import get_headers, get_userAgent
 from StreamingCommunity.Api.Player.Helper.Vixcloud.util import SeasonManager
 
-
 # Variable
 max_timeout = config_manager.get_int("REQUESTS", "timeout")
 
@@ -36,58 +35,26 @@ class GetSerieInfo:
         self.stagioni_disponibili = []
 
     def _extract_serie_id(self):
-        """Estrae l'ID della serie dall'URL di partenza"""
+        """Extract the series ID from the starting URL"""
         self.serie_id = f"SE{self.url.split('SE')[1]}"
-        print(f"Serie ID: {self.serie_id}")
         return self.serie_id
 
     def _get_public_id(self):
+        """Get the public ID for API calls"""
         self.public_id = "PR1GhC"
         return self.public_id
-        
-        """
-        bearer_token = get_bearer_token()
-        headers = {
-            'authorization': f'Bearer {bearer_token}',
-            'user-agent': get_userAgent(),
-        }
-
-        response = requests.get(
-            'https://api-ott-prod-fe.mediaset.net/PROD/play/userlist/watchlist/v2.0',
-            headers=headers,
-            impersonate="chrome",
-            allow_redirects=True
-        )
-
-        if response.status_code == 401:
-            print("Token scaduto, rinnovare il token")
-
-        if response.status_code == 200:
-            data = response.json()
-            self.public_id = data['response']['entries'][0]['media'][0]['publicUrl'].split("/")[4]
-            print(f"Public id: {self.public_id}")
-            return self.public_id
-        
-        else:
-            logging.error(f"Failed to get public ID: {response.status_code}")
-            return None
-        """
 
     def _get_series_data(self):
-        """Ottiene i dati della serie tramite l'API"""
-        headers = {
-            'User-Agent': get_userAgent(),
-        }
+        """Get series data through the API"""
+        headers = {'User-Agent': get_userAgent()}
         params = {'byGuid': self.serie_id}
 
-        response = requests.get(
-            f'https://feed.entertainment.tv.theplatform.eu/f/{self.public_id}/mediaset-prod-all-series-v2',
-            params=params,
-            headers=headers,
-            impersonate="chrome",
-            allow_redirects=True
-        )
-        print("Risposta per _get_series_data:", response.status_code)
+        with httpx.Client(timeout=max_timeout, follow_redirects=True) as client:
+            response = client.get(
+                f'https://feed.entertainment.tv.theplatform.eu/f/{self.public_id}/mediaset-prod-all-series-v2',
+                params=params,
+                headers=headers
+            )
 
         if response.status_code == 200:
             return response.json()
@@ -96,7 +63,7 @@ class GetSerieInfo:
             return None
 
     def _process_available_seasons(self, data):
-        """Processa le stagioni disponibili dai dati della serie"""
+        """Process available seasons from series data"""
         if not data or not data.get('entries'):
             logging.error("No series data found")
             return []
@@ -118,16 +85,17 @@ class GetSerieInfo:
                     'id': str(url).split("/")[-1],
                     'guid': season['guid']
                 })
+                
             else:
                 logging.warning(f"Season URL not found: {url}")
 
-        # Ordina le stagioni dalla più vecchia alla più nuova
+        # Sort seasons from oldest to newest
         stagioni_disponibili.sort(key=lambda s: s['tvSeasonNumber'])
         
         return stagioni_disponibili
 
     def _build_season_page_urls(self, stagioni_disponibili):
-        """Costruisce gli URL delle pagine delle stagioni"""
+        """Build season page URLs"""
         parsed_url = urlparse(self.url)
         base_url = f"{parsed_url.scheme}://{parsed_url.netloc}"
         series_slug = parsed_url.path.strip('/').split('/')[-1].split('_')[0]
@@ -137,39 +105,36 @@ class GetSerieInfo:
             season['page_url'] = page_url
 
     def _extract_season_sb_ids(self, stagioni_disponibili):
-        """Estrae gli ID sb dalle pagine delle stagioni"""
-        for season in stagioni_disponibili:
-            response_page = requests.get(
-                season['page_url'],
-                headers={'User-Agent': get_userAgent()},
-                impersonate="chrome",
-                allow_redirects=True
-            )
-            print("Risposta per _extract_season_sb_ids:", response_page.status_code)
-
-            soup = BeautifulSoup(response_page.text, 'html.parser')
-            
-            # Prova prima con 'Episodi', poi con 'Puntate intere'
-            link = soup.find('a', string='Episodi')
-            if not link:
-                print("Using word: Puntate intere")
-                link = soup.find('a', string='Puntate intere')
-            
-            if link and link.has_attr('href'):
-                if not link.string == 'Puntate intere':
-                    print("Using word: Episodi")
-                season['sb'] = link['href'].split(',')[-1]
-            else:
-                logging.warning(f"Link 'Episodi' o 'Puntate intere' non trovato per stagione {season['tvSeasonNumber']}")
+        """Extract sb IDs from season pages"""
+        with httpx.Client(timeout=max_timeout, follow_redirects=True) as client:
+            for season in stagioni_disponibili:
+                response_page = client.get(
+                    season['page_url'],
+                    headers={'User-Agent': get_userAgent()}
+                )
+                print("Response for _extract_season_sb_ids:", response_page.status_code, " season index:", season['tvSeasonNumber'])
+
+                soup = BeautifulSoup(response_page.text, 'html.parser')
+                
+                # Try first with 'Episodi', then with 'Puntate intere'
+                link = soup.find('a', string='Episodi')
+                if not link:
+                    #print("Using word: Puntate intere")
+                    link = soup.find('a', string='Puntate intere')
+                
+                if link and link.has_attr('href'):
+                    if not link.string == 'Puntate intere':
+                        print("Using word: Episodi")
+                    season['sb'] = link['href'].split(',')[-1]
+                else:
+                    logging.warning(f"Link 'Episodi' or 'Puntate intere' not found for season {season['tvSeasonNumber']}")
 
     def _get_season_episodes(self, season):
-        """Ottiene gli episodi per una stagione specifica"""
+        """Get episodes for a specific season"""
         if not season.get('sb'):
             return
 
         episode_headers = {
-            'origin': 'https://mediasetinfinity.mediaset.it',
-            'referer': 'https://mediasetinfinity.mediaset.it/',
             'user-agent': get_userAgent(),
         }
         params = {
@@ -179,9 +144,8 @@ class GetSerieInfo:
         }
         episode_url = f"https://feed.entertainment.tv.theplatform.eu/f/{self.public_id}/mediaset-prod-all-programs-v2"
 
-        episode_response = requests.get(episode_url, headers=episode_headers, params=params, impersonate="chrome"
-                    , allow_redirects=True)
-        print("Risposta per _get_season_episodes:", episode_response.status_code)
+        with httpx.Client(timeout=max_timeout, follow_redirects=True) as client:
+            episode_response = client.get(episode_url, headers=episode_headers, params=params)
         
         if episode_response.status_code == 200:
             episode_data = episode_response.json()
@@ -192,7 +156,8 @@ class GetSerieInfo:
                     'id': entry.get('guid'),
                     'title': entry.get('title'),
                     'duration': int(entry.get('mediasetprogram$duration', 0) / 60) if entry.get('mediasetprogram$duration') else 0,
-                    'url': entry.get('media', [{}])[0].get('publicUrl') if entry.get('media') else None
+                    'url': entry.get('media', [{}])[0].get('publicUrl') if entry.get('media') else None,
+                    'name': entry.get('title')
                 }
                 season['episodes'].append(episode_info)
             
@@ -242,22 +207,22 @@ class GetSerieInfo:
             logging.error(f"Error in collect_season: {str(e)}")
 
     def _populate_seasons_manager(self):
-        """Popola il seasons_manager con i dati raccolti"""
+        """Populate the seasons_manager with collected data - ONLY for seasons with episodes"""
+        seasons_with_episodes = 0
+        
         for season_data in self.stagioni_disponibili:
-            season_obj = self.seasons_manager.add_season({
-                'number': season_data['tvSeasonNumber'],
-                'name': f"Stagione {season_data['tvSeasonNumber']}"
-            })
             
-            if season_obj and season_data.get('episodes'):
-                for idx, episode in enumerate(season_data['episodes'], 1):
-                    season_obj.episodes.add({
-                        'id': episode['id'],
-                        'number': idx,
-                        'name': episode['title'],
-                        'url': episode['url'],
-                        'duration': episode['duration']
-                    })
+            # Add season to manager ONLY if it has episodes
+            if season_data.get('episodes') and len(season_data['episodes']) > 0:
+                season_obj = self.seasons_manager.add_season({
+                    'number': season_data['tvSeasonNumber'],
+                    'name': f"Season {season_data['tvSeasonNumber']}"
+                })
+                
+                if season_obj:
+                    for episode in season_data['episodes']:
+                        season_obj.episodes.add(episode)
+                    seasons_with_episodes += 1
 
     # ------------- FOR GUI -------------
     def getNumberSeason(self) -> int:
@@ -275,10 +240,14 @@ class GetSerieInfo:
         """
         if not self.seasons_manager.seasons:
             self.collect_season()
-            
-        # Get season directly by its number
-        season = self.seasons_manager.get_season_by_number(season_number)
-        return season.episodes.episodes if season else []
+        
+        # Convert 1-based user input to 0-based array index
+        season_index = season_number - 1
+        
+        # Get season by index in the available seasons list
+        season = self.seasons_manager.seasons[season_index]
+        
+        return season.episodes.episodes
         
     def selectEpisode(self, season_number: int, episode_index: int) -> dict:
         """
@@ -289,4 +258,4 @@ class GetSerieInfo:
             logging.error(f"Episode index {episode_index} is out of range for season {season_number}")
             return None
             
-        return episodes[episode_index]
+        return episodes[episode_index]

StreamingCommunity/Api/Site/raiplay/__init__.py

@@ -100,10 +100,13 @@ def process_search_result(select_title, selections=None):
             episode_selection = selections.get('episode')
 
         download_series(select_title, season_selection, episode_selection)
+        media_search_manager.clear()
+        table_show_manager.clear()
         return True
 
     else:
         download_film(select_title)
+        table_show_manager.clear()
         return True
 
 def search(string_to_search: str = None, get_onlyDatabase: bool = False, direct_item: dict = None, selections: dict = None):
@@ -120,40 +123,37 @@ def search(string_to_search: str = None, get_onlyDatabase: bool = False, direct_
     bot = None
     if site_constant.TELEGRAM_BOT:
         bot = get_bot_instance()
-    
+
     if direct_item:
         select_title = MediaItem(**direct_item)
-        process_search_result(select_title, selections)
-        return True
+        result = process_search_result(select_title, selections)
+        return result
     
     # Get the user input for the search term
     actual_search_query = get_user_input(string_to_search)
 
-    # Handle cases where user input is empty, or 'back' was handled (sys.exit or None return)
+    # Handle empty input
     if not actual_search_query:
         if bot:
-            if actual_search_query is None: # Specifically for timeout from bot.ask or failed restart
+            if actual_search_query is None:
                 bot.send_message("Search term not provided or operation cancelled. Returning.", None)
-        return
-    
-    # Perform the database search
+        return False
+
+    # Search on database
     len_database = title_search(actual_search_query)
 
     # If only the database is needed, return the manager
     if get_onlyDatabase:
         return media_search_manager
-
+    
     if len_database > 0:
         select_title = get_select_title(table_show_manager, media_search_manager, len_database)
-        process_search_result(select_title, selections)
-        return True
+        result = process_search_result(select_title, selections)
+        return result
     
     else:
         if bot:
             bot.send_message(f"No results found for: '{actual_search_query}'", None)
         else:
             console.print(f"\n[red]Nothing matching was found for[white]: [purple]{actual_search_query}")
-
-        # Do not call search() recursively here to avoid infinite loops on no results.
-        # The flow should return to the caller (e.g., main menu in run.py).
-        return
+        return False

StreamingCommunity/Api/Site/raiplay/series.py

@@ -58,7 +58,7 @@ def download_video(index_season_selected: int, index_episode_selected: int, scra
 
     # Get episode information
     obj_episode = scrape_serie.selectEpisode(index_season_selected, index_episode_selected-1)
-    console.print(f"[bold yellow]Download:[/bold yellow] [red]{site_constant.SITE_NAME}[/red] → [bold magenta]{obj_episode.name}[/bold magenta] ([cyan]S{index_season_selected}E{index_episode_selected}[/cyan]) \n")
+    console.print(f"[bold yellow]Download:[/bold yellow] [red]{site_constant.SITE_NAME}[/red] → [cyan]{scrape_serie.series_name}[/cyan] \\ [bold magenta]{obj_episode.name}[/bold magenta] ([cyan]S{index_season_selected}E{index_episode_selected}[/cyan]) \n")
 
     # Define filename and path
     mp4_name = f"{map_episode_title(scrape_serie.series_name, index_season_selected, index_episode_selected, obj_episode.name)}.mp4"
@@ -135,6 +135,10 @@ def download_episode(index_season_selected: int, scrape_serie: GetSerieInfo, dow
     episodes = scrape_serie.getEpisodeSeasons(index_season_selected)
     episodes_count = len(episodes)
 
+    if episodes_count == 0:
+        console.print(f"[red]No episodes found for season {index_season_selected}")
+        return
+
     if download_all:
         for i_episode in range(1, episodes_count + 1):
             path, stopped = download_video(index_season_selected, i_episode, scrape_serie)

StreamingCommunity/Api/Site/streamingcommunity/__init__.py

@@ -98,12 +98,16 @@ def process_search_result(select_title, selections=None):
             episode_selection = selections.get('episode')
 
         download_series(select_title, season_selection, episode_selection)
+        media_search_manager.clear()
+        table_show_manager.clear()
         return True
         
     else:
         download_film(select_title)
+        table_show_manager.clear()
         return True
 
+
 def search(string_to_search: str = None, get_onlyDatabase: bool = False, direct_item: dict = None, selections: dict = None):
     """
     Main function of the application for search.
@@ -121,37 +125,35 @@ def search(string_to_search: str = None, get_onlyDatabase: bool = False, direct_
         bot = get_bot_instance()
 
     if direct_item:
-        select_title_obj = MediaItem(**direct_item)
-        process_search_result(select_title_obj, selections)
-        return True
+        select_title = MediaItem(**direct_item)
+        result = process_search_result(select_title, selections)
+        return result
     
+    # Get the user input for the search term
     actual_search_query = get_user_input(string_to_search)
 
-    # Handle cases where user input is empty, or 'back' was handled (sys.exit or None return)
+    # Handle empty input
     if not actual_search_query:
         if bot:
-            if actual_search_query is None: # Specifically for timeout from bot.ask or failed restart
+            if actual_search_query is None:
                 bot.send_message("Search term not provided or operation cancelled. Returning.", None)
-        return
+        return False
 
-    # Perform search on the database using the obtained query
+    # Search on database
     len_database = title_search(actual_search_query)
 
-    # If only the database object (media_search_manager populated by title_search) is needed
+    # If only the database is needed, return the manager
     if get_onlyDatabase:
         return media_search_manager
     
     if len_database > 0:
         select_title = get_select_title(table_show_manager, media_search_manager, len_database)
-        process_search_result(select_title, selections)
-        return True
+        result = process_search_result(select_title, selections)
+        return result
     
     else:
         if bot:
             bot.send_message(f"No results found for: '{actual_search_query}'", None)
         else:
             console.print(f"\n[red]Nothing matching was found for[white]: [purple]{actual_search_query}")
-        
-        # Do not call search() recursively here to avoid infinite loops on no results.
-        # The flow should return to the caller (e.g., main menu in run.py).
-        return
+        return False

StreamingCommunity/Api/Site/streamingwatch/__init__.py

@@ -99,10 +99,13 @@ def process_search_result(select_title, selections=None):
             episode_selection = selections.get('episode')
 
         download_series(select_title, season_selection, episode_selection)
+        media_search_manager.clear()
+        table_show_manager.clear()
         return True
 
     else:
         download_film(select_title)
+        table_show_manager.clear()
         return True
 
 def search(string_to_search: str = None, get_onlyDatabase: bool = False, direct_item: dict = None, selections: dict = None):
@@ -122,20 +125,20 @@ def search(string_to_search: str = None, get_onlyDatabase: bool = False, direct_
     
     if direct_item:
         select_title = MediaItem(**direct_item)
-        process_search_result(select_title, selections)
-        return True
+        result = process_search_result(select_title, selections)
+        return result
     
     # Get the user input for the search term
     actual_search_query = get_user_input(string_to_search)
 
-    # Handle cases where user input is empty, or 'back' was handled (sys.exit or None return)
+     # Handle empty input
     if not actual_search_query:
         if bot:
-            if actual_search_query is None: # Specifically for timeout from bot.ask or failed restart
+            if actual_search_query is None:
                 bot.send_message("Search term not provided or operation cancelled. Returning.", None)
-        return
+        return False
     
-    # Perform the database search
+    # Search on database
     len_database = title_search(actual_search_query)
 
     # If only the database is needed, return the manager
@@ -144,15 +147,12 @@ def search(string_to_search: str = None, get_onlyDatabase: bool = False, direct_
 
     if len_database > 0:
         select_title = get_select_title(table_show_manager, media_search_manager, len_database)
-        process_search_result(select_title, selections)
-        return True
+        result = process_search_result(select_title, selections)
+        return result
     
     else:
         if bot:
             bot.send_message(f"No results found for: '{actual_search_query}'", None)
         else:
             console.print(f"\n[red]Nothing matching was found for[white]: [purple]{actual_search_query}")
-
-        # Do not call search() recursively here to avoid infinite loops on no results.
-        # The flow should return to the caller (e.g., main menu in run.py).
-        return
+        return False

StreamingCommunity/Api/Site/streamingwatch/series.py

@@ -92,6 +92,10 @@ def download_episode(index_season_selected: int, scrape_serie: GetSerieInfo, dow
     episodes = scrape_serie.getEpisodeSeasons(index_season_selected)
     episodes_count = len(episodes)
 
+    if episodes_count == 0:
+        console.print(f"[red]No episodes found for season {index_season_selected}")
+        return
+
     if download_all:
         for i_episode in range(1, episodes_count + 1):
             path, stopped = download_video(index_season_selected, i_episode, scrape_serie)

StreamingCommunity/Api/Template/Class/SearchType.py

@@ -19,7 +19,6 @@ class MediaItemData(TypedDict, total=False):
     slug: str               # SC
     
 
-
 class MediaItemMeta(type):
     def __new__(cls, name, bases, dct):
         def init(self, **kwargs):

StreamingCommunity/Api/Template/Util/manage_ep.py

@@ -26,14 +26,6 @@ def dynamic_format_number(number_str: str) -> str:
     """
     Formats an episode number string, intelligently handling both integer and decimal episode numbers.
     
-    This function is designed to handle various episode number formats commonly found in media series:
-    1. For integer episode numbers less than 10 (e.g., 1, 2, ..., 9), it adds a leading zero (e.g., 01, 02, ..., 09)
-    2. For integer episode numbers 10 and above, it preserves the original format without adding leading zeros
-    3. For decimal episode numbers (e.g., "7.5", "10.5"), it preserves the decimal format exactly as provided
-    
-    The function is particularly useful for media file naming conventions where special episodes
-    or OVAs may have decimal notations (like episode 7.5) which should be preserved in their original format.
-    
     Parameters:
         - number_str (str): The episode number as a string, which may contain integers or decimals.
     
@@ -104,7 +96,7 @@ def manage_selection(cmd_insert: str, max_count: int) -> List[int]:
             list_selection = list(range(1, max_count + 1))
             break
 
-        cmd_insert = msg.ask("[red]Invalid input. Please enter a valid command: ")
+        cmd_insert = msg.ask("[red]Invalid input. Please enter a valid command")
     
     logging.info(f"List return: {list_selection}")
     return list_selection
@@ -145,7 +137,6 @@ def map_episode_title(tv_name: str, number_season: int, episode_number: int, epi
     return map_episode_temp
 
 
-# --> for season
 def validate_selection(list_season_select: List[int], seasons_count: int) -> List[int]:
     """
     Validates and adjusts the selected seasons based on the available seasons.
@@ -182,7 +173,6 @@ def validate_selection(list_season_select: List[int], seasons_count: int) -> Lis
             list_season_select = list(map(int, input_seasons.split(',')))
 
 
-# --> for episode
 def validate_episode_selection(list_episode_select: List[int], episodes_count: int) -> List[int]:
     """
     Validates and adjusts the selected episodes based on the available episodes.

StreamingCommunity/Api/Template/site.py

@@ -8,6 +8,7 @@ from rich.console import Console
 from StreamingCommunity.Api.Template.config_loader import site_constant
 from StreamingCommunity.TelegramHelp.telegram_bot import get_bot_instance
 
+
 # Variable
 console = Console()
 available_colors = ['red', 'magenta', 'yellow', 'cyan', 'green', 'blue', 'white']
@@ -124,10 +125,8 @@ def get_select_title(table_show_manager, media_search_manager, num_results_avail
                 
             else:
                 console.print("\n[red]Indice errato o non valido.")
-                # sys.exit(0)
                 return None
                 
         except ValueError:
             console.print("\n[red]Input non numerico ricevuto dalla tabella.")
-            # sys.exit(0)
-            return None
+            return None

StreamingCommunity/Lib/Downloader/DASH/downloader.py

@@ -7,6 +7,7 @@ import shutil
 # External libraries
 from rich.console import Console
 from rich.panel import Panel
+from rich.table import Table
 
 
 # Internal utilities
@@ -64,23 +65,59 @@ class DASH_Downloader:
         self.parser = MPDParser(self.mpd_url)
         self.parser.parse(custom_headers)
 
-        # Video info
-        selected_video, list_available_resolution, filter_custom_resolution, downloadable_video = self.parser.select_video(FILTER_CUSTOM_REOLUTION)
-        console.print(
-            f"[cyan bold]Video    [/cyan bold] [green]Available:[/green] [purple]{', '.join(list_available_resolution)}[/purple] | "
-            f"[red]Set:[/red] [purple]{filter_custom_resolution}[/purple] | "
-            f"[yellow]Downloadable:[/yellow] [purple]{downloadable_video}[/purple]"
-        )
-        self.selected_video = selected_video
-
-        # Audio info 
-        selected_audio, list_available_audio_langs, filter_custom_audio, downloadable_audio = self.parser.select_audio(DOWNLOAD_SPECIFIC_AUDIO)
-        console.print(
-            f"[cyan bold]Audio    [/cyan bold] [green]Available:[/green] [purple]{', '.join(list_available_audio_langs)}[/purple] | "
-            f"[red]Set:[/red] [purple]{filter_custom_audio}[/purple] | "
-            f"[yellow]Downloadable:[/yellow] [purple]{downloadable_audio}[/purple]"
-        )
-        self.selected_audio = selected_audio
+        def calculate_column_widths():
+            """Calculate optimal column widths based on content."""
+            data_rows = []
+            
+            # Video info
+            selected_video, list_available_resolution, filter_custom_resolution, downloadable_video = self.parser.select_video(FILTER_CUSTOM_REOLUTION)
+            self.selected_video = selected_video
+            
+            available_video = ', '.join(list_available_resolution) if list_available_resolution else "Nothing"
+            set_video = str(filter_custom_resolution) if filter_custom_resolution else "Nothing"
+            downloadable_video_str = str(downloadable_video) if downloadable_video else "Nothing"
+            
+            data_rows.append(["Video", available_video, set_video, downloadable_video_str])
+
+            # Audio info 
+            selected_audio, list_available_audio_langs, filter_custom_audio, downloadable_audio = self.parser.select_audio(DOWNLOAD_SPECIFIC_AUDIO)
+            self.selected_audio = selected_audio
+            
+            available_audio = ', '.join(list_available_audio_langs) if list_available_audio_langs else "Nothing"
+            set_audio = str(filter_custom_audio) if filter_custom_audio else "Nothing"
+            downloadable_audio_str = str(downloadable_audio) if downloadable_audio else "Nothing"
+            
+            data_rows.append(["Audio", available_audio, set_audio, downloadable_audio_str])
+            
+            # Calculate max width for each column
+            headers = ["Type", "Available", "Set", "Downloadable"]
+            max_widths = [len(header) for header in headers]
+            
+            for row in data_rows:
+                for i, cell in enumerate(row):
+                    max_widths[i] = max(max_widths[i], len(str(cell)))
+            
+            # Add some padding
+            max_widths = [w + 2 for w in max_widths]
+            
+            return data_rows, max_widths
+        
+        data_rows, column_widths = calculate_column_widths()
+        
+        # Create table with dynamic widths
+        table = Table(show_header=True, header_style="bold cyan", border_style="blue")
+        table.add_column("Type", style="cyan bold", width=column_widths[0])
+        table.add_column("Available", style="green", width=column_widths[1])
+        table.add_column("Set", style="red", width=column_widths[2])
+        table.add_column("Downloadable", style="yellow", width=column_widths[3])
+        
+        # Add all rows to the table
+        for row in data_rows:
+            table.add_row(*row)
+
+        console.print("[cyan]You can safely stop the download with [bold]Ctrl+c[bold] [cyan]")
+        console.print(table)
+        console.print("")
 
     def get_representation_by_type(self, typ):
         if typ == "video":
@@ -212,6 +249,7 @@ class DASH_Downloader:
                 f"[cyan]Output: [bold]{os.path.abspath(output_file)}[/bold]"
             )
 
+            print("")
             console.print(Panel(
                 panel_content,
                 title=f"{os.path.basename(output_file.replace('.mp4', ''))}",