StreamingCommunity 2.2.0__py3-none-any.whl → 2.4.0__py3-none-any.whl

StreamingCommunity/Api/Template/Util/get_domain.py

@@ -1,7 +1,8 @@
 # 18.06.24
 
-import sys
-from urllib.parse import urlparse
+import ssl
+import time
+from urllib.parse import urlparse, unquote
 
 
 # External libraries
@@ -15,160 +16,188 @@ from StreamingCommunity.Util.console import console, msg
 from StreamingCommunity.Util._jsonConfig import config_manager
 
 
-def google_search(query):
-    """
-    Perform a Google search and return the first result.
+base_headers = {
+    'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
+    'accept-language': 'it-IT,it;q=0.9,en-US;q=0.8,en;q=0.7',
+    'dnt': '1',
+    'priority': 'u=0, i',
+    'referer': '',
+    'sec-ch-ua-mobile': '?0',
+    'sec-ch-ua-platform': '"Windows"',
+    'sec-fetch-dest': 'document',
+    'sec-fetch-mode': 'navigate',
+    'sec-fetch-site': 'same-origin',
+    'sec-fetch-user': '?1',
+    'upgrade-insecure-requests': '1',
+    'user-agent': ''
+}
+
+
+def get_tld(url_str):
+    """Extract the TLD (Top-Level Domain) from the URL."""
+    try:
+        url_str = unquote(url_str)
+        parsed = urlparse(url_str)
+        domain = parsed.netloc.lower()
 
-    Args:
-        query (str): The search query to execute on Google.
+        if domain.startswith('www.'):
+            domain = domain[4:]
+        parts = domain.split('.')
 
-    Returns:
-        str: The first URL result from the search, or None if no result is found.
-    """
-    # Perform the search on Google and limit to 1 result
-    search_results = search(query, num_results=1)
-    
-    # Extract the first result
-    first_result = next(search_results, None)
-    
-    if not first_result:
-        console.print("[red]No results found.[/red]")
+        return parts[-1] if len(parts) >= 2 else None
     
-    return first_result
-
-def get_final_redirect_url(initial_url, max_timeout):
-    """
-    Follow redirects from the initial URL and return the final URL after all redirects.
-
-    Args:
-        initial_url (str): The URL to start with and follow redirects.
-
-    Returns:
-        str: The final URL after all redirects are followed.
-    """
+    except Exception:
+        return None
 
-    # Create a client with redirects enabled
+def get_base_domain(url_str):
+    """Extract base domain without protocol, www and path."""
     try:
-        with httpx.Client(
-            headers={
-                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',
-                'accept-language': 'it-IT,it;q=0.9,en-US;q=0.8,en;q=0.7',
-                'User-Agent': get_headers()
-            },
-            follow_redirects=True,
-            timeout=max_timeout
-
-        ) as client:
-            response = client.get(initial_url)
-
-            if response.status_code == 403:
-                console.print("[bold red]The owner of this website has banned your IP[/bold red]")
-                raise
-
-            response.raise_for_status()
-            
-            # Capture the final URL after all redirects
-            final_url = response.url
+        parsed = urlparse(url_str)
+        domain = parsed.netloc.lower()
+        if domain.startswith('www.'):
+            domain = domain[4:]
+
+        # Check if domain has multiple parts separated by dots
+        parts = domain.split('.')
+        if len(parts) > 2:  # Handle subdomains
+            return '.'.join(parts[:-1])  # Return everything except TLD
         
-        return final_url
+        return parts[0]  # Return base domain
     
-    except Exception as e:
-        console.print(f"\n[cyan]Test url[white]: [red]{initial_url}, [cyan]error[white]: [red]{e}")
+    except Exception:
+        return None
+    
+def get_base_url(url_str):
+    """Extract base URL including protocol and domain, removing path and query parameters."""
+    try:
+        parsed = urlparse(url_str)
+        return f"{parsed.scheme}://{parsed.netloc}"
+    
+    except Exception:
         return None
 
-def search_domain(site_name: str, base_url: str, get_first: bool = False):
-    """
-    Search for a valid domain for the given site name and base URL.
-
-    Parameters:
-        - site_name (str): The name of the site to search the domain for.
-        - base_url (str): The base URL to construct complete URLs.
-        - get_first (bool): If True, automatically update to the first valid match without user confirmation.
+def validate_url(url, base_url, max_timeout, max_retries=3, sleep=3):
+    """Validate if URL is accessible and matches expected base domain."""
+    console.print(f"\n[cyan]Starting validation for URL[white]: [yellow]{url}")
+    
+    # Verify URL structure matches base_url structure
+    base_domain = get_base_domain(base_url)
+    url_domain = get_base_domain(url)
 
-    Returns:
-        tuple: The found domain and the complete URL.
-    """
+    base_headers['referer'] = url
+    base_headers['user-agent'] = get_headers()
+    
+    if base_domain != url_domain:
+        console.print(f"[red]Domain structure mismatch: {url_domain} != {base_domain}")
+        return False, None
     
-    # Extract config domain
+    # Count dots to ensure we don't have extra subdomains
+    base_dots = base_url.count('.')
+    url_dots = url.count('.')
+    if url_dots > base_dots + 1:  # Allow for one extra dot for TLD change
+        console.print(f"[red]Too many subdomains in URL")
+        return False, None
+
+    client = httpx.Client(
+        verify=False,
+        headers=base_headers,
+        timeout=max_timeout
+    )
+
+    for retry in range(max_retries):
+        try:
+            time.sleep(sleep)
+            
+            # Initial check without redirects
+            response = client.get(url, follow_redirects=False)
+            if response.status_code == 403:
+                console.print(f"[red]Check failed (403) - Attempt {retry + 1}/{max_retries}")
+                continue
+                
+            if response.status_code >= 400:
+                console.print(f"[red]Check failed: HTTP {response.status_code}")
+                return False, None
+                
+            # Follow redirects and verify final domain
+            final_response = client.get(url, follow_redirects=True)
+            final_domain = get_base_domain(str(final_response.url))
+            console.print(f"[cyan]Redirect url: [red]{final_response.url}")
+            
+            if final_domain != base_domain:
+                console.print(f"[red]Final domain mismatch: {final_domain} != {base_domain}")
+                return False, None
+                
+            new_tld = get_tld(str(final_response.url))
+            if new_tld != get_tld(url):
+                return True, new_tld
+                
+            return True, None
+            
+        except (httpx.RequestError, ssl.SSLError) as e:
+            console.print(f"[red]Connection error: {str(e)}")
+            time.sleep(sleep)
+            continue
+            
+    return False, None
+
+def search_domain(site_name: str, base_url: str, get_first: bool = False):
+    """Search for valid domain matching site name and base URL."""
     max_timeout = config_manager.get_int("REQUESTS", "timeout")
     domain = str(config_manager.get_dict("SITE", site_name)['domain'])
+    
+    # Test initial URL
+    try:
+        is_correct, redirect_tld = validate_url(base_url, base_url, max_timeout)
+
+        if is_correct:
+            tld = redirect_tld or get_tld(base_url)
+            config_manager.config['SITE'][site_name]['domain'] = tld
+            config_manager.write_config()
+            console.print(f"[green]Successfully validated initial URL")
+            return tld, base_url
+        
+    except Exception as e:
+        console.print(f"[red]Error testing initial URL: {str(e)}")
 
+    # Google search phase
+    base_domain = get_base_domain(base_url)
+    console.print(f"\n[cyan]Searching for alternate domains for[white]: [yellow]{base_domain}")
+    
     try:
-        # Test the current domain
-        with httpx.Client(
-            headers={
-                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',
-                'accept-language': 'it-IT,it;q=0.9,en-US;q=0.8,en;q=0.7',
-                'User-Agent': get_headers()
-            },
-            follow_redirects=True,
-            timeout=max_timeout
-        ) as client:
-            response_follow = client.get(f"{base_url}.{domain}")
-            response_follow.raise_for_status()
+        search_results = list(search(base_domain, num_results=20, lang="it"))
+        base_urls = set()
 
+        for url in search_results:
+            base_url = get_base_url(url)
+            if base_url:
+                base_urls.add(base_url)
+        
+        # Filter URLs based on domain matching and subdomain count
+        filtered_results = [
+            url for url in base_urls 
+            if get_base_domain(url) == base_domain 
+            and url.count('.') <= base_url.count('.') + 1
+        ]
+
+        for idx, result_url in enumerate(filtered_results, 1):
+            console.print(f"\n[cyan]Checking result {idx}/{len(filtered_results)}[white]: [yellow]{result_url}")
+            
+            is_valid, new_tld = validate_url(result_url, base_url, max_timeout)
+            if is_valid:
+                final_tld = new_tld or get_tld(result_url)
+
+                if get_first or msg.ask(
+                    f"\n[cyan]Update site[white] [red]'{site_name}'[cyan] with domain[white] [red]'{final_tld}'",
+                    choices=["y", "n"],
+                    default="y"
+                ).lower() == "y":
+                    
+                    config_manager.config['SITE'][site_name]['domain'] = final_tld
+                    config_manager.write_config()
+                    return final_tld, f"{base_url}.{final_tld}"
+                    
     except Exception as e:
-        query = base_url.split("/")[-1]
-
-        # Perform a Google search with multiple results
-        search_results = list(search(query, num_results=10, lang="it"))
-        #console.print(f"\nGoogle search results: {search_results}")
-
-        def normalize_for_comparison(url):
-            """Normalize URL by removing protocol, www, and trailing slashes"""
-            url = url.lower()
-            url = url.replace("https://", "").replace("http://", "")
-            url = url.replace("www.", "")
-            return url.rstrip("/")
-
-        # Normalize the base_url we're looking for
-        target_url = normalize_for_comparison(base_url)
-
-        # Iterate through search results
-        for first_url in search_results:
-            console.print(f"[green]Checking url[white]: [red]{first_url}")
-
-            # Get just the domain part of the search result
-            parsed_result = urlparse(first_url)
-            result_domain = normalize_for_comparison(parsed_result.netloc)
-
-            # Compare with our target URL (without the protocol part)
-            if result_domain.startswith(target_url.split("/")[-1]):
-                try:
-                    final_url = get_final_redirect_url(first_url, max_timeout)
-
-                    if final_url is not None:
-                        def extract_domain(url):
-                            parsed_url = urlparse(url)
-                            domain = parsed_url.netloc
-                            return domain.split(".")[-1]
-
-                        new_domain_extract = extract_domain(str(final_url))
-
-                        if get_first or msg.ask(f"\n[cyan]Do you want to auto update site[white] [red]'{site_name}'[cyan] with domain[white] [red]'{new_domain_extract}'.", choices=["y", "n"], default="y").lower() == "y":
-                            # Update domain in config.json
-                            config_manager.config['SITE'][site_name]['domain'] = new_domain_extract
-                            config_manager.write_config()
-
-                            return new_domain_extract, f"{base_url}.{new_domain_extract}"
-
-                except Exception as redirect_error:
-                    console.print(f"[red]Error following redirect for {first_url}: {redirect_error}")
-                    continue
-
-        # If no matching URL is found return base domain
-        console.print("[bold red]No valid URL found matching the base URL.[/bold red]")
-        return domain, f"{base_url}.{domain}"
-
-    # Handle successful initial domain check
-    parsed_url = urlparse(str(response_follow.url))
-    parse_domain = parsed_url.netloc
-    tld = parse_domain.split('.')[-1]
-
-    if tld is not None:
-        # Update domain in config.json
-        config_manager.config['SITE'][site_name]['domain'] = tld
-        config_manager.write_config()
-
-    # Return config domain
-    return tld, f"{base_url}.{tld}"
+        console.print(f"[red]Error during search: {str(e)}")
+
+    console.print("[bold red]No valid URLs found matching the base URL.")
+    return domain, f"{base_url}.{domain}"

StreamingCommunity/Api/Template/site.py

@@ -74,7 +74,7 @@ def get_select_title(table_show_manager, media_search_manager):
     table_show_manager.clear()
 
     # Handle user's quit command
-    if last_command == "q":
+    if last_command == "q" or last_command == "quit":
         console.print("\n[red]Quit [white]...")
         sys.exit(0)
 

StreamingCommunity/Lib/Downloader/HLS/downloader.py

@@ -11,7 +11,7 @@ import httpx
 
 # Internal utilities
 from StreamingCommunity.Util._jsonConfig import config_manager
-from StreamingCommunity.Util.console import console, Panel, Table
+from StreamingCommunity.Util.console import console, Panel
 from StreamingCommunity.Util.color import Colors
 from StreamingCommunity.Util.os import (
     compute_sha1_hash,
@@ -104,14 +104,15 @@ class HttpClient:
             response = httpx.get(
                 url=url, 
                 headers=self.headers, 
-                timeout=max_timeout
+                timeout=max_timeout,
+                follow_redirects=True
             )
 
             response.raise_for_status()
             return response.text
 
         except Exception as e:
-            logging.info(f"Request to {url} failed with error: {e}")
+            console.print(f"Request to {url} failed with error: {e}")
             return 404
 
     def get_content(self, url):
@@ -283,6 +284,7 @@ class ContentExtractor:
     
         print("")
 
+
 class DownloadTracker:
     def __init__(self, path_manager: PathManager):
         """
@@ -814,6 +816,9 @@ class HLS_Downloader:
             else:
                 console.log("[red]Error: m3u8_index is None")
 
+        # Reset
+        self._reset()
+
     def _clean(self, out_path: str) -> None:
         """
         Cleans up temporary files and folders after downloading and processing.
@@ -952,3 +957,9 @@ class HLS_Downloader:
 
         # Clean up temporary files and directories
         self._clean(self.content_joiner.converted_out_path)
+
+    def _reset(self):
+        global list_MissingTs, m3u8_url_fixer
+
+        m3u8_url_fixer.reset_playlist()
+        list_MissingTs = []

StreamingCommunity/Lib/Downloader/HLS/segments.py

@@ -131,6 +131,7 @@ class M3U8_Segments:
         # Convert the content of the response to hexadecimal and then to bytes
         hex_content = binascii.hexlify(response.content).decode('utf-8')
         byte_content = bytes.fromhex(hex_content)
+        logging.info(f"URI: Hex content: {hex_content}, Byte content: {byte_content}")
         
         #console.print(f"[cyan]Find key: [red]{hex_content}")
         return byte_content
@@ -160,6 +161,7 @@ class M3U8_Segments:
 
             iv = m3u8_parser.keys.get('iv')
             method = m3u8_parser.keys.get('method')
+            logging.info(f"M3U8_Decryption - IV: {iv}, method: {method}")
 
             # Create a decryption object with the key and set the method
             self.decryption = M3U8_Decryption(key, iv, method)
@@ -194,23 +196,28 @@ class M3U8_Segments:
         """
         if self.is_index_url:
 
-            # Send a GET request to retrieve the index M3U8 file
-            response = httpx.get(
-                self.url, 
-                headers={'User-Agent': get_headers()}, 
-                timeout=max_timeout
-            )
-            response.raise_for_status()
+            try:
 
-            # Save the M3U8 file to the temporary folder
-            path_m3u8_file = os.path.join(self.tmp_folder, "playlist.m3u8")
-            open(path_m3u8_file, "w+").write(response.text) 
+                # Send a GET request to retrieve the index M3U8 file
+                response = httpx.get(
+                    self.url, 
+                    headers={'User-Agent': get_headers()}, 
+                    timeout=max_timeout,
+                    follow_redirects=True
+                )
+                response.raise_for_status()
 
-            # Parse the text from the M3U8 index file
-            self.parse_data(response.text)  
+                # Save the M3U8 file to the temporary folder
+                path_m3u8_file = os.path.join(self.tmp_folder, "playlist.m3u8")
+                open(path_m3u8_file, "w+").write(response.text) 
 
-        else:
+                # Parse the text from the M3U8 index file
+                self.parse_data(response.text)  
 
+            except Exception as e:
+                print(f"Error during M3U8 index request: {e}")
+
+        else:
             # Parser data of content of index pass in input to class
             self.parse_data(self.url)
     
@@ -303,7 +310,9 @@ class M3U8_Segments:
                         
                     except Exception as e:
                         logging.error(f"Decryption failed for segment {index}: {str(e)}")
-                        raise
+                        self.interrupt_flag.set()   # Interrupt the download process
+                        self.stop_event.set()       # Trigger the stopping event for all threads
+                        break                       # Stop the current task immediately
 
                 # Update progress and queue
                 self.class_ts_estimator.update_progress_bar(content_size, duration, progress_bar)
@@ -385,7 +394,7 @@ class M3U8_Segments:
                         buffer[index] = segment_content
 
                 except queue.Empty:
-                    self.current_timeout = min(self.max_timeout, self.current_timeout * 1.5)
+                    self.current_timeout = min(self.max_timeout, self.current_timeout * 1.25)
 
                     if self.stop_event.is_set():
                         break
@@ -532,10 +541,14 @@ class M3U8_Segments:
         progress_bar.close()
 
         # Final verification
-        final_completion = (len(self.downloaded_segments) / total_segments) * 100
-        if final_completion < 99.9:  # Less than 99.9% complete
-            missing = set(range(total_segments)) - self.downloaded_segments
-            raise Exception(f"Download incomplete ({final_completion:.1f}%). Missing segments: {sorted(missing)}")
+        try:
+            final_completion = (len(self.downloaded_segments) / total_segments) * 100
+            if final_completion < 99.9:  # Less than 99.9% complete
+                missing = set(range(total_segments)) - self.downloaded_segments
+                raise Exception(f"Download incomplete ({final_completion:.1f}%). Missing segments: {sorted(missing)}")
+            
+        except:
+            pass
 
         # Verify output file
         if not os.path.exists(self.tmp_file_path):
@@ -545,15 +558,16 @@ class M3U8_Segments:
         if file_size == 0:
             raise Exception("Output file is empty")
 
-        # Display additional 
-        if self.info_nRetry >= len(self.segments) * (1/3.33):
+        # Display additional info when there is missing stream file
+        if self.info_nFailed > 0:
 
             # Get expected time
             ex_hours, ex_minutes, ex_seconds = format_duration(self.expected_real_time_s)
             ex_formatted_duration = f"[yellow]{int(ex_hours)}[red]h [yellow]{int(ex_minutes)}[red]m [yellow]{int(ex_seconds)}[red]s"
             console.print(f"[cyan]Max retry per URL[white]: [green]{self.info_maxRetry}[green] [white]| [cyan]Total retry done[white]: [green]{self.info_nRetry}[green] [white]| [cyan]Missing TS: [red]{self.info_nFailed} [white]| [cyan]Duration: {print_duration_table(self.tmp_file_path, None, True)} [white]| [cyan]Expected duation: {ex_formatted_duration} \n")
 
-            console.print("[yellow]⚠ Warning:[/yellow] Too many retries detected! Consider reducing the number of [cyan]workers[/cyan] in the [magenta]config.json[/magenta] file. This will impact [bold]performance[/bold]. \n")
+            if self.info_nRetry >= len(self.segments) * 0.3:
+                console.print("[yellow]⚠ Warning:[/yellow] Too many retries detected! Consider reducing the number of [cyan]workers[/cyan] in the [magenta]config.json[/magenta] file. This will impact [bold]performance[/bold]. \n")
 
         # Info to return
         return {'type': type, 'nFailed': self.info_nFailed}

StreamingCommunity/Lib/Downloader/TOR/downloader.py

@@ -139,9 +139,8 @@ class TOR_downloader:
         
         # Formatta e stampa le informazioni
         console.print("\n[bold green]🔗 Dettagli Torrent Aggiunto:[/bold green]")
-        console.print(f"[yellow]Nome:[/yellow] {torrent_info.get('name', torrent_name)}")
+        console.print(f"[yellow]Name:[/yellow] {torrent_info.get('name', torrent_name)}")
         console.print(f"[yellow]Hash:[/yellow] {torrent_info['hash']}")
-        console.print(f"[yellow]Dimensione:[/yellow] {internet_manager.format_file_size(torrent_info.get('size'))}")
         print()
 
         # Salva l'hash per usi successivi e il path
@@ -288,7 +287,8 @@ class TOR_downloader:
                     raise
 
             # Delete the torrent data
-            #self.qb.delete_permanently(self.qb.torrents()[-1]['hash'])
+            time.sleep(5)
+            self.qb.delete_permanently(self.qb.torrents()[-1]['hash'])
             return True
 
         except Exception as e:

StreamingCommunity/Lib/M3U8/decryptor.py

@@ -61,6 +61,7 @@ if crypto_installed:
                 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"}:

StreamingCommunity/Lib/M3U8/estimator.py

@@ -199,7 +199,7 @@ class M3U8_Ts_Estimator:
             
             if TQDM_USE_LARGE_BAR:
                 speed_data = self.get_average_speed()
-                logging.debug(f"Speed data for progress bar: {speed_data}")
+                #logging.debug(f"Speed data for progress bar: {speed_data}")
                 
                 if len(speed_data) >= 2:
                     average_internet_speed = speed_data[0]
@@ -223,7 +223,7 @@ class M3U8_Ts_Estimator:
                 )
             
             progress_counter.set_postfix_str(progress_str)
-            logging.debug(f"Updated progress bar: {progress_str}")
+            #logging.debug(f"Updated progress bar: {progress_str}")
             
         except Exception as e:
             logging.error(f"Error updating progress bar: {str(e)}")

StreamingCommunity/Lib/M3U8/url_fixer.py

@@ -49,4 +49,10 @@ class M3U8_UrlFix:
         full_url = urljoin(base_url, url_resource)
 
         return full_url
+    
+    def reset_playlist(self) -> None:
+        """
+        Reset the M3U8 playlist URL to its default state (None).
+        """
+        self.url_playlist = None
     

StreamingCommunity/Lib/TMBD/tmdb.py

@@ -75,7 +75,7 @@ def get_select_title(table_show_manager, generic_obj):
     table_show_manager.clear()
 
     # Handle user's quit command
-    if last_command == "q":
+    if last_command == "q" or last_command == "quit":
         Console.print("\n[red]Quit [white]...")
         sys.exit(0)
 

StreamingCommunity/Upload/version.py

@@ -1,5 +1,5 @@
 __title__ = 'StreamingCommunity'
-__version__ = '2.2.0'
+__version__ = '2.4.0'
 __author__ = 'Lovi-0'
 __description__ = 'A command-line program to download film'
 __copyright__ = 'Copyright 2024'