StreamingCommunity 1.7.6__py3-none-any.whl → 1.9.1__py3-none-any.whl

StreamingCommunity/{Src/Lib → Lib}/M3U8/decryptor.py

@@ -1,129 +1,164 @@
-# 03.04.24
-
-import sys
-import logging
-import subprocess
-import importlib.util
-
-
-# Internal utilities
-from StreamingCommunity.Src.Util.console import console
-
-
-# Check if Crypto module is installed
-crypto_spec = importlib.util.find_spec("Crypto")
-crypto_installed = crypto_spec is not None
-
-
-if crypto_installed:
-    logging.info("Decrypy use: Crypto")
-    from Crypto.Cipher import AES # type: ignore
-    from Crypto.Util.Padding import unpad # type: ignore
-
-    class M3U8_Decryption:
-        """
-        Class for decrypting M3U8 playlist content using AES encryption when the Crypto module is available.
-        """
-        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
-            if "0x" in str(iv):
-                self.iv = bytes.fromhex(iv.replace("0x", ""))
-            else:
-                self.iv = iv
-            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.
-            """
-            if self.method == "AES":
-                cipher = AES.new(self.key, AES.MODE_ECB)
-                decrypted_data = cipher.decrypt(ciphertext)
-                return unpad(decrypted_data, AES.block_size)
-
-            elif self.method == "AES-128":
-                cipher = AES.new(self.key[:16], AES.MODE_CBC, iv=self.iv)
-                decrypted_data = cipher.decrypt(ciphertext)
-                return unpad(decrypted_data, AES.block_size)
-
-            elif self.method == "AES-128-CTR":
-                cipher = AES.new(self.key[:16], AES.MODE_CTR, nonce=self.iv)
-                return cipher.decrypt(ciphertext)
-
-            else:
-                raise ValueError("Invalid or unsupported method")
-
-else:
-
-    # Check if openssl command is available
-    try:
-        openssl_available = subprocess.run(["openssl", "version"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL).returncode == 0
-        logging.info("Decrypy use: OPENSSL")
-    except:
-        openssl_available = False
-
-    if not openssl_available:
-        console.log("[red]Neither python library: pycryptodome nor openssl software is installed. Please install either one of them. Read readme.md [Requirement].")
-        sys.exit(0)
-
-    class M3U8_Decryption:
-        """
-        Class for decrypting M3U8 playlist content using OpenSSL when the Crypto module is not available.
-        """
-        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
-            if "0x" in str(iv):
-                self.iv = bytes.fromhex(iv.replace("0x", ""))
-            else:
-                self.iv = iv
-            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.
-            """
-            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_data = subprocess.check_output(openssl_cmd.split(), input=ciphertext, stderr=subprocess.STDOUT)
-            except subprocess.CalledProcessError as e:
-                raise ValueError(f"Decryption failed: {e.output.decode()}")
-
-            return decrypted_data
+# 03.04.24
+
+import sys
+import time
+import logging
+import subprocess
+import importlib.util
+
+
+# Internal utilities
+from StreamingCommunity.Util.console import console
+
+
+# Check if Crypto module is installed
+crypto_spec = importlib.util.find_spec("Crypto")
+crypto_installed = crypto_spec is not None
+
+
+if crypto_installed:
+    logging.info("Decrypy use: Crypto")
+    from Crypto.Cipher import AES               # type: ignore
+    from Crypto.Util.Padding import unpad       # type: ignore
+
+    class M3U8_Decryption:
+        """
+        Class for decrypting M3U8 playlist content using AES encryption when the Crypto module is available.
+        """
+        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()
+
+            # 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("Decrypy use: OPENSSL")
+    except:
+        openssl_available = False
+
+    if not openssl_available:
+        console.log("[red]Neither python library: pycryptodome nor openssl software is installed. Please install either one of them. Read readme.md [Requirement].")
+        sys.exit(0)
+
+    class M3U8_Decryption:
+        """
+        Class for decrypting M3U8 playlist content using OpenSSL when the Crypto module is not available.
+        """
+        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

StreamingCommunity/{Src/Lib → Lib}/M3U8/estimator.py

@@ -1,173 +1,176 @@
-# 20.02.24
-
-import os
-import time
-import logging
-import threading
-from collections import deque
-
-
-# External libraries
-import psutil
-from tqdm import tqdm
-
-
-# Internal utilities
-from StreamingCommunity.Src.Util.color import Colors
-from StreamingCommunity.Src.Util.os import internet_manager
-from StreamingCommunity.Src.Util._jsonConfig import config_manager
-
-
-# Variable
-TQDM_USE_LARGE_BAR = config_manager.get_int('M3U8_DOWNLOAD', 'tqdm_use_large_bar')
-
-
-class M3U8_Ts_Estimator:
-    def __init__(self, total_segments: int):
-        """
-        Initialize the M3U8_Ts_Estimator object.
-
-        Parameters:
-            - total_segments (int): Length of total segments to download.
-        """
-        self.ts_file_sizes = []
-        self.now_downloaded_size = 0
-        self.total_segments = total_segments
-        self.lock = threading.Lock()
-        self.speed = {"upload": "N/A", "download": "N/A"}  # Default to N/A
-        self.speed_thread = threading.Thread(target=self.capture_speed)
-        self.speed_thread.daemon = True
-        self.speed_thread.start()
-
-    def add_ts_file(self, size: int, size_download: int, duration: float):
-        """
-        Add a file size to the list of file sizes.
-
-        Parameters:
-            - size (int): The size of the ts file to be added.
-            - size_download (int): Single size of the ts file.
-            - duration (float): Time to download segment file.
-        """
-        if size <= 0 or size_download <= 0 or duration <= 0:
-            logging.error("Invalid input values: size=%d, size_download=%d, duration=%f", size, size_download, duration)
-            return
-
-        # Add total size bytes
-        self.ts_file_sizes.append(size)
-        self.now_downloaded_size += size_download
-
-    def capture_speed(self, interval: float = 1):
-        """
-        Capture the internet speed periodically and store the values.
-        """
-        def get_network_io():
-            """Get network I/O counters, handle missing psutil gracefully."""
-            try:
-                io_counters = psutil.net_io_counters()
-                return io_counters
-            except Exception as e:
-                logging.warning(f"Unable to access network I/O counters: {e}")
-                return None
-
-        while True:
-            old_value = get_network_io()
-            if old_value is None:  # If psutil is not available, continue with default values
-                time.sleep(interval)
-                continue
-
-            time.sleep(interval)
-            new_value = get_network_io()
-            if new_value is None:  # Handle again if psutil fails in the next call
-                time.sleep(interval)
-                continue
-
-            with self.lock:
-                upload_speed = (new_value.bytes_sent - old_value.bytes_sent) / interval
-                download_speed = (new_value.bytes_recv - old_value.bytes_recv) / interval
-
-                self.speed = {
-                    "upload": internet_manager.format_transfer_speed(upload_speed),
-                    "download": internet_manager.format_transfer_speed(download_speed)
-                }
-
-    def get_average_speed(self) -> float:
-        """
-        Calculate the average internet speed.
-
-        Returns:
-            float: The average internet speed in Mbps.
-        """
-        with self.lock:
-            return self.speed['download'].split(" ")
-
-    def calculate_total_size(self) -> str:
-        """
-        Calculate the total size of the files.
-
-        Returns:
-            str: The mean size of the files in a human-readable format.
-        """
-        try:
-            if len(self.ts_file_sizes) == 0:
-                raise ValueError("No file sizes available to calculate total size.")
-
-            total_size = sum(self.ts_file_sizes)
-            mean_size = total_size / len(self.ts_file_sizes)
-
-            # Return formatted mean size
-            return internet_manager.format_file_size(mean_size)
-
-        except ZeroDivisionError as e:
-            logging.error("Division by zero error occurred: %s", e)
-            return "0B"
-
-        except Exception as e:
-            logging.error("An unexpected error occurred: %s", e)
-            return "Error"
-
-    def get_downloaded_size(self) -> str:
-        """
-        Get the total downloaded size formatted as a human-readable string.
-
-        Returns:
-            str: The total downloaded size as a human-readable string.
-        """
-        return internet_manager.format_file_size(self.now_downloaded_size)
-
-    def update_progress_bar(self, total_downloaded: int, duration: float, progress_counter: tqdm) -> None:
-        """
-        Updates the progress bar with information about the TS segment download.
-
-        Parameters:
-            total_downloaded (int): The length of the content of the downloaded TS segment.
-            duration (float): The duration of the segment download in seconds.
-            progress_counter (tqdm): The tqdm object representing the progress bar.
-        """
-        # Add the size of the downloaded segment to the estimator
-        self.add_ts_file(total_downloaded * self.total_segments, total_downloaded, duration)
-
-        # Get downloaded size and total estimated size
-        downloaded_file_size_str = self.get_downloaded_size()
-        file_total_size = self.calculate_total_size()
-
-        # Fix parameter for prefix
-        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]
-
-        average_internet_speed = self.get_average_speed()[0]
-        average_internet_unit = self.get_average_speed()[1]
-
-        # Update the progress bar's postfix
-        if TQDM_USE_LARGE_BAR:
-            progress_counter.set_postfix_str(
-                f"{Colors.WHITE}[ {Colors.GREEN}{number_file_downloaded} {Colors.WHITE}< {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}"
-            )
-        else:
-            progress_counter.set_postfix_str(
-                f"{Colors.WHITE}[ {Colors.GREEN}{number_file_downloaded}{Colors.RED} {units_file_downloaded} "
-                f"{Colors.WHITE}| {Colors.CYAN}{average_internet_speed} {Colors.RED}{average_internet_unit}"
-            )
+# 20.02.24
+
+import os
+import time
+import logging
+import threading
+from collections import deque
+
+
+# External libraries
+import psutil
+from tqdm import tqdm
+
+
+# Internal utilities
+from StreamingCommunity.Util.color import Colors
+from StreamingCommunity.Util.os import internet_manager
+from StreamingCommunity.Util._jsonConfig import config_manager
+
+
+# Variable
+TQDM_USE_LARGE_BAR = config_manager.get_int('M3U8_DOWNLOAD', 'tqdm_use_large_bar')
+
+
+class M3U8_Ts_Estimator:
+    def __init__(self, total_segments: int):
+        """
+        Initialize the M3U8_Ts_Estimator object.
+
+        Parameters:
+            - total_segments (int): Length of total segments to download.
+        """
+        self.ts_file_sizes = []
+        self.now_downloaded_size = 0
+        self.total_segments = total_segments
+        self.lock = threading.Lock()
+        self.speed = {"upload": "N/A", "download": "N/A"}  # Default to N/A
+        self.speed_thread = threading.Thread(target=self.capture_speed)
+        self.speed_thread.daemon = True
+        self.speed_thread.start()
+
+    def add_ts_file(self, size: int, size_download: int, duration: float):
+        """
+        Add a file size to the list of file sizes.
+
+        Parameters:
+            - size (int): The size of the ts file to be added.
+            - size_download (int): Single size of the ts file.
+            - duration (float): Time to download segment file.
+        """
+        if size <= 0 or size_download <= 0 or duration <= 0:
+            logging.error("Invalid input values: size=%d, size_download=%d, duration=%f", size, size_download, duration)
+            return
+
+        # Add total size bytes
+        self.ts_file_sizes.append(size)
+        self.now_downloaded_size += size_download
+
+    def capture_speed(self, interval: float = 1):
+        """
+        Capture the internet speed periodically and store the values.
+        """
+        def get_network_io():
+            """Get network I/O counters, handle missing psutil gracefully."""
+            try:
+                io_counters = psutil.net_io_counters()
+                return io_counters
+            
+            except Exception as e:
+                logging.warning(f"Unable to access network I/O counters: {e}")
+                return None
+
+        while True:
+            old_value = get_network_io()
+
+            if old_value is None:  # If psutil is not available, continue with default values
+                time.sleep(interval)
+                continue
+
+            time.sleep(interval)
+            new_value = get_network_io()
+            
+            if new_value is None:  # Handle again if psutil fails in the next call
+                time.sleep(interval)
+                continue
+
+            with self.lock:
+                upload_speed = (new_value.bytes_sent - old_value.bytes_sent) / interval
+                download_speed = (new_value.bytes_recv - old_value.bytes_recv) / interval
+
+                self.speed = {
+                    "upload": internet_manager.format_transfer_speed(upload_speed),
+                    "download": internet_manager.format_transfer_speed(download_speed)
+                }
+
+    def get_average_speed(self) -> float:
+        """
+        Calculate the average internet speed.
+
+        Returns:
+            float: The average internet speed in Mbps.
+        """
+        with self.lock:
+            return self.speed['download'].split(" ")
+
+    def calculate_total_size(self) -> str:
+        """
+        Calculate the total size of the files.
+
+        Returns:
+            str: The mean size of the files in a human-readable format.
+        """
+        try:
+            if len(self.ts_file_sizes) == 0:
+                raise ValueError("No file sizes available to calculate total size.")
+
+            total_size = sum(self.ts_file_sizes)
+            mean_size = total_size / len(self.ts_file_sizes)
+
+            # Return formatted mean size
+            return internet_manager.format_file_size(mean_size)
+
+        except ZeroDivisionError as e:
+            logging.error("Division by zero error occurred: %s", e)
+            return "0B"
+
+        except Exception as e:
+            logging.error("An unexpected error occurred: %s", e)
+            return "Error"
+
+    def get_downloaded_size(self) -> str:
+        """
+        Get the total downloaded size formatted as a human-readable string.
+
+        Returns:
+            str: The total downloaded size as a human-readable string.
+        """
+        return internet_manager.format_file_size(self.now_downloaded_size)
+
+    def update_progress_bar(self, total_downloaded: int, duration: float, progress_counter: tqdm) -> None:
+        """
+        Updates the progress bar with information about the TS segment download.
+
+        Parameters:
+            total_downloaded (int): The length of the content of the downloaded TS segment.
+            duration (float): The duration of the segment download in seconds.
+            progress_counter (tqdm): The tqdm object representing the progress bar.
+        """
+        # Add the size of the downloaded segment to the estimator
+        self.add_ts_file(total_downloaded * self.total_segments, total_downloaded, duration)
+
+        # Get downloaded size and total estimated size
+        downloaded_file_size_str = self.get_downloaded_size()
+        file_total_size = self.calculate_total_size()
+
+        # Fix parameter for prefix
+        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]
+
+        average_internet_speed = self.get_average_speed()[0]
+        average_internet_unit = self.get_average_speed()[1]
+
+        # Update the progress bar's postfix
+        if TQDM_USE_LARGE_BAR:
+            progress_counter.set_postfix_str(
+                f"{Colors.WHITE}[ {Colors.GREEN}{number_file_downloaded} {Colors.WHITE}< {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}"
+            )
+        else:
+            progress_counter.set_postfix_str(
+                f"{Colors.WHITE}[ {Colors.GREEN}{number_file_downloaded}{Colors.RED} {units_file_downloaded} "
+                f"{Colors.WHITE}| {Colors.CYAN}{average_internet_speed} {Colors.RED}{average_internet_unit}"
+            )