StreamingCommunity 2.9.8__py3-none-any.whl → 3.0.0__py3-none-any.whl

StreamingCommunity/Api/Site/streamingcommunity/__init__.py

@@ -26,8 +26,7 @@ from .series import download_series
 # Variable
 indice = 0
 _useFor = "film_serie"
-_deprecate = False
-_priority = 1
+_priority = 0
 _engineDownload = "hls"
 
 msg = Prompt()
@@ -58,52 +57,59 @@ def get_user_input(string_to_search: str = None):
 
     return string_to_search
 
-def process_search_result(select_title):
+def process_search_result(select_title, selections=None):
     """
     Handles the search result and initiates the download for either a film or series.
+    
+    Parameters:
+        select_title (MediaItem): The selected media item
+        selections (dict, optional): Dictionary containing selection inputs that bypass manual input
+                                    {'season': season_selection, 'episode': episode_selection}
     """
     if select_title.type == 'tv':
-        download_series(select_title)
+        season_selection = None
+        episode_selection = None
+        
+        if selections:
+            season_selection = selections.get('season')
+            episode_selection = selections.get('episode')
+
+        download_series(select_title, season_selection, episode_selection)
+
     else:
         download_film(select_title)
 
-def search(string_to_search: str = None, get_onlyDatabase: bool = False, direct_item: dict = None):
+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 film, series and anime.
+    Main function of the application for search.
 
     Parameters:
         string_to_search (str, optional): String to search for
-        get_onylDatabase (bool, optional): If True, return only the database object
+        get_onlyDatabase (bool, optional): If True, return only the database object
         direct_item (dict, optional): Direct item to process (bypass search)
+        selections (dict, optional): Dictionary containing selection inputs that bypass manual input
+                                    {'season': season_selection, 'episode': episode_selection}
     """
     if direct_item:
         select_title = MediaItem(**direct_item)
-        process_search_result(select_title)
+        process_search_result(select_title, selections)
         return
-    
-    # Get the user input for the search term
-    string_to_search = get_user_input(string_to_search)
-    
-    # Perform the database search
-    len_database = title_search(quote_plus(string_to_search))
+
+    if string_to_search is None:
+        string_to_search = msg.ask(f"\n[purple]Insert a word to search in [green]{site_constant.SITE_NAME}").strip()
+
+    # Search on database
+    len_database = title_search(string_to_search)
 
     # If only the database is needed, return the manager
     if get_onlyDatabase:
         return media_search_manager
     
-    if site_constant.TELEGRAM_BOT:
-        bot = get_bot_instance()
-        
     if len_database > 0:
         select_title = get_select_title(table_show_manager, media_search_manager)
-        process_search_result(select_title)
+        process_search_result(select_title, selections)
     
     else:
-        console.print(f"\n[red]Nothing matching was found for[white]: [purple]{string_to_search}")
-
-        if site_constant.TELEGRAM_BOT:
-            bot.send_message(f"No results found, please try again", None)
-
         # If no results are found, ask again
-        string_to_search = get_user_input()
+        console.print(f"\n[red]Nothing matching was found for[white]: [purple]{string_to_search}")
         search()

StreamingCommunity/Api/Site/streamingcommunity/film.py

@@ -55,8 +55,7 @@ def download_film(select_title: MediaItem) -> str:
     console.print(f"[bold yellow]Download:[/bold yellow] [red]{site_constant.SITE_NAME}[/red] → [cyan]{select_title.name}[/cyan] \n")
 
     # Init class
-    video_source = VideoSource(site_constant.FULL_URL, False)
-    video_source.setup(select_title.id)
+    video_source = VideoSource(site_constant.FULL_URL, False, select_title.id)
 
     # Retrieve scws and if available master playlist
     video_source.get_iframe(select_title.id)

StreamingCommunity/Api/Site/streamingcommunity/series.py

@@ -39,28 +39,22 @@ console = Console()
 
 def download_video(index_season_selected: int, index_episode_selected: int, scrape_serie: GetSerieInfo, video_source: VideoSource) -> Tuple[str,bool]:
     """
-    Download a single episode video.
+    Downloads a specific episode from the specified season.
 
     Parameters:
-        - index_season_selected (int): Index of the selected season.
-        - index_episode_selected (int): Index of the selected episode.
-
-    Return:
-        - str: output path
-        - bool: kill handler status
+        - index_season_selected (int): Season number
+        - index_episode_selected (int): Episode index
+        - scrape_serie (GetSerieInfo): Scraper object with series information
+        - video_source (VideoSource): Video source handler
+
+    Returns:
+        - str: Path to downloaded file
+        - bool: Whether download was stopped
     """
     start_message()
-    index_season_selected = dynamic_format_number(str(index_season_selected))
-
-    # SPECIAL: Get season number
-    season = None
-    for s in scrape_serie.seasons_manager.seasons:
-        if s.number == int(index_season_selected):
-            season = s
-            break
 
-    # Get info about episode
-    obj_episode = season.episodes.get(index_episode_selected - 1)
+    # 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")
 
     if site_constant.TELEGRAM_BOT:
@@ -98,28 +92,28 @@ def download_video(index_season_selected: int, index_episode_selected: int, scra
 
     return r_proc['path'], r_proc['stopped']
 
-def download_episode(index_season_selected: int, scrape_serie: GetSerieInfo, video_source: VideoSource, download_all: bool = False) -> None:
+
+def download_episode(index_season_selected: int, scrape_serie: GetSerieInfo, video_source: VideoSource, download_all: bool = False, episode_selection: str = None) -> None:
     """
-    Download episodes of a selected season.
+    Handle downloading episodes for a specific season.
 
     Parameters:
-        - index_season_selected (int): Index of the selected season.
-        - download_all (bool): Download all episodes in the season.
+        - index_season_selected (int): Season number
+        - scrape_serie (GetSerieInfo): Scraper object with series information
+        - video_source (VideoSource): Video source object
+        - download_all (bool): Whether to download all episodes
+        - episode_selection (str, optional): Pre-defined episode selection that bypasses manual input
     """
-    start_message()
-    scrape_serie.collect_info_season(index_season_selected)
-    
-    # SPECIAL: Get season number
-    season = None
-    for s in scrape_serie.seasons_manager.seasons:
-        if s.number == index_season_selected:
-            season = s
-            break
-    episodes_count = len(season.episodes.episodes)
+    # Get episodes for the selected season
+    episodes = scrape_serie.getEpisodeSeasons(index_season_selected)
+    episodes_count = len(episodes)
 
-    if download_all:
+    if episodes_count == 0:
+        console.print(f"[red]No episodes found for season {index_season_selected}")
+        return
 
-        # Download all episodes without asking
+    if download_all:
+        # Download all episodes in the season
         for i_episode in range(1, episodes_count + 1):
             path, stopped = download_video(index_season_selected, i_episode, scrape_serie, video_source)
 
@@ -129,16 +123,16 @@ def download_episode(index_season_selected: int, scrape_serie: GetSerieInfo, vid
         console.print(f"\n[red]End downloaded [yellow]season: [red]{index_season_selected}.")
 
     else:
-
         # Display episodes list and manage user selection
-        last_command = display_episodes_list(season.episodes.episodes)
+        if episode_selection is None:
+            last_command = display_episodes_list(episodes)
+        else:
+            last_command = episode_selection
+            console.print(f"\n[cyan]Using provided episode selection: [yellow]{episode_selection}")
+        
+        # Validate the selection
         list_episode_select = manage_selection(last_command, episodes_count)
-
-        try:
-            list_episode_select = validate_episode_selection(list_episode_select, episodes_count)
-        except ValueError as e:
-            console.print(f"[red]{str(e)}")
-            return
+        list_episode_select = validate_episode_selection(list_episode_select, episodes_count)
 
         # Download selected episodes if not stopped
         for i_episode in list_episode_select:
@@ -147,70 +141,65 @@ def download_episode(index_season_selected: int, scrape_serie: GetSerieInfo, vid
             if stopped:
                 break
 
-def download_series(select_season: MediaItem) -> None:
+
+def download_series(select_season: MediaItem, season_selection: str = None, episode_selection: str = None) -> None:
     """
-    Download episodes of a TV series based on user selection.
+    Handle downloading a complete series.
 
     Parameters:
-        - select_season (MediaItem): Selected media item (TV series).
-        - domain (str): Domain from which to download.
+        - select_season (MediaItem): Series metadata from search
+        - season_selection (str, optional): Pre-defined season selection that bypasses manual input
+        - episode_selection (str, optional): Pre-defined episode selection that bypasses manual input
     """
-    if site_constant.TELEGRAM_BOT:
-        bot = get_bot_instance()
-
-    # Start message and set up video source
     start_message()
 
     # Init class
-    scrape_serie = GetSerieInfo(site_constant.FULL_URL)
-    video_source = VideoSource(site_constant.FULL_URL, True)
-
-    # Setup video source
-    scrape_serie.setup(select_season.id, select_season.slug)
-    video_source.setup(select_season.id)
+    video_source = VideoSource(site_constant.FULL_URL, True, select_season.id)
+    scrape_serie = GetSerieInfo(site_constant.FULL_URL, select_season.id, select_season.name)
 
-    # Collect information about seasons
-    scrape_serie.collect_info_title()
+    # Collect information about season
+    scrape_serie.getNumberSeason()
     seasons_count = len(scrape_serie.seasons_manager)
 
+    if site_constant.TELEGRAM_BOT:
+        bot = get_bot_instance()
+
     # Prompt user for season selection and download episodes
     console.print(f"\n[green]Seasons found: [red]{seasons_count}")
 
-    if site_constant.TELEGRAM_BOT:
-        console.print("\n[cyan]Insert season number [yellow](e.g., 1), [red]* [cyan]to download all seasons, "
-          "[yellow](e.g., 1-2) [cyan]for a range of seasons, or [yellow](e.g., 3-*) [cyan]to download from a specific season to the end")
-
-        bot.send_message(f"Stagioni trovate: {seasons_count}", None)
-
-        index_season_selected = bot.ask(
-            "select_title_episode",
-            "Menu di selezione delle stagioni\n\n"
-            "- Inserisci il numero della stagione (ad esempio, 1)\n"
-            "- Inserisci * per scaricare tutte le stagioni\n"
-            "- Inserisci un intervallo di stagioni (ad esempio, 1-2) per scaricare da una stagione all'altra\n"
-            "- Inserisci (ad esempio, 3-*) per scaricare dalla stagione specificata fino alla fine della serie",
-            None
-        )
+    # If season_selection is provided, use it instead of asking for input
+    if season_selection is None:
+        if site_constant.TELEGRAM_BOT:
+            console.print("\n[cyan]Insert season number [yellow](e.g., 1), [red]* [cyan]to download all seasons, "
+              "[yellow](e.g., 1-2) [cyan]for a range of seasons, or [yellow](e.g., 3-*) [cyan]to download from a specific season to the end")
+
+            bot.send_message(f"Stagioni trovate: {seasons_count}", None)
+
+            index_season_selected = bot.ask(
+                "select_title_episode",
+                "Menu di selezione delle stagioni\n\n"
+                "- Inserisci il numero della stagione (ad esempio, 1)\n"
+                "- Inserisci * per scaricare tutte le stagioni\n"
+                "- Inserisci un intervallo di stagioni (ad esempio, 1-2) per scaricare da una stagione all'altra\n"
+                "- Inserisci (ad esempio, 3-*) per scaricare dalla stagione specificata fino alla fine della serie",
+                None
+            )
 
+        else:
+            index_season_selected = msg.ask(
+                "\n[cyan]Insert season number [yellow](e.g., 1), [red]* [cyan]to download all seasons, "
+                "[yellow](e.g., 1-2) [cyan]for a range of seasons, or [yellow](e.g., 3-*) [cyan]to download from a specific season to the end"
+            )
     else:
-        index_season_selected = msg.ask(
-            "\n[cyan]Insert season number [yellow](e.g., 1), [red]* [cyan]to download all seasons, "
-            "[yellow](e.g., 1-2) [cyan]for a range of seasons, or [yellow](e.g., 3-*) [cyan]to download from a specific season to the end"
-        )
+        index_season_selected = season_selection
+        console.print(f"\n[cyan]Using provided season selection: [yellow]{season_selection}")
 
-    # Manage and validate the selection
+    # Validate the selection
     list_season_select = manage_selection(index_season_selected, seasons_count)
-
-    try:
-        list_season_select = validate_selection(list_season_select, seasons_count)
-    except ValueError as e:
-        console.print(f"[red]{str(e)}")
-        return
+    list_season_select = validate_selection(list_season_select, seasons_count)
 
     # Loop through the selected seasons and download episodes
     for i_season in list_season_select:
-
-        # SPECIAL: Get season number
         season = None
         for s in scrape_serie.seasons_manager.seasons:
             if s.number == i_season:
@@ -219,13 +208,10 @@ def download_series(select_season: MediaItem) -> None:
         season_number = season.number
 
         if len(list_season_select) > 1 or index_season_selected == "*":
-
-            # Download all episodes if multiple seasons are selected or if '*' is used
             download_episode(season_number, scrape_serie, video_source, download_all=True)
+            
         else:
-
-            # Otherwise, let the user select specific episodes for the single season
-            download_episode(season_number, scrape_serie, video_source, download_all=False)
+            download_episode(season_number, scrape_serie, video_source, download_all=False, episode_selection=episode_selection)
 
     if site_constant.TELEGRAM_BOT:
         bot.send_message(f"Finito di scaricare tutte le serie e episodi", None)

StreamingCommunity/Api/Site/streamingcommunity/site.py

@@ -1,7 +1,5 @@
 # 10.12.23
 
-import sys
-
 
 # External libraries
 import httpx
@@ -47,7 +45,13 @@ def title_search(query: str) -> int:
     console.print(f"[cyan]Search url: [yellow]{search_url}")
 
     try:
-        response = httpx.get(search_url, headers={'user-agent': get_userAgent()}, timeout=max_timeout, follow_redirects=True)
+        response = httpx.get(
+            search_url, 
+            headers={'user-agent': get_userAgent()}, 
+            timeout=max_timeout, 
+            follow_redirects=True, 
+            verify=False
+        )
         response.raise_for_status()
 
     except Exception as e:
@@ -75,7 +79,7 @@ def title_search(query: str) -> int:
                 'name': dict_title.get('name'),
                 'type': dict_title.get('type'),
                 'date': dict_title.get('last_air_date'),
-                'score': dict_title.get('score')
+                'image': f"{site_constant.FULL_URL.replace('stream', 'cdn.stream')}/images/{dict_title.get('images')[0].get('filename')}"
             })
 
             if site_constant.TELEGRAM_BOT:

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

@@ -20,31 +20,21 @@ max_timeout = config_manager.get_int("REQUESTS", "timeout")
 
 
 class GetSerieInfo:
-    def __init__(self, url):
+    def __init__(self, url, media_id: int = None, series_name: str = None):
         """
         Initialize the GetSerieInfo class for scraping TV series information.
         
         Args:
             - url (str): The URL of the streaming site.
+            - media_id (int, optional): Unique identifier for the media
+            - series_name (str, optional): Name of the TV series
         """
         self.is_series = False
         self.headers = {'user-agent': get_userAgent()}
         self.url = url
-
-        # Initialize the SeasonManager
-        self.seasons_manager = SeasonManager()
-
-    def setup(self, media_id: int = None, series_name: str = None):
-        """
-        Set up the scraper with specific media details.
-        
-        Args:
-            media_id (int, optional): Unique identifier for the media
-            series_name (str, optional): Name of the TV series
-        """
         self.media_id = media_id
+        self.seasons_manager = SeasonManager()
 
-        # If series name is provided, initialize series-specific properties
         if series_name is not None:
             self.is_series = True
             self.series_name = series_name
@@ -127,4 +117,40 @@ class GetSerieInfo:
 
         except Exception as e:
             logging.error(f"Error collecting episodes for season {number_season}: {e}")
-            raise
+            raise
+
+    # ------------- FOR GUI -------------
+    def getNumberSeason(self) -> int:
+        """
+        Get the total number of seasons available for the series.
+        """
+        if not self.seasons_manager.seasons:
+            self.collect_info_title()
+            
+        return len(self.seasons_manager.seasons)
+    
+    def getEpisodeSeasons(self, season_number: int) -> list:
+        """
+        Get all episodes for a specific season.
+        """
+        season = self.seasons_manager.get_season_by_number(season_number)
+
+        if not season:
+            logging.error(f"Season {season_number} not found")
+            return []
+            
+        if not season.episodes.episodes:
+            self.collect_info_season(season_number)
+            
+        return season.episodes.episodes
+        
+    def selectEpisode(self, season_number: int, episode_index: int) -> dict:
+        """
+        Get information for a specific episode in a specific season.
+        """
+        episodes = self.getEpisodeSeasons(season_number)
+        if not episodes or episode_index < 0 or episode_index >= len(episodes):
+            logging.error(f"Episode index {episode_index} is out of range for season {season_number}")
+            return None
+            
+        return episodes[episode_index]

StreamingCommunity/Api/Template/site.py

@@ -10,7 +10,7 @@ from rich.console import Console
 # Variable
 console = Console()
 available_colors = ['red', 'magenta', 'yellow', 'cyan', 'green', 'blue', 'white']
-column_to_hide = ['Slug', 'Sub_ita', 'Last_air_date', 'Seasons_count', 'Url']
+column_to_hide = ['Slug', 'Sub_ita', 'Last_air_date', 'Seasons_count', 'Url', 'Image', 'Path_id']
 
 
 def get_select_title(table_show_manager, media_search_manager):
@@ -81,4 +81,4 @@ def get_select_title(table_show_manager, media_search_manager):
     
     else:
         console.print("\n[red]Wrong index")
-        sys.exit(0)
+        sys.exit(0)

StreamingCommunity/Lib/Downloader/HLS/downloader.py

@@ -514,7 +514,7 @@ class HLS_Downloader:
         for item in self.download_manager.missing_segments:
             if int(item['nFailed']) >= 1:
                 missing_ts = True
-                missing_info += f"[red]TS Failed: {item['nFailed']} {item['type']} tracks[/red]\n"
+                missing_info += f"[red]TS Failed: {item['nFailed']} {item['type']} tracks[/red]"
 
         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)

StreamingCommunity/Lib/Downloader/HLS/segments.py

@@ -23,7 +23,7 @@ from rich.console import Console
 # Internal utilities
 from StreamingCommunity.Util.color import Colors
 from StreamingCommunity.Util.headers import get_userAgent
-from StreamingCommunity.Util.config_json import config_manager, get_use_large_bar
+from StreamingCommunity.Util.config_json import config_manager
 
 
 # Logic class
@@ -41,10 +41,9 @@ REQUEST_VERIFY = config_manager.get_bool('REQUESTS', 'verify')
 DEFAULT_VIDEO_WORKERS = config_manager.get_int('M3U8_DOWNLOAD', 'default_video_workser')
 DEFAULT_AUDIO_WORKERS = config_manager.get_int('M3U8_DOWNLOAD', 'default_audio_workser')
 MAX_TIMEOOUT = config_manager.get_int("REQUESTS", "timeout")
-MAX_INTERRUPT_COUNT = 3
 SEGMENT_MAX_TIMEOUT = config_manager.get_int("M3U8_DOWNLOAD", "segment_timeout")
 TELEGRAM_BOT = config_manager.get_bool('DEFAULT', 'telegram_bot')
-
+MAX_INTERRUPT_COUNT = 3
 
 # Variable
 console = Console()
@@ -160,7 +159,7 @@ class M3U8_Segments:
         if self.is_index_url:
             try:
                 client_params = {'headers': {'User-Agent': get_userAgent()}, 'timeout': MAX_TIMEOOUT}
-                response = httpx.get(self.url, **client_params)
+                response = httpx.get(self.url, **client_params, follow_redirects=True)
                 response.raise_for_status()
                 
                 self.parse_data(response.text)
@@ -408,20 +407,12 @@ class M3U8_Segments:
         """
         Generate platform-appropriate progress bar format.
         """
-        if not get_use_large_bar():
-            return (
-                f"{Colors.YELLOW}Proc{Colors.WHITE}: "
-                f"{Colors.RED}{{percentage:.2f}}% "
-                f"{Colors.CYAN}{{remaining}}{{postfix}} {Colors.WHITE}]"
-            )
-            
-        else:
-            return (
-                f"{Colors.YELLOW}[HLS] {Colors.WHITE}({Colors.CYAN}{description}{Colors.WHITE}): "
-                f"{Colors.RED}{{percentage:.2f}}% "
-                f"{Colors.MAGENTA}{{bar}} "
-                f"{Colors.YELLOW}{{elapsed}}{Colors.WHITE} < {Colors.CYAN}{{remaining}}{Colors.WHITE}{{postfix}}{Colors.WHITE}"
-            )
+        return (
+            f"{Colors.YELLOW}[HLS] {Colors.WHITE}({Colors.CYAN}{description}{Colors.WHITE}): "
+            f"{Colors.RED}{{percentage:.2f}}% "
+            f"{Colors.MAGENTA}{{bar}} "
+            f"{Colors.YELLOW}{{elapsed}}{Colors.WHITE} < {Colors.CYAN}{{remaining}}{Colors.WHITE}{{postfix}}{Colors.WHITE}"
+        )
     
     def _get_worker_count(self, stream_type: str) -> int:
         """

StreamingCommunity/Lib/Downloader/MP4/downloader.py

@@ -21,7 +21,7 @@ from rich.panel import Panel
 from StreamingCommunity.Util.headers import get_userAgent
 from StreamingCommunity.Util.color import Colors
 from StreamingCommunity.Util.config_json import config_manager
-from StreamingCommunity.Util.os import internet_manager
+from StreamingCommunity.Util.os import internet_manager, os_manager
 from StreamingCommunity.TelegramHelp.telegram_bot import get_bot_instance
 
 
@@ -80,6 +80,7 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
         bot = get_bot_instance()
         console.log("####")
 
+    path = os_manager.get_sanitize_path(path)
     if os.path.exists(path):
         console.log("[red]Output file already exists.")
         if TELEGRAM_BOT:

StreamingCommunity/Lib/Downloader/TOR/downloader.py

@@ -18,7 +18,7 @@ import qbittorrentapi
 # Internal utilities
 from StreamingCommunity.Util.color import Colors
 from StreamingCommunity.Util.os import internet_manager
-from StreamingCommunity.Util.config_json import config_manager, get_use_large_bar
+from StreamingCommunity.Util.config_json import config_manager
 
 
 # Configuration
@@ -316,19 +316,12 @@ class TOR_downloader:
             # Ensure the torrent is started
             self.qb.torrents_resume(torrent_hashes=self.latest_torrent_hash)
             
-            # Configure progress bar display format based on device
-            if get_use_large_bar():
-                bar_format = (
-                    f"{Colors.YELLOW}[TOR] {Colors.WHITE}({Colors.CYAN}video{Colors.WHITE}): "
-                    f"{Colors.RED}{{percentage:.2f}}% {Colors.MAGENTA}{{bar}} {Colors.WHITE}[ "
-                    f"{Colors.YELLOW}{{elapsed}} {Colors.WHITE}< {Colors.CYAN}{{remaining}}{{postfix}} {Colors.WHITE}]"
-                )
-            else:
-                bar_format = (
-                    f"{Colors.YELLOW}Proc{Colors.WHITE}: "
-                    f"{Colors.RED}{{percentage:.2f}}% {Colors.WHITE}| "
-                    f"{Colors.CYAN}{{remaining}}{{postfix}} {Colors.WHITE}]"
-                )
+            # Configure progress bar display format
+            bar_format = (
+                f"{Colors.YELLOW}[TOR] {Colors.WHITE}({Colors.CYAN}video{Colors.WHITE}): "
+                f"{Colors.RED}{{percentage:.2f}}% {Colors.MAGENTA}{{bar}} {Colors.WHITE}[ "
+                f"{Colors.YELLOW}{{elapsed}} {Colors.WHITE}< {Colors.CYAN}{{remaining}}{{postfix}} {Colors.WHITE}]"
+            )
 
             # Initialize progress bar
             with tqdm(

StreamingCommunity/Lib/FFmpeg/capture.py

@@ -36,11 +36,7 @@ def capture_output(process: subprocess.Popen, description: str) -> None:
                 if not line:
                     continue
 
-                logging.info(f"FFMPEG line: {line}")
-
-                # Capture only error
-                if "rror" in str(line):
-                    console.log(f"[red]FFMPEG: {str(line).strip()}")
+                logging.info(f"CAPTURE ffmpeg line: {line}")
 
                 # Check if termination is requested
                 if terminate_flag.is_set():