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

StreamingCommunity/Lib/FFmpeg/command.py

@@ -23,18 +23,30 @@ from ..M3U8 import M3U8_Codec
 # Config
 DEBUG_MODE = config_manager.get_bool("DEFAULT", "debug")
 DEBUG_FFMPEG = "debug" if DEBUG_MODE else "error"
-USE_CODEC = config_manager.get_bool("M3U8_CONVERSION", "use_codec")
-USE_VCODEC = config_manager.get_bool("M3U8_CONVERSION", "use_vcodec")
-USE_ACODEC = config_manager.get_bool("M3U8_CONVERSION", "use_acodec")
-USE_BITRATE = config_manager.get_bool("M3U8_CONVERSION", "use_bitrate")
 USE_GPU = config_manager.get_bool("M3U8_CONVERSION", "use_gpu")
-FFMPEG_DEFAULT_PRESET = config_manager.get("M3U8_CONVERSION", "default_preset")
+PARAM_VIDEO = config_manager.get_list("M3U8_CONVERSION", "param_video")
+PARAM_AUDIO = config_manager.get_list("M3U8_CONVERSION", "param_audio")
+PARAM_FINAL = config_manager.get_list("M3U8_CONVERSION", "param_final")
 
 
 # Variable
 console = Console()
 
 
+def add_encoding_params(ffmpeg_cmd: List[str]):
+    """
+    Add encoding parameters to the ffmpeg command.
+    
+    Parameters:
+        ffmpeg_cmd (List[str]): List of the FFmpeg command to modify
+    """
+    if PARAM_FINAL:
+        ffmpeg_cmd.extend(PARAM_FINAL)
+    else:
+        ffmpeg_cmd.extend(PARAM_VIDEO)
+        ffmpeg_cmd.extend(PARAM_AUDIO)
+
+
 def check_subtitle_encoders() -> Tuple[Optional[bool], Optional[bool]]:
     """
     Executes 'ffmpeg -encoders' and checks if 'mov_text' and 'webvtt' encoders are available.
@@ -51,7 +63,6 @@ def check_subtitle_encoders() -> Tuple[Optional[bool], Optional[bool]]:
             check=True
         )
         
-        # Check for encoder presence in output
         output = result.stdout
         mov_text_supported = "mov_text" in output
         webvtt_supported = "webvtt" in output
@@ -74,11 +85,9 @@ def select_subtitle_encoder() -> Optional[str]:
     """
     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"
@@ -98,7 +107,7 @@ def join_video(video_path: str, out_path: str, codec: M3U8_Codec = None):
     Parameters:
         - video_path (str): The path to the video file.
         - out_path (str): The path to save the output file.
-        - codec (M3U8_Codec): The video codec to use. Defaults to 'copy'.
+        - codec (M3U8_Codec): The video codec to use (non utilizzato con nuova configurazione).
     """
     ffmpeg_cmd = [get_ffmpeg_path()]
 
@@ -113,42 +122,11 @@ def join_video(video_path: str, out_path: str, codec: M3U8_Codec = None):
     # Insert input video path
     ffmpeg_cmd.extend(['-i', video_path])
 
-    # Add output Parameters
-    if USE_CODEC and codec is not None:
-        if USE_VCODEC:
-            if codec.video_codec_name: 
-                if not USE_GPU: 
-                    ffmpeg_cmd.extend(['-c:v', codec.video_codec_name])
-                else: 
-                    ffmpeg_cmd.extend(['-c:v', 'h264_nvenc'])
-            else: 
-                console.log("[red]Cant find vcodec for 'join_audios'")
-        else:
-            if USE_GPU:
-                ffmpeg_cmd.extend(['-c:v', 'h264_nvenc'])
-
-
-        if USE_ACODEC:
-            if codec.audio_codec_name: 
-                ffmpeg_cmd.extend(['-c:a', codec.audio_codec_name])
-            else: 
-                console.log("[red]Cant find acodec for 'join_audios'")
-
-        if USE_BITRATE:
-            ffmpeg_cmd.extend(['-b:v',  f'{codec.video_bitrate // 1000}k'])
-            ffmpeg_cmd.extend(['-b:a',  f'{codec.audio_bitrate // 1000}k'])
-
-    else:
-        ffmpeg_cmd.extend(['-c', 'copy'])
-
-    # Ultrafast preset always or fast for gpu
-    if not USE_GPU:
-        ffmpeg_cmd.extend(['-preset', FFMPEG_DEFAULT_PRESET])
-    else:
-        ffmpeg_cmd.extend(['-preset', 'fast'])
+    # Add encoding parameters (prima dell'output)
+    add_encoding_params(ffmpeg_cmd)
 
-    # Overwrite
-    ffmpeg_cmd += [out_path, "-y"]
+    # Output file and overwrite
+    ffmpeg_cmd.extend([out_path, '-y'])
 
     # Run join
     if DEBUG_MODE:
@@ -169,6 +147,8 @@ def join_audios(video_path: str, audio_tracks: List[Dict[str, str]], out_path: s
         - audio_tracks (list[dict[str, str]]): A list of dictionaries containing information about audio tracks.
             Each dictionary should contain the 'path' and 'name' keys.
         - out_path (str): The path to save the output file.
+        - codec (M3U8_Codec): The video codec to use (non utilizzato con nuova configurazione).
+        - limit_duration_diff (float): Maximum duration difference in seconds.
     """
     use_shortest = False
     duration_diffs = []
@@ -210,59 +190,25 @@ def join_audios(video_path: str, audio_tracks: List[Dict[str, str]], out_path: s
     for i, audio_track in enumerate(audio_tracks):
         ffmpeg_cmd.extend(['-i', audio_track.get('path')])
 
-
     # Map the video and audio streams
-    ffmpeg_cmd.append('-map')
-    ffmpeg_cmd.append('0:v')            # Map video stream from the first input (video_path)
+    ffmpeg_cmd.extend(['-map', '0:v'])
     
     for i in range(1, len(audio_tracks) + 1):
-        ffmpeg_cmd.append('-map')
-        ffmpeg_cmd.append(f'{i}:a')     # Map audio streams from subsequent inputs
-
-    # Add output Parameters
-    if USE_CODEC:
-        if USE_VCODEC:
-            if codec.video_codec_name: 
-                if not USE_GPU: 
-                    ffmpeg_cmd.extend(['-c:v', codec.video_codec_name])
-                else: 
-                    ffmpeg_cmd.extend(['-c:v', 'h264_nvenc'])
-            else: 
-                console.log("[red]Cant find vcodec for 'join_audios'")
-        else:
-            if USE_GPU:
-                ffmpeg_cmd.extend(['-c:v', 'h264_nvenc'])
-
-        if USE_ACODEC:
-            if codec.audio_codec_name: 
-                ffmpeg_cmd.extend(['-c:a', codec.audio_codec_name])
-            else: 
-                console.log("[red]Cant find acodec for 'join_audios'")
-
-        if USE_BITRATE:
-            ffmpeg_cmd.extend(['-b:v',  f'{codec.video_bitrate // 1000}k'])
-            ffmpeg_cmd.extend(['-b:a',  f'{codec.audio_bitrate // 1000}k'])
+        ffmpeg_cmd.extend(['-map', f'{i}:a'])
 
-    else:
-        ffmpeg_cmd.extend(['-c', 'copy'])
-
-    # Ultrafast preset always or fast for gpu
-    if not USE_GPU:
-        ffmpeg_cmd.extend(['-preset', FFMPEG_DEFAULT_PRESET])
-    else:
-        ffmpeg_cmd.extend(['-preset', 'fast'])
+    # Add encoding parameters (prima di -shortest e output)
+    add_encoding_params(ffmpeg_cmd)
 
     # Use shortest input path if any audio track has significant difference
     if use_shortest:
         ffmpeg_cmd.extend(['-shortest', '-strict', 'experimental'])
 
-    # Overwrite
-    ffmpeg_cmd += [out_path, "-y"]
+    # Output file and overwrite
+    ffmpeg_cmd.extend([out_path, '-y'])
 
     # Run join
     if DEBUG_MODE:
         subprocess.run(ffmpeg_cmd, check=True)
-        
     else:
         capture_ffmpeg_real_time(ffmpeg_cmd, "[yellow]FFMPEG [cyan]Join audio")
         print()
@@ -294,11 +240,8 @@ def join_subtitle(video_path: str, subtitles_list: List[Dict[str, str]], out_pat
         ffmpeg_cmd += ["-map", f"{idx + 1}:s"]
         ffmpeg_cmd += ["-metadata:s:s:{}".format(idx), "title={}".format(subtitle['language'])]
 
-    # Add output Parameters
-    if USE_CODEC:
-        ffmpeg_cmd.extend(['-c:v', 'copy', '-c:a', 'copy', '-c:s', select_subtitle_encoder()])
-    else:
-        ffmpeg_cmd.extend(['-c', 'copy', '-c:s', select_subtitle_encoder()])
+    # For subtitles, we always use copy for video/audio and only encoder for subtitles
+    ffmpeg_cmd.extend(['-c:v', 'copy', '-c:a', 'copy', '-c:s', select_subtitle_encoder()])
 
     # Overwrite
     ffmpeg_cmd += [out_path, "-y"]
@@ -307,7 +250,6 @@ def join_subtitle(video_path: str, subtitles_list: List[Dict[str, str]], out_pat
     # Run join
     if DEBUG_MODE:
         subprocess.run(ffmpeg_cmd, check=True)
-
     else:
         capture_ffmpeg_real_time(ffmpeg_cmd, "[yellow]FFMPEG [cyan]Join subtitle")
         print()

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/Lib/TMBD/tmdb.py

@@ -4,13 +4,12 @@ import sys
 
 
 # External libraries
-import httpx
 from rich.console import Console
 
 
 # Internal utilities
 from .obj_tmbd import Json_film
-from StreamingCommunity.Util.config_json import config_manager
+from StreamingCommunity.Util.http_client import create_client
 from StreamingCommunity.Util.table import TVShowManager
 
 
@@ -18,7 +17,6 @@ from StreamingCommunity.Util.table import TVShowManager
 console = Console()
 table_show_manager = TVShowManager()
 api_key = "a800ed6c93274fb857ea61bd9e7256c5"
-MAX_TIMEOUT = config_manager.get_int("REQUESTS", "timeout")
 
 
 def get_select_title(table_show_manager, generic_obj):
@@ -113,7 +111,7 @@ class TheMovieDB:
 
         params['api_key'] = self.api_key
         url = f"{self.base_url}/{endpoint}"
-        response = httpx.get(url, params=params, timeout=MAX_TIMEOUT)
+        response = create_client().get(url, params=params)
         response.raise_for_status()
         
         return response.json()

StreamingCommunity/TelegramHelp/config.json

@@ -29,7 +29,6 @@
         "specific_list_audio": [
             "ita"
         ],
-        "download_subtitle": true,
         "merge_subs": true,
         "specific_list_subtitles": [
             "ita",

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.3.9'
+__version__ = '3.4.2'
 __author__ = 'Arrowar'
 __description__ = 'A command-line program to download film'
 __copyright__ = 'Copyright 2025'

StreamingCommunity/Util/config_json.py

@@ -318,7 +318,7 @@ class ConfigManager:
             logging.error(f"Download of {filename} failed: {e}")
             raise
     
-    def get(self, section: str, key: str, data_type: type = str, from_site: bool = False) -> Any:
+    def get(self, section: str, key: str, data_type: type = str, from_site: bool = False, default: Any = None) -> Any:
         """
         Read a value from the configuration.
         
@@ -327,9 +327,10 @@ class ConfigManager:
             key (str): Key to read
             data_type (type, optional): Expected data type. Default: str
             from_site (bool, optional): Whether to read from the site configuration. Default: False
+            default (Any, optional): Default value if key is not found. Default: None
             
         Returns:
-            Any: The key value converted to the specified data type
+            Any: The key value converted to the specified data type, or default if not found
         """
         cache_key = f"{'site' if from_site else 'config'}.{section}.{key}"
         logging.info(f"Reading key: {cache_key}")
@@ -343,9 +344,15 @@ class ConfigManager:
         
         # Check if the section and key exist
         if section not in config_source:
+            if default is not None:
+                logging.info(f"Section '{section}' not found. Returning default value.")
+                return default
             raise ValueError(f"Section '{section}' not found in {'site' if from_site else 'main'} configuration")
         
         if key not in config_source[section]:
+            if default is not None:
+                logging.info(f"Key '{key}' not found in section '{section}'. Returning default value.")
+                return default
             raise ValueError(f"Key '{key}' not found in section '{section}' of {'site' if from_site else 'main'} configuration")
         
         # Get and convert the value
@@ -356,7 +363,7 @@ class ConfigManager:
         self.cache[cache_key] = converted_value
         
         return converted_value
-    
+
     def _convert_to_data_type(self, value: Any, data_type: type) -> Any:
         """
         Convert the value to the specified data type.
@@ -399,30 +406,30 @@ class ConfigManager:
             raise ValueError(f"Cannot convert '{value}' to {data_type.__name__}: {str(e)}")
     
     # Getters for main configuration
-    def get_string(self, section: str, key: str) -> str:
+    def get_string(self, section: str, key: str, default: str = None) -> str:
         """Read a string from the main configuration."""
-        return self.get(section, key, str)
-    
-    def get_int(self, section: str, key: str) -> int:
+        return self.get(section, key, str, default=default)
+
+    def get_int(self, section: str, key: str, default: int = None) -> int:
         """Read an integer from the main configuration."""
-        return self.get(section, key, int)
-    
-    def get_float(self, section: str, key: str) -> float:
+        return self.get(section, key, int, default=default)
+
+    def get_float(self, section: str, key: str, default: float = None) -> float:
         """Read a float from the main configuration."""
-        return self.get(section, key, float)
-    
-    def get_bool(self, section: str, key: str) -> bool:
+        return self.get(section, key, float, default=default)
+
+    def get_bool(self, section: str, key: str, default: bool = None) -> bool:
         """Read a boolean from the main configuration."""
-        return self.get(section, key, bool)
-    
-    def get_list(self, section: str, key: str) -> List[str]:
+        return self.get(section, key, bool, default=default)
+
+    def get_list(self, section: str, key: str, default: List[str] = None) -> List[str]:
         """Read a list from the main configuration."""
-        return self.get(section, key, list)
-    
-    def get_dict(self, section: str, key: str) -> dict:
+        return self.get(section, key, list, default=default)
+
+    def get_dict(self, section: str, key: str, default: dict = None) -> dict:
         """Read a dictionary from the main configuration."""
-        return self.get(section, key, dict)
-    
+        return self.get(section, key, dict, default=default)
+
     # Getters for site configuration
     def get_site(self, section: str, key: str) -> Any:
         """Read a value from the site configuration."""

StreamingCommunity/Util/http_client.py

@@ -8,6 +8,7 @@ from typing import Any, Dict, Optional, Union
 
 # External library
 import httpx
+from curl_cffi import requests
 
 
 # Logic class
@@ -104,6 +105,33 @@ def create_async_client(
     )
 
 
+def create_client_curl(
+    *,
+    headers: Optional[Dict[str, str]] = None,
+    cookies: Optional[Dict[str, str]] = None,
+    timeout: Optional[Union[int, float]] = None,
+    verify: Optional[bool] = None,
+    proxies: Optional[Dict[str, str]] = None,
+    impersonate: str = "chrome136",
+    allow_redirects: bool = True,
+):
+    """Factory for a configured curl_cffi session."""
+    session = requests.Session()
+    session.headers.update(_default_headers(headers))
+    if cookies:
+        session.cookies.update(cookies)
+    session.timeout = timeout if timeout is not None else _get_timeout()
+    session.verify = _get_verify() if verify is None else verify
+    if proxies is not None:
+        session.proxies = proxies
+    elif _get_proxies():
+        session.proxies = _get_proxies()
+    session.impersonate = impersonate
+    session.allow_redirects = allow_redirects
+    
+    return session
+
+
 def _sleep_with_backoff(attempt: int, base: float = 1.1, cap: float = 10.0) -> None:
     """Exponential backoff with jitter."""
     delay = min(base * (2 ** attempt), cap)

StreamingCommunity/Util/os.py

@@ -71,27 +71,37 @@ class OsManager:
 
         return normalized
 
-    def get_sanitize_file(self, filename: str) -> str:
-        """Sanitize filename."""
+    def get_sanitize_file(self, filename: str, year: str = None) -> str:
+        """Sanitize filename. Optionally append a year in format ' (YYYY)' if year is provided and valid."""
         if not filename:
             return filename
 
-        # Decode and sanitize
+        # Extract and validate year if provided
+        year_str = ""
+        if year:
+            y = str(year).split('-')[0].strip()
+            if y.isdigit() and len(y) == 4:
+                year_str = f" ({y})"
+
+        # Decode and sanitize base filename
         decoded = unidecode(filename)
         sanitized = sanitize_filename(decoded)
 
         # Split name and extension
         name, ext = os.path.splitext(sanitized)
 
+        # Append year if present
+        name_with_year = name + year_str
+
         # Calculate available length for name considering the '...' and extension
         max_name_length = self.max_length - len('...') - len(ext)
 
         # Truncate name if it exceeds the max name length
-        if len(name) > max_name_length:
-            name = name[:max_name_length] + '...'
+        if len(name_with_year) > max_name_length:
+            name_with_year = name_with_year[:max_name_length] + '...'
 
         # Ensure the final file name includes the extension
-        return name + ext
+        return name_with_year + ext
 
     def get_sanitize_path(self, path: str) -> str:
         """Sanitize complete path."""

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'

{streamingcommunity-3.3.9.dist-info → streamingcommunity-3.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: StreamingCommunity
-Version: 3.3.9
+Version: 3.4.2
 Home-page: https://github.com/Arrowar/StreamingCommunity
 Author: Arrowar
 Project-URL: Bug Reports, https://github.com/Arrowar/StreamingCommunity/issues
@@ -182,7 +182,6 @@ mpd_url = "https://example.com/stream.mpd"
 license_url = "https://example.com/get_license"
 
 dash_process = DASH_Downloader(
-    cdm_device=get_wvd_path(),
     license_url=license_url,
     mpd_url=mpd_url,
     output_path="output.mp4",
@@ -267,7 +266,6 @@ To enable qBittorrent integration, follow the setup guide [here](https://github.
         "specific_list_audio": [
             "ita"
         ],
-        "download_subtitle": true,
         "merge_subs": true,
         "specific_list_subtitles": [
             "ita",    // Specify language codes or use ["*"] to download all available subtitles