StreamingCommunity 2.7.0__py3-none-any.whl → 2.9.0__py3-none-any.whl

StreamingCommunity/Lib/M3U8/decryptor.py

@@ -3,163 +3,89 @@
 import sys
 import time
 import logging
-import subprocess
 import importlib.util
 
 
-# Internal utilities
-from StreamingCommunity.Util.console import console
+# External library
+from rich.console import Console
 
 
-# Check if Crypto module is installed
+# Check if Cryptodome module is installed
+console = Console()
 crypto_spec = importlib.util.find_spec("Cryptodome")
 crypto_installed = crypto_spec is not None
 
+if not crypto_installed:
+    console.log("[red]pycryptodomex non è installato. Per favore installalo. Leggi readme.md [Requirement].")
+    sys.exit(0)
 
-if crypto_installed:
-    logging.info("[cyan]Decrypy use: Cryptodomex")
-    from Cryptodome.Cipher import AES
-    from Cryptodome.Util.Padding import unpad
+logging.info("[cyan]Decrypy use: Cryptodomex")
+from Cryptodome.Cipher import AES
+from Cryptodome.Util.Padding import unpad
 
-    class M3U8_Decryption:
+
+
+class M3U8_Decryption:
+    """
+    Class for decrypting M3U8 playlist content using AES with pycryptodomex.
+    """
+    def __init__(self, key: bytes, iv: bytes, method: str) -> None:
         """
-        Class for decrypting M3U8 playlist content using AES encryption when the Crypto module is available.
+        Initialize the M3U8_Decryption object.
+
+        Parameters:
+            key (bytes): The encryption key.
+            iv (bytes): The initialization vector (IV).
+            method (str): The encryption method.
         """
-        def __init__(self, key: bytes, iv: bytes, method: str) -> None:
-            """
-            Initialize the M3U8_Decryption object.
-
-            Parameters:
-                - key (bytes): The encryption key.
-                - iv (bytes): The initialization vector (IV).
-                - method (str): The encryption method.
-            """
-            self.key = key
-            self.iv = iv
-            if "0x" in str(iv): 
-                self.iv = bytes.fromhex(iv.replace("0x", ""))
-            self.method = method
-
-            # Precreate cipher based on encryption method
-            if self.method == "AES":
-                self.cipher = AES.new(self.key, AES.MODE_ECB)
-            elif self.method == "AES-128":
-                self.cipher = AES.new(self.key[:16], AES.MODE_CBC, iv=self.iv)
-            elif self.method == "AES-128-CTR":
-                self.cipher = AES.new(self.key[:16], AES.MODE_CTR, nonce=self.iv)
-            else:
-                raise ValueError("Invalid or unsupported method")
-
-        def decrypt(self, ciphertext: bytes) -> bytes:
-            """
-            Decrypt the ciphertext using the specified encryption method.
-
-            Parameters:
-                - ciphertext (bytes): The encrypted content to decrypt.
-
-            Returns:
-                bytes: The decrypted content.
-            """
-            start = time.perf_counter_ns()
-            #logging.info(f"Ciphertext: {ciphertext}")
-
-            # Decrypt based on encryption method
-            if self.method in {"AES", "AES-128"}:
-                decrypted_data = self.cipher.decrypt(ciphertext)
-                decrypted_content = unpad(decrypted_data, AES.block_size)
-                
-            elif self.method == "AES-128-CTR":
-                decrypted_content = self.cipher.decrypt(ciphertext)
-            else:
-                raise ValueError("Invalid or unsupported method")
-
-            end = time.perf_counter_ns() 
-
-            # Calculate elapsed time with high precision
-            elapsed_nanoseconds = end - start
-            elapsed_milliseconds = elapsed_nanoseconds / 1_000_000
-            elapsed_seconds = elapsed_nanoseconds / 1_000_000_000
-
-            # Print performance metrics
-            logging.info(f"[Crypto Decryption Performance]")
-            logging.info(f"Method: {self.method}")
-            logging.info(f"Decryption Time: {elapsed_milliseconds:.4f} ms ({elapsed_seconds:.6f} s)")
-            logging.info(f"Decrypted Content Length: {len(decrypted_content)} bytes")
-
-            return decrypted_content
-
-
-else:
-
-    # Check if openssl command is available
-    try:
-        openssl_available = subprocess.run(["openssl", "version"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL).returncode == 0
-        logging.info("[cyan]Decrypy use: OPENSSL")
-    except:
-        openssl_available = False
-
-    if not openssl_available:
-        console.log("[red]Neither python library: pycryptodomex nor openssl software is installed. Please install either one of them. Read readme.md [Requirement].")
-        sys.exit(0)
-
-    class M3U8_Decryption:
+        self.key = key
+        self.iv = iv
+        if "0x" in str(iv):
+            self.iv = bytes.fromhex(iv.replace("0x", ""))
+        self.method = method
+
+        # Pre-create the cipher based on the encryption method
+        if self.method == "AES":
+            self.cipher = AES.new(self.key, AES.MODE_ECB)
+        elif self.method == "AES-128":
+            self.cipher = AES.new(self.key[:16], AES.MODE_CBC, iv=self.iv)
+        elif self.method == "AES-128-CTR":
+            self.cipher = AES.new(self.key[:16], AES.MODE_CTR, nonce=self.iv)
+        else:
+            raise ValueError("Invalid or unsupported method")
+
+    def decrypt(self, ciphertext: bytes) -> bytes:
+        """
+        Decrypt the ciphertext using the specified encryption method.
+
+        Parameters:
+            ciphertext (bytes): The encrypted content to decrypt.
+
+        Returns:
+            bytes: The decrypted content.
+        """
+        #start = time.perf_counter_ns()
+
+        if self.method in {"AES", "AES-128"}:
+            decrypted_data = self.cipher.decrypt(ciphertext)
+            decrypted_content = unpad(decrypted_data, AES.block_size)
+        elif self.method == "AES-128-CTR":
+            decrypted_content = self.cipher.decrypt(ciphertext)
+        else:
+            raise ValueError("Invalid or unsupported method")
+
         """
-        Class for decrypting M3U8 playlist content using OpenSSL when the Crypto module is not available.
+        end = time.perf_counter_ns()
+
+        # Calculate the elapsed time with high precision
+        elapsed_nanoseconds = end - start
+        elapsed_milliseconds = elapsed_nanoseconds / 1_000_000
+        elapsed_seconds = elapsed_nanoseconds / 1_000_000_000
+
+        # Log performance metrics
+        logging.info("[Crypto Decryption Performance]")
+        logging.info(f"Method: {self.method}")
+        logging.info(f"Decryption Time: {elapsed_milliseconds:.4f} ms ({elapsed_seconds:.6f} s)")
+        logging.info(f"Decrypted Content Length: {len(decrypted_content)} bytes")
         """
-        def __init__(self, key: bytes, iv: bytes, method: str) -> None:
-            """
-            Initialize the M3U8_Decryption object.
-
-            Parameters:
-                - key (bytes): The encryption key.
-                - iv (bytes): The initialization vector (IV).
-                - method (str): The encryption method.
-            """
-            self.key = key
-            self.iv = iv
-            if "0x" in str(iv): 
-                self.iv = bytes.fromhex(iv.replace("0x", ""))
-            self.method = method
-            logging.info(f"Decrypt add: ('key': {self.key}, 'iv': {self.iv}, 'method': {self.method})")
-
-        def decrypt(self, ciphertext: bytes) -> bytes:
-            """
-            Decrypt the ciphertext using the specified encryption method.
-
-            Parameters:
-                - ciphertext (bytes): The encrypted content to decrypt.
-
-            Returns:
-                bytes: The decrypted content.
-            """
-            start = time.perf_counter_ns()
-
-            # Construct OpenSSL command based on encryption method
-            if self.method == "AES":
-                openssl_cmd = f'openssl enc -d -aes-256-ecb -K {self.key.hex()} -nosalt'
-            elif self.method == "AES-128":
-                openssl_cmd = f'openssl enc -d -aes-128-cbc -K {self.key[:16].hex()} -iv {self.iv.hex()}'
-            elif self.method == "AES-128-CTR":
-                openssl_cmd = f'openssl enc -d -aes-128-ctr -K {self.key[:16].hex()} -iv {self.iv.hex()}'
-            else:
-                raise ValueError("Invalid or unsupported method")
-
-            try:
-                decrypted_content = subprocess.check_output(openssl_cmd.split(), input=ciphertext, stderr=subprocess.STDOUT)
-            except subprocess.CalledProcessError as e:
-                raise ValueError(f"Decryption failed: {e.output.decode()}")
-
-            end = time.perf_counter_ns()
-
-            # Calculate elapsed time with high precision
-            elapsed_nanoseconds = end - start
-            elapsed_milliseconds = elapsed_nanoseconds / 1_000_000
-            elapsed_seconds = elapsed_nanoseconds / 1_000_000_000
-
-            # Print performance metrics
-            logging.info(f"[OpenSSL Decryption Performance]")
-            logging.info(f"Method: {self.method}")
-            logging.info(f"Decryption Time: {elapsed_milliseconds:.4f} ms ({elapsed_seconds:.6f} s)")
-            logging.info(f"Decrypted Content Length: {len(decrypted_content)} bytes")
-
-            return decrypted_content
+        return decrypted_content

StreamingCommunity/Lib/M3U8/estimator.py

@@ -14,13 +14,10 @@ from tqdm import tqdm
 
 # Internal utilities
 from StreamingCommunity.Util.color import Colors
+from StreamingCommunity.Util.config_json import get_use_large_bar
 from StreamingCommunity.Util.os import internet_manager
 
 
-# Variable
-USE_LARGE_BAR = not ("android" in sys.platform or "ios" in sys.platform)
-
-
 class M3U8_Ts_Estimator:
     def __init__(self, total_segments: int, segments_instance=None):
         """
@@ -36,7 +33,7 @@ class M3U8_Ts_Estimator:
         self.lock = threading.Lock()
         self.speed = {"upload": "N/A", "download": "N/A"}
 
-        if USE_LARGE_BAR:
+        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
@@ -106,15 +103,11 @@ class M3U8_Ts_Estimator:
         try:
             self.add_ts_file(total_downloaded * self.total_segments, total_downloaded, duration)
             
-            #downloaded_file_size_str = internet_manager.format_file_size(self.now_downloaded_size)
             file_total_size = self.calculate_total_size()
-            
-            #number_file_downloaded = downloaded_file_size_str.split(' ')[0]
             number_file_total_size = file_total_size.split(' ')[0]
-            #units_file_downloaded = downloaded_file_size_str.split(' ')[1]
             units_file_total_size = file_total_size.split(' ')[1]
             
-            if USE_LARGE_BAR:
+            if get_use_large_bar():
                 speed_data = self.speed['download'].split(" ")
                 
                 if len(speed_data) >= 2:
@@ -126,17 +119,16 @@ class M3U8_Ts_Estimator:
                 
                 retry_count = self.segments_instance.active_retries if self.segments_instance else 0
                 progress_str = (
-                    #f"{Colors.WHITE}[ {Colors.GREEN}{number_file_downloaded} {Colors.WHITE}< "
-                    f"{Colors.GREEN}{number_file_total_size} {Colors.RED}{units_file_total_size}"
+                    f"{Colors.GREEN}{number_file_total_size} {Colors.WHITE}< {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.GREEN}CRR {Colors.RED}{retry_count} "
                 )
+                
             else:
                 retry_count = self.segments_instance.active_retries if self.segments_instance else 0
                 progress_str = (
-                    #f"{Colors.WHITE}[ {Colors.GREEN}{number_file_downloaded} {Colors.WHITE}< "
-                    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.WHITE}< {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

@@ -9,10 +9,6 @@ from m3u8 import loads
 from StreamingCommunity.Util.os import internet_manager
 
 
-# External libraries
-import httpx
-
-
 # Costant
 CODEC_MAPPINGS = {
     "video": {
@@ -79,7 +75,6 @@ class M3U8_Codec:
         Extracted codecs are set as attributes: audio_codec and video_codec.
         """
         try:
-            # Split the codecs string by comma
             codecs_list = self.codecs.split(',')
         except Exception as e:
             logging.error(f"Can't split codec list: {self.codecs} with error {e}")
@@ -407,10 +402,8 @@ class M3U8_Parser:
         Parameters:
             - m3u8_content (str): The content of the M3U8 file.
         """
-
-        # Get obj of the m3u8 text content download, dictionary with video, audio, segments, subtitles
         m3u8_obj = loads(raw_content, uri)
-
+        
         self.__parse_video_info__(m3u8_obj)
         self.__parse_subtitles_and_audio__(m3u8_obj)
         self.__parse_segments__(m3u8_obj)
@@ -469,7 +462,6 @@ class M3U8_Parser:
         Parameters:
             - m3u8_obj: The M3U8 object containing video playlists.
         """
-
         try:
             for playlist in m3u8_obj.playlists:
 
@@ -511,25 +503,35 @@ class M3U8_Parser:
         except Exception as e:
             logging.error(f"Error parsing video info: {e}")
 
-    def __parse_encryption_keys__(self, m3u8_obj) -> None:
+    def __parse_encryption_keys__(self, obj) -> None:
         """
-        Extracts encryption keys from the M3U8 object.
+        Extracts encryption keys either from the M3U8 object or from individual segments.
 
         Parameters:
-            - m3u8_obj: The M3U8 object containing encryption keys.
+            - obj: Either the main M3U8 object or an individual segment.
         """
         try:
-            if m3u8_obj.key is not None:
+            if hasattr(obj, 'key') and obj.key is not None:
+                key_info = {
+                    'method': obj.key.method,
+                    'iv': obj.key.iv,
+                    'uri': obj.key.uri
+                }
+                
                 if self.keys is None:
-                    self.keys = {
-                        'method': m3u8_obj.key.method,
-                        'iv': m3u8_obj.key.iv,
-                        'uri': m3u8_obj.key.uri
-                    }
+                    self.keys = key_info
+
+                """
+                elif obj.key.uri not in self.keys:
+                    if isinstance(self.keys, dict):
+                        self.keys[obj.key.uri] = key_info
+                    else:
+                        old_key = self.keys
+                        self.keys = {'default': old_key, obj.key.uri: key_info}
+                """
 
         except Exception as e:
             logging.error(f"Error parsing encryption keys: {e}")
-            sys.exit(0)
             pass
 
     def __parse_subtitles_and_audio__(self, m3u8_obj) -> None:
@@ -569,7 +571,6 @@ class M3U8_Parser:
         Parameters:
             - m3u8_obj: The M3U8 object containing segment data.
         """
-
         try:
             for segment in m3u8_obj.segments:
 
@@ -583,6 +584,10 @@ class M3U8_Parser:
                     self.segments.append(segment.uri)
                 else:
                     self.subtitle.append(segment.uri)
+            
+            # Second check if there is key in main m3u8 obj
+            if self.keys is None:
+                self.__parse_encryption_keys__(m3u8_obj)
 
         except Exception as e:
             logging.error(f"Error parsing segments: {e}")
@@ -606,13 +611,6 @@ class M3U8_Parser:
         Returns:
             - formatted_duration (str): Formatted duration string with hours, minutes, and seconds if return_string is True.
             - duration_dict (dict): Dictionary with keys 'h', 'm', 's' representing hours, minutes, and seconds respectively if return_string is False.
-
-        Example usage:
-        >>> obj = YourClass(duration=3661)
-        >>> obj.get_duration()
-        '[yellow]1[red]h [yellow]1[red]m [yellow]1[red]s'
-        >>> obj.get_duration(return_string=False)
-        {'h': 1, 'm': 1, 's': 1}
         """
 
         # Calculate hours, minutes, and remaining seconds

StreamingCommunity/Lib/M3U8/url_fixer.py

@@ -33,8 +33,6 @@ class M3U8_UrlFix:
         Returns:
             str: The full URL for the specified resource.
         """
-
-        # Check if m3u8 url playlist is present
         if self.url_playlist == None:
             logging.error("[M3U8_UrlFix] Cant generate full url, playlist not present")
             raise
@@ -54,5 +52,4 @@ class M3U8_UrlFix:
         """
         Reset the M3U8 playlist URL to its default state (None).
         """
-        self.url_playlist = None
-    
+        self.url_playlist = None

StreamingCommunity/Lib/TMBD/__init__.py

@@ -1,2 +1,4 @@
+# 17.09.24
+
 from .tmdb import tmdb
 from .obj_tmbd import Json_film

StreamingCommunity/Lib/TMBD/obj_tmbd.py

@@ -5,35 +5,21 @@ from typing import Dict
 
 class Json_film:
     def __init__(self, data: Dict):
-        self.adult = data.get('adult', False)
-        self.backdrop_path = data.get('backdrop_path')
-        self.budget = data.get('budget', 0)
-        self.homepage = data.get('homepage')
         self.id = data.get('id', 0)
         self.imdb_id = data.get('imdb_id')
         self.origin_country = data.get('origin_country', [])
         self.original_language = data.get('original_language')
         self.original_title = data.get('original_title')
-        self.overview = data.get('overview')
         self.popularity = data.get('popularity', 0.0)
         self.poster_path = data.get('poster_path')
         self.release_date = data.get('release_date')
-        self.revenue = data.get('revenue', 0)
-        self.runtime = data.get('runtime', 0)
         self.status = data.get('status')
-        self.tagline = data.get('tagline')
         self.title = data.get('title')
-        self.video = data.get('video', False)
         self.vote_average = data.get('vote_average', 0.0)
         self.vote_count = data.get('vote_count', 0)
 
     def __repr__(self):
-        return (f"Film(adult={self.adult}, backdrop_path='{self.backdrop_path}', "
-                f"budget={self.budget}, "
-                f"homepage='{self.homepage}', id={self.id}, "
-                f"imdb_id='{self.imdb_id}', origin_country={self.origin_country}, "
+        return (f"Json_film(id={self.id}, imdb_id='{self.imdb_id}', origin_country={self.origin_country}, "
                 f"original_language='{self.original_language}', original_title='{self.original_title}', "
-                f"overview='{self.overview}', popularity={self.popularity}, poster_path='{self.poster_path}', "
-                f"release_date='{self.release_date}', revenue={self.revenue}, runtime={self.runtime}, "
-                f"status='{self.status}', tagline='{self.tagline}', "
-                f"title='{self.title}', video={self.video}, vote_average={self.vote_average}, vote_count={self.vote_count})")
+                f"popularity={self.popularity}, poster_path='{self.poster_path}', release_date='{self.release_date}', "
+                f"status='{self.status}', title='{self.title}', vote_average={self.vote_average}, vote_count={self.vote_count})")

StreamingCommunity/Lib/TMBD/tmdb.py

@@ -6,22 +6,22 @@ from typing import Dict
 
 # External libraries
 import httpx
+from rich.console import Console
 
 
 # Internal utilities
 from .obj_tmbd import Json_film
-from StreamingCommunity.Util.console import console
-from StreamingCommunity.Util._jsonConfig import config_manager
+from StreamingCommunity.Util.config_json import config_manager
 from StreamingCommunity.Util.table import TVShowManager
 
 
 # Variable
+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):
     """
     Display a selection of titles and prompt the user to choose one.
@@ -29,11 +29,6 @@ def get_select_title(table_show_manager, generic_obj):
     Returns:
         dict: The selected media item.
     """
-
-    # Set up table for displaying titles
-    table_show_manager.set_slice_end(10)
-
-    # Check if the generic_obj list is empty
     if not generic_obj:
         console.print("\n[red]No media items available.")
         return None
@@ -158,7 +153,7 @@ class TheMovieDB:
         
         # Join with colored arrows and print with proper category label
         console.print(
-            f"[bold purple]{category}:[/] {' [red]→[/] '.join(colored_items)}"
+            f"[bold purple]{category}:[/] {' [red]->[/] '.join(colored_items)}"
         )
 
     def display_trending_tv_shows(self):