StreamingCommunity 3.4.0__py3-none-any.whl → 3.4.2__py3-none-any.whl

StreamingCommunity/Lib/Downloader/DASH/segments.py

@@ -3,6 +3,7 @@
 import os
 import asyncio
 import time
+from typing import Dict, Optional
 
 
 # External libraries
@@ -68,6 +69,9 @@ class MPD_Segments:
         # Segment tracking - store only metadata, not content
         self.segment_status = {}  # {idx: {'downloaded': bool, 'size': int}}
         self.segments_lock = asyncio.Lock()
+        
+        # Estimator for progress tracking
+        self.estimator: Optional[M3U8_Ts_Estimator] = None
 
     def get_concat_path(self, output_dir: str = None):
         """
@@ -150,7 +154,7 @@ class MPD_Segments:
         semaphore = asyncio.Semaphore(concurrent_downloads)
 
         # Initialize estimator
-        estimator = M3U8_Ts_Estimator(total_segments=len(segment_urls) + 1)
+        self.estimator = M3U8_Ts_Estimator(total_segments=len(segment_urls) + 1)
 
         self.segment_status = {}
         self.downloaded_segments = set()
@@ -166,17 +170,17 @@ class MPD_Segments:
             async with httpx.AsyncClient(timeout=timeout_config, limits=limits) as client:
                 
                 # Download init segment
-                await self._download_init_segment(client, init_url, concat_path, estimator, progress_bar)
+                await self._download_init_segment(client, init_url, concat_path, progress_bar)
 
                 # Download all segments to temp files
                 await self._download_segments_batch(
-                    client, segment_urls, temp_dir, semaphore, REQUEST_MAX_RETRY, estimator, progress_bar
+                    client, segment_urls, temp_dir, semaphore, REQUEST_MAX_RETRY, progress_bar
                 )
 
                 # Retry failed segments only if enabled
                 if self.enable_retry:
                     await self._retry_failed_segments(
-                        client, segment_urls, temp_dir, semaphore, REQUEST_MAX_RETRY, estimator, progress_bar
+                        client, segment_urls, temp_dir, semaphore, REQUEST_MAX_RETRY, progress_bar
                     )
 
                 # Concatenate all segments IN ORDER
@@ -192,7 +196,7 @@ class MPD_Segments:
         self._verify_download_completion()
         return self._generate_results(stream_type)
 
-    async def _download_init_segment(self, client, init_url, concat_path, estimator, progress_bar):
+    async def _download_init_segment(self, client, init_url, concat_path, progress_bar):
         """
         Download the init segment and update progress/estimator.
         """
@@ -208,25 +212,28 @@ class MPD_Segments:
             with open(concat_path, 'wb') as outfile:
                 if response.status_code == 200:
                     outfile.write(response.content)
-                    estimator.add_ts_file(len(response.content))
+                    if self.estimator:
+                        self.estimator.add_ts_file(len(response.content))
 
             progress_bar.update(1)
-            self._throttled_progress_update(len(response.content), estimator, progress_bar)
+            if self.estimator:
+                self._throttled_progress_update(len(response.content), progress_bar)
 
         except Exception as e:
             progress_bar.close()
             raise RuntimeError(f"Error downloading init segment: {e}")
 
-    def _throttled_progress_update(self, content_size: int, estimator, progress_bar):
+    def _throttled_progress_update(self, content_size: int, progress_bar):
         """
         Throttled progress update to reduce CPU usage.
         """
         current_time = time.time()
         if current_time - self._last_progress_update > self._progress_update_interval:
-            estimator.update_progress_bar(content_size, progress_bar)
+            if self.estimator:
+                self.estimator.update_progress_bar(content_size, progress_bar)
             self._last_progress_update = current_time
 
-    async def _download_segments_batch(self, client, segment_urls, temp_dir, semaphore, max_retry, estimator, progress_bar):
+    async def _download_segments_batch(self, client, segment_urls, temp_dir, semaphore, max_retry, progress_bar):
         """
         Download segments to temporary files - write immediately to disk, not memory.
         """
@@ -287,15 +294,16 @@ class MPD_Segments:
                 self.info_nRetry += nretry
                     
                 progress_bar.update(1)
-                estimator.add_ts_file(size)
-                self._throttled_progress_update(size, estimator, progress_bar)
+                if self.estimator:
+                    self.estimator.add_ts_file(size)
+                    self._throttled_progress_update(size, progress_bar)
 
             except KeyboardInterrupt:
                 self.download_interrupted = True
                 console.print("\n[red]Download interrupted by user (Ctrl+C).")
                 break
 
-    async def _retry_failed_segments(self, client, segment_urls, temp_dir, semaphore, max_retry, estimator, progress_bar):
+    async def _retry_failed_segments(self, client, segment_urls, temp_dir, semaphore, max_retry, progress_bar):
         """
         Retry failed segments up to 3 times.
         """
@@ -354,8 +362,9 @@ class MPD_Segments:
                     self.info_nRetry += nretry
                     
                     progress_bar.update(0)
-                    estimator.add_ts_file(size)
-                    self._throttled_progress_update(size, estimator, progress_bar)
+                    if self.estimator:
+                        self.estimator.add_ts_file(size)
+                        self._throttled_progress_update(size, progress_bar)
 
                 except KeyboardInterrupt:
                     self.download_interrupted = True
@@ -474,4 +483,24 @@ class MPD_Segments:
         console.print(f" [cyan]Max retries: [red]{getattr(self, 'info_maxRetry', 0)} [white]| "
             f"[cyan]Total retries: [red]{getattr(self, 'info_nRetry', 0)} [white]| "
             f"[cyan]Failed segments: [red]{getattr(self, 'info_nFailed', 0)} [white]| "
-            f"[cyan]Failed indices: [red]{failed_indices}")
+            f"[cyan]Failed indices: [red]{failed_indices}")
+    
+    def get_progress_data(self) -> Dict:
+        """Returns current download progress data for API."""
+        if not self.estimator:
+            return None
+            
+        total = self.get_segments_count()
+        downloaded = len(self.downloaded_segments)
+        percentage = (downloaded / total * 100) if total > 0 else 0
+        stats = self.estimator.get_stats(downloaded, total)
+        
+        return {
+            'total_segments': total,
+            'downloaded_segments': downloaded,
+            'failed_segments': self.info_nFailed,
+            'current_speed': stats['download_speed'],
+            'estimated_size': stats['estimated_total_size'],
+            'percentage': round(percentage, 2),
+            'eta_seconds': stats['eta_seconds']
+        }

StreamingCommunity/Lib/Downloader/HLS/downloader.py

@@ -8,7 +8,6 @@ from typing import Any, Dict, List, Optional, Union
 
 # External libraries
 from rich.console import Console
-from rich.panel import Panel
 from rich.table import Table
 
 
@@ -155,6 +154,7 @@ class M3U8Manager:
         """
         Selects video, audio, and subtitle streams based on configuration.
         If it's a master playlist, only selects video stream.
+        Auto-selects first audio if only one is available and none match filters.
         """
         if not self.is_master:
             self.video_url, self.video_res = self.m3u8_url, "undefined"
@@ -162,6 +162,7 @@ class M3U8Manager:
             self.sub_streams = []
 
         else:
+            # Video selection logic
             if str(FILTER_CUSTOM_RESOLUTION) == "best":
                 self.video_url, self.video_res = self.parser._video.get_best_uri()
             elif str(FILTER_CUSTOM_RESOLUTION) == "worst":
@@ -173,18 +174,29 @@ class M3U8Manager:
                 # Fallback to best if custom resolution not found
                 if self.video_url is None:
                     self.video_url, self.video_res = self.parser._video.get_best_uri()
-
             else:
                 logging.error("Resolution not recognized.")
                 self.video_url, self.video_res = self.parser._video.get_best_uri()
 
-            # Audio info
+            # Audio selection with auto-select fallback
+            all_audio = self.parser._audio.get_all_uris_and_names() or []
+            
+            # Try to match with configured languages
             self.audio_streams = [
-                s for s in (self.parser._audio.get_all_uris_and_names() or [])
+                s for s in all_audio
                 if s.get('language') in DOWNLOAD_SPECIFIC_AUDIO
             ]
-
-            # Subtitle info
+            
+            # Auto-select first audio if:
+            # 1. No audio matched the filters
+            # 2. At least one audio track is available
+            # 3. Filters are configured (not empty)
+            if not self.audio_streams and all_audio and DOWNLOAD_SPECIFIC_AUDIO:
+                first_audio_lang = all_audio[0].get('language', 'unknown')
+                console.print(f"\n[yellow]Auto-selecting first available audio track: {first_audio_lang}[/yellow]")
+                self.audio_streams = [all_audio[0]]
+
+            # Subtitle selection
             self.sub_streams = []
             if "*" in DOWNLOAD_SPECIFIC_SUBTITLE:
                 self.sub_streams = self.parser._subtitle.get_all_uris_and_names() or []
@@ -212,27 +224,22 @@ class M3U8Manager:
             
             data_rows.append(["Video", available_video, str(FILTER_CUSTOM_RESOLUTION), downloadable_video])
             
-
             # Subtitle information
             available_subtitles = self.parser._subtitle.get_all_uris_and_names() or []
-            available_sub_languages = [sub.get('language') for sub in available_subtitles]
-            
-            if available_sub_languages:
+            if available_subtitles:
+                available_sub_languages = [sub.get('language') for sub in available_subtitles]
                 available_subs = ', '.join(available_sub_languages)
-                
-                downloadable_sub_languages = available_sub_languages if "*" in DOWNLOAD_SPECIFIC_SUBTITLE else list(set(available_sub_languages) & set(DOWNLOAD_SPECIFIC_SUBTITLE))
+                downloadable_sub_languages = [sub.get('language') for sub in self.sub_streams]
                 downloadable_subs = ', '.join(downloadable_sub_languages) if downloadable_sub_languages else "Nothing"
                 
                 data_rows.append(["Subtitle", available_subs, ', '.join(DOWNLOAD_SPECIFIC_SUBTITLE), downloadable_subs])
 
             # Audio information
             available_audio = self.parser._audio.get_all_uris_and_names() or []
-            available_audio_languages = [audio.get('language') for audio in available_audio]
-            
-            if available_audio_languages:
+            if available_audio:
+                available_audio_languages = [audio.get('language') for audio in available_audio]
                 available_audios = ', '.join(available_audio_languages)
-                
-                downloadable_audio_languages = list(set(available_audio_languages) & set(DOWNLOAD_SPECIFIC_AUDIO))
+                downloadable_audio_languages = [audio.get('language') for audio in self.audio_streams]
                 downloadable_audios = ', '.join(downloadable_audio_languages) if downloadable_audio_languages else "Nothing"
                 
                 data_rows.append(["Audio", available_audios, ', '.join(DOWNLOAD_SPECIFIC_AUDIO), downloadable_audios])
@@ -263,7 +270,8 @@ class M3U8Manager:
 
         console.print(table)
         print("")
-            
+
+
 class DownloadManager:
     """Manages downloading of video, audio, and subtitle streams."""
     def __init__(self, temp_dir: str, client: HLSClient, url_fixer: M3U8_UrlFix, custom_headers: Optional[Dict[str, str]] = None):
@@ -282,6 +290,10 @@ class DownloadManager:
         self.stopped = False
         self.video_segments_count = 0
 
+        # For progress tracking
+        self.current_downloader: Optional[M3U8_Segments] = None
+        self.current_download_type: Optional[str] = None
+
     def download_video(self, video_url: str) -> bool:
         """
         Downloads video segments from the M3U8 playlist.
@@ -299,12 +311,20 @@ class DownloadManager:
                 tmp_folder=video_tmp_dir,
                 custom_headers=self.custom_headers
             )
+
+            # Set current downloader for progress tracking
+            self.current_downloader = downloader
+            self.current_download_type = 'video'
             
             # Download video and get segment count
             result = downloader.download_streams("Video", "video")
             self.video_segments_count = downloader.get_segments_count()
             self.missing_segments.append(result)
 
+            # Reset current downloader after completion
+            self.current_downloader = None
+            self.current_download_type = None
+
             if result.get('stopped', False):
                 self.stopped = True
                 return False
@@ -313,6 +333,8 @@ class DownloadManager:
         
         except Exception as e:
             logging.error(f"Error downloading video from {video_url}: {str(e)}")
+            self.current_downloader = None
+            self.current_download_type = None
             return False
 
     def download_audio(self, audio: Dict) -> bool:
@@ -334,10 +356,19 @@ class DownloadManager:
                 limit_segments=self.video_segments_count if self.video_segments_count > 0 else None,
                 custom_headers=self.custom_headers
             )
-            
+
+            # Set current downloader for progress tracking
+            self.current_downloader = downloader
+            self.current_download_type = f"audio_{audio['language']}"
+
+            # Download audio
             result = downloader.download_streams(f"Audio {audio['language']}", "audio")
             self.missing_segments.append(result)
 
+            # Reset current downloader after completion
+            self.current_downloader = None
+            self.current_download_type = None
+
             if result.get('stopped', False):
                 self.stopped = True
                 return False
@@ -346,6 +377,8 @@ class DownloadManager:
         
         except Exception as e:
             logging.error(f"Error downloading audio {audio.get('language', 'unknown')}: {str(e)}")
+            self.current_downloader = None
+            self.current_download_type = None
             return False
 
     def download_subtitle(self, sub: Dict) -> bool:
@@ -645,6 +678,7 @@ class HLS_Downloader:
         """Prints download summary including file size, duration, and any missing segments."""
         missing_ts = False
         missing_info = ""
+
         for item in self.download_manager.missing_segments:
             if int(item['nFailed']) >= 1:
                 missing_ts = True
@@ -653,15 +687,7 @@ class HLS_Downloader:
         file_size = internet_manager.format_file_size(os.path.getsize(self.path_manager.output_path))
         duration = print_duration_table(self.path_manager.output_path, description=False, return_string=True)
 
-        panel_content = (
-            f"[cyan]File size: [bold red]{file_size}[/bold red]\n"
-            f"[cyan]Duration: [bold]{duration}[/bold]\n"
-            f"[cyan]Output: [bold]{os.path.abspath(self.path_manager.output_path)}[/bold]"
-        )
-
-        if missing_ts:
-            panel_content += f"\n{missing_info}"
-
+        # Rename output file if there were missing segments or shortest used
         new_filename = self.path_manager.output_path
         if missing_ts and use_shortest:
             new_filename = new_filename.replace(EXTENSION_OUTPUT, f"_failed_sync_ts{EXTENSION_OUTPUT}")
@@ -670,13 +696,24 @@ class HLS_Downloader:
         elif use_shortest:
             new_filename = new_filename.replace(EXTENSION_OUTPUT, f"_failed_sync{EXTENSION_OUTPUT}")
 
+        # Rename the file accordingly
         if missing_ts or use_shortest:
             os.rename(self.path_manager.output_path, new_filename)
             self.path_manager.output_path = new_filename
 
-        print("")
-        console.print(Panel(
-            panel_content,
-            title=f"{os.path.basename(self.path_manager.output_path.replace('.mp4', ''))}",
-            border_style="green"
-        ))
+        console.print(f"[yellow]Output [red]{os.path.abspath(self.path_manager.output_path)} [cyan]with size [red]{file_size} [cyan]and duration [red]{duration}")
+
+    def get_progress_data(self) -> Optional[Dict]:
+        """Get current download progress data."""
+        if not self.download_manager.current_downloader:
+            return None
+
+        try:
+            progress = self.download_manager.current_downloader.get_progress_data()
+            if progress:
+                progress['download_type'] = self.download_manager.current_download_type
+            return progress
+            
+        except Exception as e:
+            logging.error(f"Error getting progress data: {e}")
+            return None

StreamingCommunity/Lib/Downloader/HLS/segments.py

@@ -487,4 +487,21 @@ class M3U8_Segments:
         """Generate final error report."""
         console.print(f" [cyan]Max retries: [red]{self.info_maxRetry} [white] | "
             f"[cyan]Total retries: [red]{self.info_nRetry} [white] | "
-            f"[cyan]Failed segments: [red]{self.info_nFailed}")
+            f"[cyan]Failed segments: [red]{self.info_nFailed}")
+        
+    def get_progress_data(self) -> Dict:
+        """Returns current download progress data for API consumption."""
+        total = self.get_segments_count()
+        downloaded = len(self.downloaded_segments)
+        percentage = (downloaded / total * 100) if total > 0 else 0
+        stats = self.class_ts_estimator.get_stats(downloaded, total)
+        
+        return {
+            'total_segments': total,
+            'downloaded_segments': downloaded,
+            'failed_segments': self.info_nFailed,
+            'current_speed': stats['download_speed'],
+            'estimated_size': stats['estimated_total_size'],
+            'percentage': round(percentage, 2),
+            'eta_seconds': stats['eta_seconds']
+        }

StreamingCommunity/Lib/Downloader/MP4/downloader.py

@@ -76,6 +76,7 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
     - Single Ctrl+C: Completes download gracefully
     - Triple Ctrl+C: Saves partial download and exits
     """
+    url = url.strip()
     if TELEGRAM_BOT:
         bot = get_bot_instance()
         console.log("####")
@@ -134,20 +135,23 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
 
                 # Create progress bar with percentage instead of n_fmt/total_fmt
                 console.print("[cyan]You can safely stop the download with [bold]Ctrl+c[bold] [cyan]")
+                
                 progress_bar = tqdm(
                     total=total,
                     ascii='░▒█',
                     bar_format=f"{Colors.YELLOW}MP4{Colors.CYAN} Downloading{Colors.WHITE}: "
-                               f"{Colors.RED}{{percentage:.1f}}% {Colors.MAGENTA}{{bar:40}} {Colors.WHITE}"
-                               f"{Colors.DARK_GRAY}[{Colors.YELLOW}{{elapsed}}{Colors.WHITE} < {Colors.CYAN}{{remaining}}{Colors.DARK_GRAY}] "
-                               f"{Colors.LIGHT_CYAN}{{rate_fmt}}",
+                               f"{Colors.MAGENTA}{{bar:40}} "
+                               f"{Colors.LIGHT_GREEN}{{n_fmt}}{Colors.WHITE}/{Colors.CYAN}{{total_fmt}}"
+                               f" {Colors.DARK_GRAY}[{Colors.YELLOW}{{elapsed}}{Colors.WHITE} < {Colors.CYAN}{{remaining}}{Colors.DARK_GRAY}]"
+                               f"{Colors.WHITE}{{postfix}} ",
                     unit='B',
                     unit_scale=True,
                     unit_divisor=1024,
                     mininterval=0.05,
                     file=sys.stdout
                 )
-
+                
+                start_time = time.time()
                 downloaded = 0
                 with open(temp_path, 'wb') as file, progress_bar as bar:
                     try:
@@ -160,6 +164,14 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
                                 size = file.write(chunk)
                                 downloaded += size
                                 bar.update(size)
+                                
+                                # Update postfix with speed and final size
+                                elapsed = time.time() - start_time
+                                if elapsed > 0:
+                                    speed = downloaded / elapsed
+                                    speed_str = internet_manager.format_transfer_speed(speed)
+                                    postfix_str = f"{Colors.LIGHT_MAGENTA}@ {Colors.LIGHT_CYAN}{speed_str}"
+                                    bar.set_postfix_str(postfix_str)
 
                     except KeyboardInterrupt:
                         if not interrupt_handler.force_quit:

StreamingCommunity/Lib/M3U8/estimator.py

@@ -4,6 +4,7 @@ import time
 import logging
 import threading
 from collections import deque
+from typing import Dict
 
 
 # External libraries
@@ -165,4 +166,49 @@ class M3U8_Ts_Estimator:
         """Stop speed monitoring thread."""
         self._running = False
         if self.speed_thread.is_alive():
-            self.speed_thread.join(timeout=5.0)
+            self.speed_thread.join(timeout=5.0)
+
+    def get_speed_data(self) -> Dict[str, str]:
+        """Returns current speed data thread-safe."""
+        with self.lock:
+            return self.speed.copy()
+    
+    def get_average_segment_size(self) -> int:
+        """Returns average segment size in bytes."""
+        with self.lock:
+            if not self.ts_file_sizes:
+                return 0
+            return int(sum(self.ts_file_sizes) / len(self.ts_file_sizes))
+    
+    def get_stats(self, downloaded_count: int = None, total_segments: int = None) -> Dict:
+        """Returns comprehensive statistics for API."""
+        with self.lock:
+            avg_size = self.get_average_segment_size()
+            total_downloaded = sum(self.ts_file_sizes)
+            
+            # Calculate ETA
+            eta_seconds = 0
+            if downloaded_count is not None and total_segments is not None:
+                speed = self.speed.get('download', 'N/A')
+                if speed != 'N/A' and ' ' in speed:
+                    try:
+                        speed_value, speed_unit = speed.split(' ', 1)
+                        speed_bps = float(speed_value) * (1024 * 1024 if 'MB/s' in speed_unit else 1024 if 'KB/s' in speed_unit else 1)
+                        
+                        remaining_segments = total_segments - downloaded_count
+                        if remaining_segments > 0 and avg_size > 0 and speed_bps > 0:
+                            eta_seconds = int((avg_size * remaining_segments) / speed_bps)
+                    
+                    except Exception:
+                        pass
+            
+            return {
+                'total_segments': self.total_segments,
+                'downloaded_count': len(self.ts_file_sizes),
+                'average_segment_size': avg_size,
+                'total_downloaded_bytes': total_downloaded,
+                'estimated_total_size': self.calculate_total_size(),
+                'upload_speed': self.speed.get('upload', 'N/A'),
+                'download_speed': self.speed.get('download', 'N/A'),
+                'eta_seconds': eta_seconds
+            }

StreamingCommunity/Upload/update.py

@@ -18,7 +18,6 @@ from StreamingCommunity.Util.config_json import config_manager
 from StreamingCommunity.Util.headers import get_userAgent
 
 
-
 # Variable
 if getattr(sys, 'frozen', False):  # Modalità PyInstaller
     base_path = os.path.join(sys._MEIPASS, "StreamingCommunity")
@@ -26,6 +25,7 @@ else:
     base_path = os.path.dirname(__file__)
 console = Console()
 
+
 async def fetch_github_data(client, url):
     """Helper function to fetch data from GitHub API"""
     response = await client.get(
@@ -46,10 +46,23 @@ async def async_github_requests():
         ]
         return await asyncio.gather(*tasks)
 
+def get_execution_mode():
+    """Get the execution mode of the application"""
+    if getattr(sys, 'frozen', False):
+        return "installer"
+
+    try:
+        package_location = importlib.metadata.files(__title__)
+        if any("site-packages" in str(path) for path in package_location):
+            return "pip"
+        
+    except importlib.metadata.PackageNotFoundError:
+        pass
+
+    return "python"
+
 def update():
-    """
-    Check for updates on GitHub and display relevant information.
-    """
+    """Check for updates on GitHub and display relevant information."""
     try:
         # Run async requests concurrently
         response_reposity, response_releases, response_commits = asyncio.run(async_github_requests())
@@ -93,7 +106,7 @@ def update():
         console.print(f"\n[cyan]New version available: [yellow]{last_version}")
 
     console.print(f"\n[red]{__title__} has been downloaded [yellow]{total_download_count} [red]times, but only [yellow]{percentual_stars}% [red]of users have starred it.\n\
-        [green]Current installed version: [yellow]{current_version} [green]last commit: [white]''[yellow]{latest_commit_message.splitlines()[0]}[white]''\n\
+        [yellow]{get_execution_mode()} - [green]Current installed version: [yellow]{current_version} [green]last commit: [white]'[yellow]{latest_commit_message.splitlines()[0]}[white]'\n\
         [cyan]Help the repository grow today by leaving a [yellow]star [cyan]and [yellow]sharing [cyan]it with others online!")
     
-    time.sleep(1)
+    time.sleep(0.8)

StreamingCommunity/Upload/version.py

@@ -1,5 +1,5 @@
 __title__ = 'StreamingCommunity'
-__version__ = '3.4.0'
+__version__ = '3.4.2'
 __author__ = 'Arrowar'
 __description__ = 'A command-line program to download film'
 __copyright__ = 'Copyright 2025'

StreamingCommunity/Util/table.py

@@ -12,7 +12,7 @@ from typing import Dict, List, Any
 from rich.console import Console
 from rich.table import Table
 from rich.prompt import Prompt
-from rich.style import Style
+from rich import box
 
 
 # Internal utilities
@@ -38,6 +38,9 @@ class TVShowManager:
         self.slice_end = 10
         self.step = self.slice_end
         self.column_info = []
+        self.table_title = None
+        self.table_style = "blue"
+        self.show_lines = False
 
     def add_column(self, column_info: Dict[str, Dict[str, str]]) -> None:
         """
@@ -48,6 +51,26 @@ class TVShowManager:
         """
         self.column_info = column_info
 
+    def set_table_title(self, title: str) -> None:
+        """
+        Set the table title.
+        
+        Parameters:
+            - title (str): The title to display above the table.
+        """
+        self.table_title = title
+
+    def set_table_style(self, style: str = "blue", show_lines: bool = False) -> None:
+        """
+        Set the table border style and row lines.
+        
+        Parameters:
+            - style (str): Border color (e.g., "blue", "green", "magenta", "cyan")
+            - show_lines (bool): Whether to show lines between rows
+        """
+        self.table_style = style
+        self.show_lines = show_lines
+
     def add_tv_show(self, tv_show: Dict[str, Any]) -> None:
         """
         Add a TV show to the list of TV shows.
@@ -73,19 +96,38 @@ class TVShowManager:
             logging.error("Error: Column information not configured.")
             return
 
-        table = Table(border_style="white")
+        # Create table with specified style
+        table = Table(
+            title=self.table_title,
+            box=box.ROUNDED,
+            show_header=True,
+            header_style="bold cyan",
+            border_style=self.table_style,
+            show_lines=self.show_lines,
+            padding=(0, 1)
+        )
 
         # Add columns dynamically based on provided column information
         for col_name, col_style in self.column_info.items():
-            color = col_style.get("color", None)
-            style = Style(color=color) if color else None
-            table.add_column(col_name, style=style, justify='center')
+            color = col_style.get("color", "white")
+            width = col_style.get("width", None)
+            justify = col_style.get("justify", "center")
+            
+            table.add_column(
+                col_name, 
+                style=color,
+                justify=justify,
+                width=width
+            )
 
         # Add rows dynamically based on available TV show data
-        for entry in data_slice:
+        for idx, entry in enumerate(data_slice):
             if entry:
                 row_data = [str(entry.get(col_name, '')) for col_name in self.column_info.keys()]
-                table.add_row(*row_data)
+                
+                # Alternate row styling for better readability
+                style = "dim" if idx % 2 == 1 else None
+                table.add_row(*row_data, style=style)
 
         self.console.print(table)
     
@@ -162,7 +204,7 @@ class TVShowManager:
             
             self.display_data(current_slice)
 
-            # Resto del codice rimane uguale...
+            # Get research function from call stack
             research_func = next((
                 f for f in get_call_stack()
                 if f['function'] == 'search' and f['script'] == '__init__.py'