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

StreamingCommunity/Lib/FFmpeg/util.py

@@ -132,31 +132,66 @@ def print_duration_table(file_path: str, description: str = "Duration", return_s
 def get_ffprobe_info(file_path):
     """
     Get format and codec information for a media file using ffprobe.
-
     Parameters:
         - file_path (str): Path to the media file.
-
     Returns:
         dict: A dictionary containing the format name and a list of codec names.
+              Returns None if file does not exist or ffprobe crashes.
     """
+    if not os.path.exists(file_path):
+        logging.error(f"File not found: {file_path}")
+        return None
+
+    # Get ffprobe path and verify it exists
+    ffprobe_path = get_ffprobe_path()
+    if not ffprobe_path or not os.path.exists(ffprobe_path):
+        logging.error(f"FFprobe not found at path: {ffprobe_path}")
+        return None
+
+    # Verify file permissions
+    try:
+        file_stat = os.stat(file_path)
+        logging.info(f"File permissions: {oct(file_stat.st_mode)}")
+        if not os.access(file_path, os.R_OK):
+            logging.error(f"No read permission for file: {file_path}")
+            return None
+    except OSError as e:
+        logging.error(f"Cannot access file {file_path}: {e}")
+        return None
+
     try:
+        cmd = [ffprobe_path, '-v', 'error', '-show_format', '-show_streams', '-print_format', 'json', file_path]
+        logging.info(f"Running FFprobe command: {' '.join(cmd)}")
+        
+        # Use subprocess.run instead of Popen for better error handling
         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
+            cmd,
+            capture_output=True,
+            text=True,
+            check=False  # Don't raise exception on non-zero exit
         )
-        output = result.stdout
-        info = json.loads(output)
-        
-        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
-        }
-    
+
+        if result.returncode != 0:
+            logging.error(f"FFprobe failed with return code {result.returncode}")
+            logging.error(f"FFprobe stderr: {result.stderr}")
+            logging.error(f"FFprobe stdout: {result.stdout}")
+            logging.error(f"Command: {' '.join(cmd)}")
+            logging.error(f"FFprobe path permissions: {oct(os.stat(ffprobe_path).st_mode)}")
+            return None
+
+        # Parse JSON output
+        try:
+            info = json.loads(result.stdout)
+            return {
+                'format_name': info.get('format', {}).get('format_name'),
+                'codec_names': [stream.get('codec_name') for stream in info.get('streams', [])]
+            }
+        except json.JSONDecodeError as e:
+            logging.error(f"Failed to parse FFprobe output: {e}")
+            return None
+
     except Exception as e:
-        logging.error(f"Failed to parse JSON output from ffprobe for file {file_path}: {e}")
+        logging.error(f"FFprobe execution failed: {e}")
         return None
 
 
@@ -173,8 +208,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):
@@ -225,4 +263,4 @@ def check_duration_v_a(video_path, audio_path, tolerance=1.0):
     if duration_difference <= tolerance:
         return True, duration_difference
     else:
-        return False, duration_difference
+        return False, duration_difference

StreamingCommunity/Lib/M3U8/estimator.py

@@ -1,6 +1,5 @@
 # 21.04.25
 
-import sys
 import time
 import logging
 import threading
@@ -14,7 +13,6 @@ 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
 
 
@@ -31,16 +29,16 @@ class M3U8_Ts_Estimator:
         self.segments_instance = segments_instance
         self.lock = threading.Lock()
         self.speed = {"upload": "N/A", "download": "N/A"}
+        self._running = True
+        
+        self.speed_thread = threading.Thread(target=self.capture_speed)
+        self.speed_thread.daemon = True
+        self.speed_thread.start()
 
-        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 +48,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 +98,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,32 +115,34 @@ 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]
             
-            if get_use_large_bar():
-                speed_data = self.speed['download'].split(" ")
-                
-                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 = ""
-                
-                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} "
-                )
-                
-            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} "
-                )
+            # 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
+            
+            # Get speed data outside of any locks
+            speed_data = ["N/A", ""]
+            with self.lock:
+                download_speed = self.speed['download']
+            
+            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 ""
+            
+            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} "
+            )
             
             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.8'
+__version__ = '3.0.0'
 __author__ = 'Arrowar'
 __description__ = 'A command-line program to download film'
 __copyright__ = 'Copyright 2024'

StreamingCommunity/Util/ffmpeg_installer.py

@@ -238,6 +238,31 @@ class FFMPEGDownloader:
         Returns:
             Tuple[Optional[str], Optional[str], Optional[str]]: Paths to ffmpeg, ffprobe, and ffplay executables.
         """
+        if self.os_name == 'linux':
+            try:
+                # Attempt to install FFmpeg using apt
+                console.print("[bold blue]Trying to install FFmpeg using 'sudo apt install ffmpeg'[/]")
+                result = subprocess.run(
+                    ['sudo', 'apt', 'install', '-y', 'ffmpeg'],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True
+                )
+                if result.returncode == 0:
+                    ffmpeg_path = shutil.which('ffmpeg')
+                    ffprobe_path = shutil.which('ffprobe')
+
+                    if ffmpeg_path and ffprobe_path:
+                        console.print("[bold green]FFmpeg successfully installed via apt[/]")
+                        return ffmpeg_path, ffprobe_path, None
+                else:
+                    console.print("[bold yellow]Failed to install FFmpeg via apt. Proceeding with static download.[/]")
+                    
+            except Exception as e:
+                logging.error(f"Error during 'sudo apt install ffmpeg': {e}")
+                console.print("[bold red]Error during 'sudo apt install ffmpeg'. Proceeding with static download.[/]")
+
+        # Proceed with static download if apt installation fails or is not applicable
         config = FFMPEG_CONFIGURATION[self.os_name]
         executables = [exe.format(arch=self.arch) for exe in config['executables']]
         successful_extractions = []
@@ -346,4 +371,4 @@ def check_ffmpeg() -> Tuple[Optional[str], Optional[str], Optional[str]]:
 
     except Exception as e:
         logging.error(f"Error checking or downloading FFmpeg executables: {e}")
-        return None, None, None
+        return None, None, None

StreamingCommunity/Util/os.py

@@ -4,7 +4,6 @@ import io
 import os
 import glob
 import sys
-import time
 import shutil
 import hashlib
 import logging
@@ -13,11 +12,9 @@ import inspect
 import subprocess
 import contextlib
 import importlib.metadata
-from pathlib import Path
 
 
 # External library
-import httpx
 from unidecode import unidecode
 from rich.console import Console
 from rich.prompt import Prompt
@@ -107,16 +104,14 @@ class OsManager:
         if not path:
             return path
 
-        # Decode unicode characters
+        # Decode unicode characters and perform basic sanitization
         decoded = unidecode(path)
-
-        # Basic path sanitization
         sanitized = sanitize_filepath(decoded)
 
         if self.system == 'windows':
             # Handle network paths (UNC or IP-based)
-            if path.startswith('\\\\') or path.startswith('//'):
-                parts = path.replace('/', '\\').split('\\')
+            if sanitized.startswith('\\\\') or sanitized.startswith('//'):
+                parts = sanitized.replace('/', '\\').split('\\')
                 # Keep server/IP and share name as is
                 sanitized_parts = parts[:4]
                 # Sanitize remaining parts
@@ -129,9 +124,9 @@ class OsManager:
                 return '\\'.join(sanitized_parts)
 
             # Handle drive letters
-            elif len(path) >= 2 and path[1] == ':':
-                drive = path[:2]
-                rest = path[2:].lstrip('\\').lstrip('/')
+            elif len(sanitized) >= 2 and sanitized[1] == ':':
+                drive = sanitized[:2]
+                rest = sanitized[2:].lstrip('\\').lstrip('/')
                 path_parts = [drive] + [
                     self.get_sanitize_file(part)
                     for part in rest.replace('/', '\\').split('\\')
@@ -141,12 +136,12 @@ class OsManager:
 
             # Regular path
             else:
-                parts = path.replace('/', '\\').split('\\')
+                parts = sanitized.replace('/', '\\').split('\\')
                 return '\\'.join(p for p in parts if p)
         else:
             # Handle Unix-like paths (Linux and macOS)
-            is_absolute = path.startswith('/')
-            parts = path.replace('\\', '/').split('/')
+            is_absolute = sanitized.startswith('/')
+            parts = sanitized.replace('\\', '/').split('/')
             sanitized_parts = [
                 self.get_sanitize_file(part)
                 for part in parts
@@ -357,12 +352,15 @@ class OsSummary:
         Exits with a message if not the official version.
         """
         python_implementation = platform.python_implementation()
+        python_version = platform.python_version()
 
         if python_implementation != "CPython":
             console.print(f"[bold red]Warning: You are using a non-official Python distribution: {python_implementation}.[/bold red]")
             console.print("Please install the official Python from [bold blue]https://www.python.org[/bold blue] and try again.", style="bold yellow")
             sys.exit(0)
 
+        console.print(f"[cyan]Python version: [bold red]{python_version}[/bold red]")
+
     def get_system_summary(self):
         self.check_python_version()
 
@@ -454,4 +452,4 @@ def get_ffmpeg_path():
 
 def get_ffprobe_path():
     """Returns the path of FFprobe."""
-    return os_summary.ffprobe_path
+    return os_summary.ffprobe_path

StreamingCommunity/Util/table.py

@@ -158,7 +158,8 @@ class TVShowManager:
                     else:
                         key = Prompt.ask(prompt_msg)
                 else:
-                    choices = [str(i) for i in range(max_int_input + 1)] + ["q", "quit", "b", "back"]
+                    # Include empty string in choices to allow pagination with Enter key
+                    choices = [""] + [str(i) for i in range(max_int_input + 1)] + ["q", "quit", "b", "back"]
                     prompt_msg = "[cyan]Insert media [red]index"
                     telegram_msg = "Scegli il contenuto da scaricare:\n Serie TV -  Film -  Anime\noppure `back` per tornare indietro"
                     
@@ -199,7 +200,8 @@ class TVShowManager:
                     else:
                         key = Prompt.ask(prompt_msg)
                 else:
-                    choices = [str(i) for i in range(max_int_input + 1)] + ["q", "quit", "b", "back"]
+                    # Include empty string in choices to allow pagination with Enter key
+                    choices = [""] + [str(i) for i in range(max_int_input + 1)] + ["q", "quit", "b", "back"]
                     prompt_msg = "[cyan]Insert media [red]index"
                     telegram_msg = "Scegli il contenuto da scaricare:\n Serie TV -  Film -  Anime\noppure `back` per tornare indietro"
                     

StreamingCommunity/global_search.py

@@ -57,11 +57,8 @@ def load_search_functions():
 
             # Get 'indice' from the module
             indice = getattr(mod, 'indice', 0)
-            is_deprecate = bool(getattr(mod, '_deprecate', True))
             use_for = getattr(mod, '_useFor', 'other')
-
-            if not is_deprecate:
-                modules.append((module_name, indice, use_for))
+            modules.append((module_name, indice, use_for))
 
         except Exception as e:
             console.print(f"[red]Failed to import module {module_name}: {str(e)}")

StreamingCommunity/run.py

@@ -90,11 +90,8 @@ def load_search_functions():
 
             # Get 'indice' from the module
             indice = getattr(mod, 'indice', 0)
-            is_deprecate = bool(getattr(mod, '_deprecate', True))
             use_for = getattr(mod, '_useFor', 'other')
-
-            if not is_deprecate:
-                modules.append((module_name, indice, use_for))
+            modules.append((module_name, indice, use_for))
 
         except Exception as e:
             console.print(f"[red]Failed to import module {module_name}: {str(e)}")

{streamingcommunity-2.9.8.dist-info → streamingcommunity-3.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: StreamingCommunity
-Version: 2.9.8
+Version: 3.0.0
 Home-page: https://github.com/Lovi-0/StreamingCommunity
 Author: Lovi-0
 Project-URL: Bug Reports, https://github.com/Lovi-0/StreamingCommunity/issues

streamingcommunity-3.0.0.dist-info/RECORD

@@ -0,0 +1,91 @@
+StreamingCommunity/__init__.py,sha256=Cw-N0VCg7sef1WqdtvVwrhs1zc4LoUhs5C8k7vpM1lQ,207
+StreamingCommunity/global_search.py,sha256=LgRTjVBJYyLiKYa3EIb33vRnVQ-COoQT7gASfVW8-Dg,12022
+StreamingCommunity/run.py,sha256=xBq2GS3JznLZBAF5DnJplNtJBzqOl_zHQXVmXxDMnBs,13108
+StreamingCommunity/Api/Player/ddl.py,sha256=S3UZFonJl3d3xU1fQrosRFXFhwAm8hGVQ8Ff8g-6xSI,2071
+StreamingCommunity/Api/Player/maxstream.py,sha256=WXg8xncFXFiaUmTVXxB3NyknQtbvd0sF1eRaoDO24bU,4822
+StreamingCommunity/Api/Player/mediapolisvod.py,sha256=OcdnE1BMSwPZM-nw74GXNJ44E9RYwGnc_kFEA-G8XyY,2294
+StreamingCommunity/Api/Player/supervideo.py,sha256=hr9QViI-XD0Dqhcx90oaH8_j0d6cxpVaf-EuCjMs6hI,5199
+StreamingCommunity/Api/Player/sweetpixel.py,sha256=gJSe1fop5J216CB3u8vstxLPP5YbcyoGUH4y3X3-JaQ,1643
+StreamingCommunity/Api/Player/vixcloud.py,sha256=qI9ppYEMGaJ1B5y693BOMeRQri-F4-94SfRkS-9udfM,6287
+StreamingCommunity/Api/Player/Helper/Vixcloud/js_parser.py,sha256=U-8QlD5kGzIk3-4t4D6QyYmiDe8UBrSuVi1YHRQb7AU,4295
+StreamingCommunity/Api/Player/Helper/Vixcloud/util.py,sha256=QLUgbwQrpuPIVNzdBlAiEJXnd-eCj_JQFckZZEEL55w,5214
+StreamingCommunity/Api/Site/1337xx/__init__.py,sha256=OdQxYoJ9UyGSAutZwqH1FgmOH-Z6vGVHb0CLKhwEZGM,1999
+StreamingCommunity/Api/Site/1337xx/site.py,sha256=lwpZt8ALBd9_ImuFWKrRx6KCIqPmDMdqZCM-n-pxvGI,2283
+StreamingCommunity/Api/Site/1337xx/title.py,sha256=8T3cVRb-Mt9QdOtKWVVFHz8iOHqspf7iw28E7bfTV78,1865
+StreamingCommunity/Api/Site/altadefinizione/__init__.py,sha256=Oxjfyg6VolwV6n2VGgICLvdRVPPMzJXMSdz8oI2Xs0M,4145
+StreamingCommunity/Api/Site/altadefinizione/film.py,sha256=0XeqMrMHnk5nbFkVTFaNZWtlXI8pETl7dsORDtIMbjg,4395
+StreamingCommunity/Api/Site/altadefinizione/series.py,sha256=-rCYx-Fa7aZiYepcIne7OdH1aaUFZZAPX-ToBv6mxFs,8192
+StreamingCommunity/Api/Site/altadefinizione/site.py,sha256=S-ucgLNXUYZPjgSNjEYVxlkpMkJyjpr7mYf_jBcYwqM,2860
+StreamingCommunity/Api/Site/altadefinizione/util/ScrapeSerie.py,sha256=bSApjfY9xd5dw0tZ1t7vB6ifAo5vAkeeEwX6IS7yH1o,3756
+StreamingCommunity/Api/Site/animeunity/__init__.py,sha256=EayZqxyWltgjRRDNfM32JRzgeyElK85o6s0_YJ0dpBk,4031
+StreamingCommunity/Api/Site/animeunity/film.py,sha256=Vqg6yag2siR-Y3ougBsV8mzdQXChxg6ghz_KVXFQ3pE,998
+StreamingCommunity/Api/Site/animeunity/serie.py,sha256=ib86sLXYsYbrvrFNbzKdhlwMUO3DT7JS5yTTrrSr2jk,5711
+StreamingCommunity/Api/Site/animeunity/site.py,sha256=KLBQ08TAMyzsrZ3SAxw8hZefreCtZAuU1KwEbaJnUAE,5646
+StreamingCommunity/Api/Site/animeunity/util/ScrapeSerie.py,sha256=9q108tS2St3ogR73nGZhMlCTHoZH-taE_CTBC6LY6d0,3374
+StreamingCommunity/Api/Site/animeworld/__init__.py,sha256=UzHQbfxx_i6qzM586LL940CoiI3Y98IGIVP4-hXUxn4,2790
+StreamingCommunity/Api/Site/animeworld/film.py,sha256=W9KOS9Wvx3Mlqx5WojR-NgnF9WX8mI79JZPS7UwG-dc,1763
+StreamingCommunity/Api/Site/animeworld/serie.py,sha256=MXyV1fK05jPW4iV9NWrRKW-R4ect-TSN78-2APayniU,3516
+StreamingCommunity/Api/Site/animeworld/site.py,sha256=1Ah4CmKXdqsoCGTbyPRSVJRAxtcW449kpBnPKnzR1K8,3650
+StreamingCommunity/Api/Site/animeworld/util/ScrapeSerie.py,sha256=CBTCH_wnTXUK_MKwq9a1k_XdvOlUrMpbUmpkD5fXVQ0,3589
+StreamingCommunity/Api/Site/cb01new/__init__.py,sha256=fy0dPL0NnZxSz3UL_i_zE809Rus7-ZI60WsXq9S4NUs,2039
+StreamingCommunity/Api/Site/cb01new/film.py,sha256=vjd1ftm4LhxxG0TTKEwlOXtx0AYgxBbV5ZlQH8aSxGU,1695
+StreamingCommunity/Api/Site/cb01new/site.py,sha256=ROT3yh6mpC85qHJAvPkWply91tFd8-V7ayX_3KsdtR4,2152
+StreamingCommunity/Api/Site/ddlstreamitaly/__init__.py,sha256=2FGeGNJ5SHPQzKEEmVMFWft4woGgJ-XLeNxjbSb6L9s,2141
+StreamingCommunity/Api/Site/ddlstreamitaly/series.py,sha256=F_D_2lwHHWN5hgLs8oUDNCYe-4SEPtWzJoU4yT_Nzfg,3726
+StreamingCommunity/Api/Site/ddlstreamitaly/site.py,sha256=hspimNOnIkLdJMrYLgXHmXepLz_mu8z257camnlGfaI,2596
+StreamingCommunity/Api/Site/ddlstreamitaly/util/ScrapeSerie.py,sha256=tETaN-2GyFBeRsoLnGw3Kz4D4j2TMcnPzGjzlC62w_Y,3655
+StreamingCommunity/Api/Site/guardaserie/__init__.py,sha256=p5hzqshw5hwDl9nJ8FBWbzfPe2j7c5eNYiaftDThGcU,2768
+StreamingCommunity/Api/Site/guardaserie/series.py,sha256=U9rMZCjRqHLFjo468vikxl-2RqO6DCJjebB-G8Y6LDg,6492
+StreamingCommunity/Api/Site/guardaserie/site.py,sha256=DrtHD365Ezh3GGcluvTIJxWYSjhaJpiY1w6pg4M1odw,2321
+StreamingCommunity/Api/Site/guardaserie/util/ScrapeSerie.py,sha256=_aXU-YcUtSwbC2b6QpNnWDZR8m6vp9xzBEx_zdu5tgI,4196
+StreamingCommunity/Api/Site/raiplay/__init__.py,sha256=xkxVkFsSxA6DHRqPuzQYXnCVNUBhfUG5xxlz6iwf1mw,3132
+StreamingCommunity/Api/Site/raiplay/film.py,sha256=wBv5kQXx7-aCKhAZ5LABZ8zUzu_jPGdXOl9OM2p8dpY,1982
+StreamingCommunity/Api/Site/raiplay/series.py,sha256=uQVbeA_g3Z1Ciqeq99gsY2F8mC5DssH3ueGbCW8gd9Q,6161
+StreamingCommunity/Api/Site/raiplay/site.py,sha256=FtIR_oT-ag1sh5XnaOAhEOE8biHZmXtZnsFAjKszU8U,5154
+StreamingCommunity/Api/Site/raiplay/util/ScrapeSerie.py,sha256=5F6abToCTtsvW8iIACbChZ0fPlymJiCSF_y8FRsDu7M,5002
+StreamingCommunity/Api/Site/streamingcommunity/__init__.py,sha256=Ej-xZ6x99zeq3p5O7-e_Evi_529x3eq_VryBLejCBiA,3796
+StreamingCommunity/Api/Site/streamingcommunity/film.py,sha256=TPt0yB1DKShDIz_1OEVG1IolMoAKBOaWIZ8lQF61dfM,2575
+StreamingCommunity/Api/Site/streamingcommunity/series.py,sha256=jWwgawBovZkL7pafvd55L68AMAy7ZyvCPNZdh72bqq8,8859
+StreamingCommunity/Api/Site/streamingcommunity/site.py,sha256=nKII_DjKN1ePeYdMn4titYgvPRMbm8PmEXIM6npGkeI,3129
+StreamingCommunity/Api/Site/streamingcommunity/util/ScrapeSerie.py,sha256=3sNz9uD-o9xz0dKpSnQsLPC_45v5fnW9Mzas2rQ8-Uc,5579
+StreamingCommunity/Api/Template/__init__.py,sha256=oyfd_4_g5p5q6mxb_rKwSsudZnTM3W3kg1tLwxg-v-Q,46
+StreamingCommunity/Api/Template/config_loader.py,sha256=2RT_0mqQmWzXM4rYaqss-yhXztYAcfNkTalFPjzv270,2056
+StreamingCommunity/Api/Template/site.py,sha256=BJjQktdu2q2pkGflJv3UdrpSEmzJCJnaT-u-jD5zhgs,2861
+StreamingCommunity/Api/Template/Class/SearchType.py,sha256=LOlE8UgraEM0UAVeNCThDGi8bleei31p7KpryuZm3VE,2530
+StreamingCommunity/Api/Template/Util/__init__.py,sha256=ZWQQd6iymNFDol9HaKPhVBoRX1W-xHJZgU_mZvLVdsM,196
+StreamingCommunity/Api/Template/Util/manage_ep.py,sha256=FYe2DC9SXIXzlRYI7fW4ieBpfrxYzsUgt2C47tYRk7U,9252
+StreamingCommunity/Lib/Downloader/__init__.py,sha256=JhbBh5hOnSM7VmtkxJ7zZ_FtWEC1JdnKThsSBjLV5FY,140
+StreamingCommunity/Lib/Downloader/HLS/downloader.py,sha256=wlujaWn5I5KtP0m61iYExtnEhwmsy_jdFqd9cM1A-2E,21588
+StreamingCommunity/Lib/Downloader/HLS/segments.py,sha256=Q_YZxkWfUqd6TRkHoYt58Iy-xMWVLH6fCnBnQImQK2I,18059
+StreamingCommunity/Lib/Downloader/MP4/downloader.py,sha256=L03fpjaJ2pvZ_McaOShv3iCsdbefCGW3WM1QIa2TGJo,7514
+StreamingCommunity/Lib/Downloader/TOR/downloader.py,sha256=CrRGdLGI_45AnhtTZm8r7KO7uGmU9k6pywy-qO18LG8,19242
+StreamingCommunity/Lib/FFmpeg/__init__.py,sha256=6PBsZdE1jrD2EKOVyx3JEHnyDZzVeKlPkH5T0zyfOgU,130
+StreamingCommunity/Lib/FFmpeg/capture.py,sha256=QZYtuUG3L5_BsHFdzBU-5pZrX1PYxfCTx8bXShGF_bs,5029
+StreamingCommunity/Lib/FFmpeg/command.py,sha256=ubpffE02nsZM7xch5gbwGlEiUzecpxcFOd63n2cqM1k,10708
+StreamingCommunity/Lib/FFmpeg/util.py,sha256=byM5DzAA-8Ts0FtviEPfbFJKN_PuxVFGjELgD_FEhsk,9287
+StreamingCommunity/Lib/M3U8/__init__.py,sha256=H_KS2eDd3kVXMziFJnD0FCPvPHEizaqfoA36ElTv_r8,170
+StreamingCommunity/Lib/M3U8/decryptor.py,sha256=kuxxsd3eN0VGRrMJWXzHo8gCpT0u3fSZs_lwxlE5Fqs,2948
+StreamingCommunity/Lib/M3U8/estimator.py,sha256=8gwTxJ3poRqZdHUTD9_oqXegiPWSXFuqLmqCZBnXS8A,5893
+StreamingCommunity/Lib/M3U8/parser.py,sha256=cSjXPOSgTewrfLgREyQ47wzoOeoYo3L4lOfEWZKxad8,22485
+StreamingCommunity/Lib/M3U8/url_fixer.py,sha256=zldE4yOuNBV6AAvL1KI6p7XdRI_R5YZRscbDgT1564M,1735
+StreamingCommunity/Lib/TMBD/__init__.py,sha256=XzE42tw3Ws59DD1PF8WmGtZ0D4D7Hk3Af8QthNE-22U,66
+StreamingCommunity/Lib/TMBD/obj_tmbd.py,sha256=dRSvJFS5yqmsBZcw2wqbStcBtXNjU_3n5czMyremAtU,1187
+StreamingCommunity/Lib/TMBD/tmdb.py,sha256=byg0EFnlmd9JeLvn1N9K3QkB1KEfeMuFa7OVfGqks1Y,10685
+StreamingCommunity/TelegramHelp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+StreamingCommunity/TelegramHelp/telegram_bot.py,sha256=Qe1__aoK4PpDuing8JtWgdHzLee8LuYYyfeLNA7yADU,26307
+StreamingCommunity/Upload/update.py,sha256=mJTKUIOhC2j03sWXUK6oAZxHyObNP2r1fl3y0BC2jes,3351
+StreamingCommunity/Upload/version.py,sha256=w7FJx8AjjjVxIMxI1IxHS70oEvmUKg7KBImjlhijaMI,171
+StreamingCommunity/Util/color.py,sha256=NvD0Eni-25oOOkY-szCEoc0lGvzQxyL7xhM0RE4EvUM,458
+StreamingCommunity/Util/config_json.py,sha256=xiE5JNw9HgbBdBqKhlywwWw1EnoyDdG47wcxFDTC8sA,24960
+StreamingCommunity/Util/ffmpeg_installer.py,sha256=yRVIPwbh05tZ-duZmXkH0qasLNxaQCAT_E4cTP79Z3c,14890
+StreamingCommunity/Util/headers.py,sha256=TItkaFMx1GqsVNEIS3Tr0BGU5EHyF-HkZVliHORT3P8,308
+StreamingCommunity/Util/logger.py,sha256=9kGD6GmWj2pM8ADpJc85o7jm8DD0c5Aguqnq-9kmxos,3314
+StreamingCommunity/Util/message.py,sha256=SJaIPLvWeQqsIODVUKw3TgYRmBChovmlbcF6OUxqMI8,1425
+StreamingCommunity/Util/os.py,sha256=0AD2DYoan9dl1ZC1pjDoUM7D8sRa9p81cGdI-lP1OX4,14993
+StreamingCommunity/Util/table.py,sha256=Nw5PlsvfEIOQZWy5VhsU5OK3heuBXGwsqmLl0k8yQzc,9813
+streamingcommunity-3.0.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+streamingcommunity-3.0.0.dist-info/METADATA,sha256=OwSAYErIcsUYH-VDC9VlXEpNByWJpCBCCZgC-vMu5UY,25012
+streamingcommunity-3.0.0.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+streamingcommunity-3.0.0.dist-info/entry_points.txt,sha256=Qph9XYfDC8n4LfDLOSl6gJGlkb9eFb5f-JOr_Wb_5rk,67
+streamingcommunity-3.0.0.dist-info/top_level.txt,sha256=YsOcxKP-WOhWpIWgBlh0coll9XUx7aqmRPT7kmt3fH0,19
+streamingcommunity-3.0.0.dist-info/RECORD,,