StreamingCommunity 2.9.7__py3-none-any.whl → 2.9.9__py3-none-any.whl

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

@@ -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)

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/FFmpeg/util.py

@@ -138,26 +138,53 @@ def get_ffprobe_info(file_path):
 
     Returns:
         dict: A dictionary containing the format name and a list of codec names.
+              Returns None if file does not exist or ffprobe crashes.
     """
-    try:
-        result = subprocess.run(
-            [get_ffprobe_path(), '-v', 'error', '-show_format', '-show_streams', '-print_format', 'json', file_path],
-            stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, check=True
-        )
-        output = result.stdout
-        info = json.loads(output)
+    if not os.path.exists(file_path):
+        logging.error(f"File not found: {file_path}")
+        return None
         
-        format_name = info['format']['format_name'] if 'format' in info else None
-        codec_names = [stream['codec_name'] for stream in info['streams']] if 'streams' in info else []
+    try:
+        # Use subprocess.Popen instead of run to better handle crashes
+        cmd = [get_ffprobe_path(), '-v', 'error', '-show_format', '-show_streams', '-print_format', 'json', file_path]
+        logging.info(f"FFmpeg command: {cmd}")
         
-        return {
-            'format_name': format_name,
-            'codec_names': codec_names
-        }
+        with subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) as proc:
+            stdout, stderr = proc.communicate()
+            
+            if proc.returncode != 0:
+                logging.error(f"FFprobe failed with return code {proc.returncode} for file {file_path}")
+                if stderr:
+                    logging.error(f"FFprobe stderr: {stderr}")
+                return {
+                    'format_name': None,
+                    'codec_names': []
+                }
+            
+            # Make sure we have valid JSON before parsing
+            if not stdout or not stdout.strip():
+                logging.warning(f"FFprobe returned empty output for file {file_path}")
+                return {
+                    'format_name': None,
+                    'codec_names': []
+                }
+                
+            info = json.loads(stdout)
+            
+            format_name = info['format']['format_name'] if 'format' in info else None
+            codec_names = [stream['codec_name'] for stream in info['streams']] if 'streams' in info else []
+            
+            return {
+                'format_name': format_name,
+                'codec_names': codec_names
+            }
     
     except Exception as e:
-        logging.error(f"Failed to parse JSON output from ffprobe for file {file_path}: {e}")
-        return None
+        logging.error(f"Failed to get ffprobe info for file {file_path}: {e}")
+        return {
+            'format_name': None,
+            'codec_names': []
+        }
 
 
 def is_png_format_or_codec(file_info):
@@ -173,8 +200,11 @@ def is_png_format_or_codec(file_info):
     if not file_info:
         return False
     
-    #console.print(f"[yellow][FFmpeg] [cyan]Avaiable codec[white]: [red]{file_info['codec_names']}")
-    return file_info['format_name'] == 'png_pipe' or 'png' in file_info['codec_names']
+    # Handle None values in format_name gracefully
+    format_name = file_info.get('format_name')
+    codec_names = file_info.get('codec_names', [])
+    
+    return format_name == 'png_pipe' or 'png' in codec_names
 
 
 def need_to_force_to_ts(file_path):

StreamingCommunity/Lib/M3U8/estimator.py

@@ -31,16 +31,20 @@ class M3U8_Ts_Estimator:
         self.segments_instance = segments_instance
         self.lock = threading.Lock()
         self.speed = {"upload": "N/A", "download": "N/A"}
+        self._running = True
 
         if get_use_large_bar():
             logging.debug("USE_LARGE_BAR is True, starting speed capture thread")
             self.speed_thread = threading.Thread(target=self.capture_speed)
             self.speed_thread.daemon = True
             self.speed_thread.start()
-
         else:
             logging.debug("USE_LARGE_BAR is False, speed capture thread not started")
 
+    def __del__(self):
+        """Ensure thread is properly stopped when the object is destroyed."""
+        self._running = False
+        
     def add_ts_file(self, size: int):
         """Add a file size to the list of file sizes."""
         if size <= 0:
@@ -50,32 +54,44 @@ class M3U8_Ts_Estimator:
         self.ts_file_sizes.append(size)
 
     def capture_speed(self, interval: float = 1.5):
-        """Capture the internet speed periodically."""
+        """Capture the internet speed periodically with improved efficiency."""
         last_upload, last_download = 0, 0
         speed_buffer = deque(maxlen=3)
         
-        while True:
+        while self._running:
             try:
+                # Get IO counters only once per loop to reduce function calls
                 io_counters = psutil.net_io_counters()
                 if not io_counters:
                     raise ValueError("No IO counters available")
                 
                 current_upload, current_download = io_counters.bytes_sent, io_counters.bytes_recv
+                
                 if last_upload and last_download:
                     upload_speed = (current_upload - last_upload) / interval
                     download_speed = (current_download - last_download) / interval
-                    speed_buffer.append(max(0, download_speed))
                     
+                    # Only update buffer when we have valid data
+                    if download_speed > 0:
+                        speed_buffer.append(download_speed)
+                    
+                    # Use a more efficient approach for thread synchronization
+                    avg_speed = sum(speed_buffer) / len(speed_buffer) if speed_buffer else 0
+                    formatted_upload = internet_manager.format_transfer_speed(max(0, upload_speed))
+                    formatted_download = internet_manager.format_transfer_speed(avg_speed)
+                    
+                    # Minimize lock time by preparing data outside the lock
                     with self.lock:
                         self.speed = {
-                            "upload": internet_manager.format_transfer_speed(max(0, upload_speed)),
-                            "download": internet_manager.format_transfer_speed(sum(speed_buffer) / len(speed_buffer))
+                            "upload": formatted_upload,
+                            "download": formatted_download
                         }
-                        logging.debug(f"Updated speeds - Upload: {self.speed['upload']}, Download: {self.speed['download']}")
                 
                 last_upload, last_download = current_upload, current_download
+                
             except Exception as e:
-                logging.error(f"Error in speed capture: {str(e)}")
+                if self._running:  # Only log if we're still supposed to be running
+                    logging.error(f"Error in speed capture: {str(e)}")
                 self.speed = {"upload": "N/A", "download": "N/A"}
             
             time.sleep(interval)
@@ -88,6 +104,10 @@ class M3U8_Ts_Estimator:
             str: The mean size of the files in a human-readable format.
         """
         try:
+            # Only do calculations if we have data
+            if not self.ts_file_sizes:
+                return "0 B"
+                
             total_size = sum(self.ts_file_sizes)
             mean_size = total_size / len(self.ts_file_sizes)
             return internet_manager.format_file_size(mean_size)
@@ -101,31 +121,40 @@ class M3U8_Ts_Estimator:
             self.add_ts_file(total_downloaded * self.total_segments)
             
             file_total_size = self.calculate_total_size()
+            if file_total_size == "Error":
+                return
+                
             number_file_total_size = file_total_size.split(' ')[0]
             units_file_total_size = file_total_size.split(' ')[1]
             
+            # Reduce lock contention by acquiring data with minimal synchronization
+            retry_count = 0
+            if self.segments_instance:
+                with self.segments_instance.active_retries_lock:
+                    retry_count = self.segments_instance.active_retries
+            
             if get_use_large_bar():
-                speed_data = self.speed['download'].split(" ")
+                # Get speed data outside of any locks
+                speed_data = ["N/A", ""]
+                with self.lock:
+                    download_speed = self.speed['download']
                 
-                if len(speed_data) >= 2:
-                    average_internet_speed = speed_data[0]
-                    average_internet_unit = speed_data[1]
-                else:
-                    average_internet_speed = "N/A"
-                    average_internet_unit = ""
+                if download_speed != "N/A":
+                    speed_data = download_speed.split(" ")
+                
+                average_internet_speed = speed_data[0] if len(speed_data) >= 1 else "N/A"
+                average_internet_unit = speed_data[1] if len(speed_data) >= 2 else ""
                 
-                retry_count = self.segments_instance.active_retries if self.segments_instance else 0
                 progress_str = (
                     f"{Colors.GREEN}{number_file_total_size} {Colors.RED}{units_file_total_size}"
-                    f"{Colors.WHITE}, {Colors.CYAN}{average_internet_speed} {Colors.RED}{average_internet_unit}"
-                    f"{Colors.WHITE}, {Colors.GREEN}CRR {Colors.RED}{retry_count} "
+                    f"{Colors.WHITE}, {Colors.CYAN}{average_internet_speed} {Colors.RED}{average_internet_unit} "
+                    #f"{Colors.WHITE}, {Colors.GREEN}CRR {Colors.RED}{retry_count} "
                 )
                 
             else:
-                retry_count = self.segments_instance.active_retries if self.segments_instance else 0
                 progress_str = (
-                    f"{Colors.GREEN}{number_file_total_size} {Colors.RED}{units_file_total_size}"
-                    f"{Colors.WHITE}, {Colors.GREEN}CRR {Colors.RED}{retry_count} "
+                    f"{Colors.GREEN}{number_file_total_size} {Colors.RED}{units_file_total_size} "
+                    #f"{Colors.WHITE}, {Colors.GREEN}CRR {Colors.RED}{retry_count} "
                 )
             
             progress_counter.set_postfix_str(progress_str)

StreamingCommunity/Lib/M3U8/parser.py

@@ -1,6 +1,6 @@
 # 20.04.25
 
-import sys
+import re
 import logging
 
 
@@ -418,18 +418,38 @@ class M3U8_Parser:
             - uri (str): The URI containing video information.
 
         Returns:
-            int: The video resolution if found, otherwise 0.
+            tuple: The video resolution (width, height) if found, otherwise (0, 0).
         """
-
         # Log
         logging.info(f"Try extract resolution from: {uri}")
-
+        
+        # First try: Check for known resolutions
         for resolution in RESOLUTIONS:
             if "http" in str(uri):
                 if str(resolution[1]) in uri:
                     return resolution
-            
-        # Default resolution return (not best)
+        
+        # Pattern to match common resolution formats like 854x480, 1280x720, etc.
+        resolution_patterns = [
+            r'(\d+)x(\d+)',  # Match format: 854x480
+            r'(\d+)p',       # Match format: 480p, 720p, etc.
+            r'_(\d+)x(\d+)'  # Match format: _854x480
+        ]
+        
+        for pattern in resolution_patterns:
+            matches = re.findall(pattern, uri)
+            if matches:
+                if len(matches[0]) == 2:  # Format like 854x480
+                    width, height = int(matches[0][0]), int(matches[0][1])
+                    return (width, height)
+                
+                elif len(matches[0]) == 1:  # Format like 480p
+                    height = int(matches[0])
+
+                    # Estimate width based on common aspect ratios (16:9)
+                    width = int(height * 16 / 9)
+                    return (width, height)
+        
         logging.warning("No resolution found with custom parsing.")
         return (0, 0)
 

StreamingCommunity/Upload/update.py

@@ -43,6 +43,13 @@ def update():
             timeout=config_manager.get_int("REQUESTS", "timeout"), 
             follow_redirects=True
         ).json()
+
+        response_commits = httpx.get(
+            url=f"https://api.github.com/repos/{__author__}/{__title__}/commits",
+            headers={'user-agent': get_userAgent()}, 
+            timeout=config_manager.get_int("REQUESTS", "timeout"), 
+            follow_redirects=True
+        ).json()
         
     except Exception as e:
         console.print(f"[red]Error accessing GitHub API: {e}")
@@ -66,11 +73,23 @@ def update():
     else:
         percentual_stars = 0
 
-    # Check installed version
-    if str(__version__).replace('v', '') != str(last_version).replace('v', '') :
+    # Get the current version (installed version)
+    current_version = __version__
+
+    # Get commit details
+    latest_commit = response_commits[0] if response_commits else None
+    if latest_commit:
+        latest_commit_message = latest_commit.get('commit', {}).get('message', 'No commit message')
+    else:
+        latest_commit_message = 'No commit history available'
+
+    console.print(f"\n[cyan]Current installed version: [yellow]{current_version}")
+    console.print(f"[cyan]Last commit: [yellow]{latest_commit_message}")
+    
+    if str(current_version).replace('v', '') != str(last_version).replace('v', ''):
         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\
         [cyan]Help the repository grow today by leaving a [yellow]star [cyan]and [yellow]sharing [cyan]it with others online!")
     
-    time.sleep(3)
+    time.sleep(3)

StreamingCommunity/Upload/version.py

@@ -1,5 +1,5 @@
 __title__ = 'StreamingCommunity'
-__version__ = '2.9.7'
+__version__ = '2.9.9'
 __author__ = 'Arrowar'
 __description__ = 'A command-line program to download film'
 __copyright__ = 'Copyright 2024'