StreamingCommunity 3.0.1__py3-none-any.whl → 3.0.3__py3-none-any.whl

StreamingCommunity/Api/Site/streamingwatch/site.py

@@ -0,0 +1,111 @@
+# 29.04.25
+
+import re
+
+
+# External libraries
+import httpx
+from bs4 import BeautifulSoup
+from rich.console import Console
+
+
+# Internal utilities
+from StreamingCommunity.Util.config_json import config_manager
+from StreamingCommunity.Util.headers import get_userAgent
+from StreamingCommunity.Util.table import TVShowManager
+
+
+# Logic class
+from StreamingCommunity.Api.Template.config_loader import site_constant
+from StreamingCommunity.Api.Template.Class.SearchType import MediaManager
+
+
+# Variable
+console = Console()
+media_search_manager = MediaManager()
+table_show_manager = TVShowManager()
+max_timeout = config_manager.get_int("REQUESTS", "timeout")
+
+
+def extract_nonce(response_) -> str:
+    """Extract nonce value from the page script"""
+    soup = BeautifulSoup(response_.content, 'html.parser')
+    script = soup.find('script', id='live-search-js-extra')
+    if script:
+        match = re.search(r'"admin_ajax_nonce":"([^"]+)"', script.text)
+        if match:
+            return match.group(1)
+    return ""
+
+
+def title_search(query: str, additionalData: list) -> int:
+    """
+    Search for titles based on a search query.
+      
+    Parameters:
+        - query (str): The query to search for.
+
+    Returns:
+        int: The number of titles found.
+    """
+    media_search_manager.clear()
+    table_show_manager.clear()
+
+    proxy, response_serie = additionalData
+    search_url = f"{site_constant.FULL_URL}/wp-admin/admin-ajax.php"
+    console.print(f"[cyan]Search url: [yellow]{search_url}")
+
+    try:
+        _wpnonce = extract_nonce(response_serie)
+        
+        if not _wpnonce:
+            console.print("[red]Error: Failed to extract nonce")
+            return 0
+
+        data = {
+            'action': 'data_fetch',
+            'keyword': query,
+            '_wpnonce': _wpnonce
+        }
+
+        response = httpx.post(
+            search_url,
+            headers={
+                'origin': site_constant.FULL_URL,
+                'user-agent': get_userAgent()
+            },
+            data=data,
+            timeout=max_timeout,
+            proxy=proxy
+        )
+        response.raise_for_status()
+        soup = BeautifulSoup(response.text, 'html.parser')
+
+    except Exception as e:
+        console.print(f"[red]Site: {site_constant.SITE_NAME}, request search error: {e}")
+        return 0
+
+    for item in soup.find_all('div', class_='searchelement'):
+        try:
+
+            title = item.find_all("a")[-1].get_text(strip=True) if item.find_all("a") else 'N/A'
+            url = item.find('a').get('href', '')
+            year = item.find('div', id='search-cat-year')
+            year = year.get_text(strip=True) if year else 'N/A'
+
+            if any(keyword in year.lower() for keyword in ['stagione', 'episodio', 'ep.', 'season', 'episode']):
+                continue
+
+            media_search_manager.add_media({
+                'name': title,
+                'type': 'tv' if '/serie/' in url else 'Film',
+                'date': year,
+                'image': item.find('img').get('src', ''),
+                'url': url
+            })
+
+        except Exception as e:
+            print(f"Error parsing a film entry: {e}")
+          
+    # Return the number of titles found
+    return media_search_manager.get_length()

StreamingCommunity/Api/Site/streamingwatch/util/ScrapeSerie.py

@@ -0,0 +1,118 @@
+# 29.04.25
+
+import re
+import logging
+
+
+# External libraries
+import httpx
+from bs4 import BeautifulSoup
+
+# Internal utilities
+from StreamingCommunity.Util.headers import get_userAgent
+from StreamingCommunity.Util.config_json import config_manager
+from StreamingCommunity.Api.Player.Helper.Vixcloud.util import SeasonManager, Episode
+
+
+# Variable
+max_timeout = config_manager.get_int("REQUESTS", "timeout")
+
+
+class GetSerieInfo:
+    def __init__(self, url, proxy: str = None):
+        self.headers = {'user-agent': get_userAgent()}
+        self.url = url
+        self.seasons_manager = SeasonManager()
+        self.series_name = None
+        
+        self.client = httpx.Client(headers=self.headers, proxy=proxy, timeout=max_timeout)
+
+    def collect_info_season(self) -> None:
+        """
+        Retrieve all series information including episodes and seasons.
+        """
+        try:
+            response = self.client.get(self.url)
+            response.raise_for_status()
+            soup = BeautifulSoup(response.text, 'html.parser')
+            
+            if not self.series_name:
+                title_tag = soup.find('h1', class_='title-border')
+                self.series_name = title_tag.get_text(strip=True) if title_tag else 'N/A'
+            
+            # Extract episodes and organize by season
+            episodes = {}
+            for ep in soup.find_all('div', class_='bolumust'):
+                a_tag = ep.find('a')
+                if not a_tag:
+                    continue
+                
+                ep_url = a_tag.get('href', '')
+                episode_title = a_tag.get_text(strip=True)
+                
+                # Clean up episode title by removing season info and date
+                clean_title = re.sub(r'Stagione \d+ Episodio \d+\s*\(?([^)]+)\)?\s*\d+\s*\w+\s*\d+', r'\1', episode_title)
+                
+                season_match = re.search(r'stagione-(\d+)', ep_url)
+                if season_match:
+                    season_num = int(season_match.group(1))
+                    if season_num not in episodes:
+                        episodes[season_num] = []
+                    
+                    episodes[season_num].append({
+                        'id': len(episodes[season_num]) + 1,
+                        'number': len(episodes[season_num]) + 1,
+                        'name': clean_title.strip(),
+                        'url': ep_url
+                    })
+            
+            # Add seasons to SeasonManager
+            for season_num, eps in episodes.items():
+                season = self.seasons_manager.add_season({
+                    'id': season_num,
+                    'number': season_num,
+                    'name': f'Stagione {season_num}'
+                })
+                
+                # Add episodes to season's EpisodeManager
+                for ep in eps:
+                    season.episodes.add(ep)
+                
+        except Exception as e:
+            logging.error(f"Error collecting series info: {str(e)}")
+            raise
+
+    # ------------- FOR GUI -------------
+    def getNumberSeason(self) -> int:
+        """
+        Get the total number of seasons available for the series.
+        """
+        if not self.seasons_manager.seasons:
+            self.collect_info_season()
+
+        return len(self.seasons_manager.seasons)
+    
+    def getEpisodeSeasons(self, season_number: int) -> list:
+        """
+        Get all episodes for a specific season.
+        """
+        if not self.seasons_manager.seasons:
+            self.collect_info_season()
+            
+        season = self.seasons_manager.get_season_by_number(season_number)
+        if not season:
+            logging.error(f"Season {season_number} not found")
+            return []
+            
+        return season.episodes.episodes
+        
+    def selectEpisode(self, season_number: int, episode_index: int) -> Episode:
+        """
+        Get information for a specific episode in a specific season.
+        """
+        episodes = self.getEpisodeSeasons(season_number)
+        if not episodes or episode_index < 0 or episode_index >= len(episodes):
+            logging.error(f"Episode index {episode_index} is out of range for season {season_number}")
+            return None
+            
+        return episodes[episode_index]

StreamingCommunity/Lib/Proxies/proxy.py

@@ -0,0 +1,232 @@
+# 29.04.25
+
+import os
+import sys
+import time
+import json
+import signal
+import warnings
+warnings.filterwarnings("ignore", category=UserWarning)
+from datetime import datetime, timedelta
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+
+# External library
+import httpx
+from rich import print
+from rich.progress import Progress, SpinnerColumn, BarColumn, TextColumn, TimeRemainingColumn
+
+
+# Internal utilities
+from StreamingCommunity.Util.config_json import config_manager
+from StreamingCommunity.Util.headers import get_headers
+
+
+# Variable
+MAX_TIMEOUT = config_manager.get_int("REQUESTS", "timeout")
+
+
+class ProxyFinder:
+    def __init__(self, url, timeout_threshold: float = 7.0, max_proxies: int = 150, max_workers: int = 12):
+        self.url = url
+        self.timeout_threshold = timeout_threshold
+        self.max_proxies = max_proxies
+        self.max_workers = max_workers
+        self.found_proxy = None
+        self.shutdown_flag = False
+        self.json_file = os.path.join(os.path.dirname(__file__), 'working_proxies.json')
+        signal.signal(signal.SIGINT, self._handle_interrupt)
+
+    def load_saved_proxies(self) -> tuple:
+        """Load saved proxies if they're not expired (2 hours old)"""
+        try:
+            if not os.path.exists(self.json_file):
+                return None, None
+                
+            with open(self.json_file, 'r') as f:
+                data = json.load(f)
+                
+            if not data.get('proxies') or not data.get('last_update'):
+                return None, None
+                
+            last_update = datetime.fromisoformat(data['last_update'])
+            if datetime.now() - last_update > timedelta(hours=2):
+                return None, None
+                
+            return data['proxies'], last_update
+        except Exception:
+            return None, None
+            
+    def save_working_proxy(self, proxy: str, response_time: float):
+        """Save working proxy to JSON file"""
+        data = {
+            'proxies': [{'proxy': proxy, 'response_time': response_time}],
+            'last_update': datetime.now().isoformat()
+        }
+        try:
+            with open(self.json_file, 'w') as f:
+                json.dump(data, f, indent=4)
+        except Exception as e:
+            print(f"[bold red]Error saving proxy:[/bold red] {str(e)}")
+
+    def fetch_geonode(self) -> list:
+        proxies = []
+        try:
+            response = httpx.get(
+                "https://proxylist.geonode.com/api/proxy-list?protocols=http%2Chttps&limit=100&page=1&sort_by=speed&sort_type=asc",
+                headers=get_headers(), 
+                timeout=MAX_TIMEOUT
+            )
+            data = response.json()
+            proxies = [(f"http://{p['ip']}:{p['port']}", "Geonode") for p in data.get('data', [])]
+            
+        except Exception as e:
+            print(f"[bold red]Error in Geonode:[/bold red] {str(e)[:100]}")
+
+        return proxies
+
+    def fetch_proxyscrape(self) -> list:
+        proxies = []
+        try:
+            response = httpx.get(
+                "https://api.proxyscrape.com/v4/free-proxy-list/get?request=get_proxies&protocol=http&skip=0&proxy_format=protocolipport&format=json&limit=100&timeout=1000",
+                headers=get_headers(), 
+                timeout=MAX_TIMEOUT
+            )
+            data = response.json()
+            if 'proxies' in data and isinstance(data['proxies'], list):
+                proxies = [(proxy_data['proxy'], "ProxyScrape") for proxy_data in data['proxies'] if 'proxy' in proxy_data]
+
+        except Exception as e:
+            print(f"[bold red]Error in ProxyScrape:[/bold red] {str(e)[:100]}")
+
+        return proxies
+
+    def fetch_proxies_from_sources(self) -> list:
+        #print("[cyan]Fetching proxies from sources...[/cyan]")
+        with ThreadPoolExecutor(max_workers=3) as executor:
+            proxyscrape_future = executor.submit(self.fetch_proxyscrape)
+            geonode_future = executor.submit(self.fetch_geonode)
+            
+            sources_proxies = {}
+            
+            try:
+                proxyscrape_result = proxyscrape_future.result()
+                sources_proxies["proxyscrape"] = proxyscrape_result[:int(self.max_proxies/2)]
+            except Exception as e:
+                print(f"[bold red]Error fetching from proxyscrape:[/bold red] {str(e)[:100]}")
+                sources_proxies["proxyscrape"] = []
+            
+            try:
+                geonode_result = geonode_future.result()
+                sources_proxies["geonode"] = geonode_result[:int(self.max_proxies/2)]
+            except Exception as e:
+                print(f"[bold red]Error fetching from geonode:[/bold red] {str(e)[:100]}")
+                sources_proxies["geonode"] = []
+            
+            merged_proxies = []
+            
+            if "proxyscrape" in sources_proxies:
+                merged_proxies.extend(sources_proxies["proxyscrape"])
+            
+            if "geonode" in sources_proxies:
+                merged_proxies.extend(sources_proxies["geonode"])
+            
+            proxy_list = merged_proxies[:self.max_proxies]
+            return proxy_list
+
+    def _test_single_request(self, proxy_info: tuple) -> tuple:
+        proxy, source = proxy_info
+        try:
+            start = time.time()
+            with httpx.Client(proxy=proxy, timeout=self.timeout_threshold) as client:
+                response = client.get(self.url, headers=get_headers())
+                if response.status_code == 200:
+                    return (True, time.time() - start, response, source)
+        except Exception:
+            pass
+        return (False, self.timeout_threshold + 1, None, source)
+
+    def test_proxy(self, proxy_info: tuple) -> tuple:
+        proxy, source = proxy_info
+        if self.shutdown_flag:
+            return (proxy, False, 0, None, source)
+        
+        success1, time1, text1, source = self._test_single_request(proxy_info)
+        if not success1 or time1 > self.timeout_threshold:
+            return (proxy, False, time1, None, source)
+        
+        success2, time2, _, source = self._test_single_request(proxy_info)
+        avg_time = (time1 + time2) / 2
+        return (proxy, success2 and time2 <= self.timeout_threshold, avg_time, text1, source)
+
+    def _handle_interrupt(self, sig, frame):
+        print("\n[bold yellow]Received keyboard interrupt. Terminating...[/bold yellow]")
+        self.shutdown_flag = True
+        sys.exit(0)
+
+    def find_fast_proxy(self) -> tuple:
+        saved_proxies, last_update = self.load_saved_proxies()
+        if saved_proxies:
+            print("[cyan]Testing saved proxy...[/cyan]")
+            for proxy_data in saved_proxies:
+                result = self.test_proxy((proxy_data['proxy'], 'cached'))
+                if result[1]:
+                    return proxy_data['proxy'], result[3], result[2]
+                else:
+                    print(f"[red]Saved proxy {proxy_data['proxy']} failed - response time: {result[2]:.2f}s[/red]")
+
+        proxies = self.fetch_proxies_from_sources()
+        if not proxies:
+            print("[bold red]No proxies fetched to test.[/bold red]")
+            return (None, None, None)
+             
+        found_proxy = None
+        response_text = None
+        source = None
+        failed_count = 0
+        success_count = 0
+
+        #print(f"[cyan]Testing {len(proxies)} proxies...[/cyan]")
+        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+            futures = {executor.submit(self.test_proxy, p): p for p in proxies}
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                BarColumn(),
+                TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+                TextColumn("[cyan]{task.fields[success]}[/cyan]/[red]{task.fields[failed]}[/red]"),
+                TimeRemainingColumn(),
+            ) as progress:
+                task = progress.add_task(
+                    "[cyan]Testing Proxies", 
+                    total=len(futures),
+                    success=success_count,
+                    failed=failed_count
+                )
+                
+                for future in as_completed(futures):
+                    if self.shutdown_flag:
+                        break
+
+                    try:
+                        proxy, success, elapsed, response, proxy_source = future.result()
+                        if success:
+                            success_count += 1
+                            print(f"[bold green]Found valid proxy:[/bold green] {proxy} ({elapsed:.2f}s)")
+                            found_proxy = proxy
+                            response_text = response
+                            self.save_working_proxy(proxy, elapsed)
+                            self.shutdown_flag = True
+                            break
+                        else:
+                            failed_count += 1
+                    except Exception:
+                        failed_count += 1
+                    
+                    progress.update(task, advance=1, success=success_count, failed=failed_count)
+
+        if not found_proxy:
+            print("[bold red]No working proxies found[/bold red]")
+        
+        return (found_proxy, response_text, source)

StreamingCommunity/Upload/update.py

@@ -3,7 +3,7 @@
 import os
 import sys
 import time
-
+import asyncio
 
 # External library
 import httpx
@@ -24,32 +24,33 @@ else:
     base_path = os.path.dirname(__file__)
 console = Console()
 
+async def fetch_github_data(client, url):
+    """Helper function to fetch data from GitHub API"""
+    response = await client.get(
+        url=url,
+        headers={'user-agent': get_userAgent()},
+        timeout=config_manager.get_int("REQUESTS", "timeout"),
+        follow_redirects=True
+    )
+    return response.json()
+
+async def async_github_requests():
+    """Make concurrent GitHub API requests"""
+    async with httpx.AsyncClient() as client:
+        tasks = [
+            fetch_github_data(client, f"https://api.github.com/repos/{__author__}/{__title__}"),
+            fetch_github_data(client, f"https://api.github.com/repos/{__author__}/{__title__}/releases"),
+            fetch_github_data(client, f"https://api.github.com/repos/{__author__}/{__title__}/commits")
+        ]
+        return await asyncio.gather(*tasks)
 
 def update():
     """
     Check for updates on GitHub and display relevant information.
     """
     try:
-        response_reposity = httpx.get(
-            url=f"https://api.github.com/repos/{__author__}/{__title__}", 
-            headers={'user-agent': get_userAgent()}, 
-            timeout=config_manager.get_int("REQUESTS", "timeout"), 
-            follow_redirects=True
-        ).json()
-
-        response_releases = httpx.get(
-            url=f"https://api.github.com/repos/{__author__}/{__title__}/releases",
-            headers={'user-agent': get_userAgent()}, 
-            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()
+        # Run async requests concurrently
+        response_reposity, response_releases, response_commits = asyncio.run(async_github_requests())
         
     except Exception as e:
         console.print(f"[red]Error accessing GitHub API: {e}")
@@ -92,4 +93,4 @@ def update():
     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(4)

StreamingCommunity/Upload/version.py

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

StreamingCommunity/Util/os.py

@@ -19,6 +19,7 @@ from unidecode import unidecode
 from rich.console import Console
 from rich.prompt import Prompt
 from pathvalidate import sanitize_filename, sanitize_filepath
+from dns.resolver import dns
 
 
 # Internal utilities
@@ -282,6 +283,43 @@ class InternManager():
         else:
             return f"{bytes / (1024 * 1024):.2f} MB/s"
 
+    def check_dns_provider(self):
+        """
+        Check if the system's current DNS server matches any known DNS providers.
+        
+        Returns:
+            bool: True if the current DNS server matches a known provider,
+                  False if no match is found or in case of errors
+        """
+        dns_providers = {
+            "Cloudflare": ["1.1.1.1", "1.0.0.1"],
+            "Google": ["8.8.8.8", "8.8.4.4"],
+            "OpenDNS": ["208.67.222.222", "208.67.220.220"],
+            "Quad9": ["9.9.9.9", "149.112.112.112"],
+            "AdGuard": ["94.140.14.14", "94.140.15.15"],
+            "Comodo": ["8.26.56.26", "8.20.247.20"],
+            "Level3": ["209.244.0.3", "209.244.0.4"],
+            "Norton": ["199.85.126.10", "199.85.127.10"],
+            "CleanBrowsing": ["185.228.168.9", "185.228.169.9"],
+            "Yandex": ["77.88.8.8", "77.88.8.1"]
+        }
+        
+        try:
+            resolver = dns.resolver.Resolver()
+            nameservers = resolver.nameservers
+            
+            if not nameservers:
+                return False
+                
+            for server in nameservers:
+                for provider, ips in dns_providers.items():
+                    if server in ips:
+                        return True
+            return False
+            
+        except Exception:
+            return False
+
 
 class OsSummary:
     def __init__(self):

StreamingCommunity/global_search.py

@@ -58,7 +58,10 @@ def load_search_functions():
             # Get 'indice' from the module
             indice = getattr(mod, 'indice', 0)
             use_for = getattr(mod, '_useFor', 'other')
-            modules.append((module_name, indice, use_for))
+            priority = getattr(mod, '_priority', 0)
+
+            if priority == 0:
+                modules.append((module_name, indice, use_for))
 
         except Exception as e:
             console.print(f"[red]Failed to import module {module_name}: {str(e)}")
@@ -296,17 +299,26 @@ def process_selected_item(selected_item, search_functions):
     console.print(f"\n[bold green]Processing selection from:[/bold green] {selected_item.get('source')}")
     
     # Extract necessary information to pass to the site's search function
-    item_id = selected_item.get('id', selected_item.get('media_id'))
+    item_id = None
+    for id_field in ['id', 'media_id', 'ID', 'item_id', 'url']:
+        item_id = selected_item.get(id_field)
+        if item_id:
+            break
+            
     item_type = selected_item.get('type', selected_item.get('media_type', 'unknown'))
     item_title = selected_item.get('title', selected_item.get('name', 'Unknown'))
     
     if item_id:
         console.print(f"[bold green]Selected item:[/bold green] {item_title} (ID: {item_id}, Type: {item_type})")
         
-        # Call the site's search function with direct_item parameter to process download
         try:
             func(direct_item=selected_item)
+
         except Exception as e:
             console.print(f"[bold red]Error processing download:[/bold red] {str(e)}")
+            logging.exception("Download processing error")
+            
     else:
-        console.print("[bold red]Error: Item ID not found.[/bold red]")
+        console.print("[bold red]Error: Item ID not found. Available fields:[/bold red]")
+        for key in selected_item.keys():
+            console.print(f"[yellow]- {key}: {selected_item[key]}[/yellow]")

StreamingCommunity/run.py

@@ -21,7 +21,7 @@ from rich.prompt import Prompt
 from .global_search import global_search
 from StreamingCommunity.Util.message import start_message
 from StreamingCommunity.Util.config_json import config_manager
-from StreamingCommunity.Util.os import os_summary
+from StreamingCommunity.Util.os import os_summary, internet_manager
 from StreamingCommunity.Util.logger import Logger
 from StreamingCommunity.Upload.update import update as git_update
 from StreamingCommunity.Lib.TMBD import tmdb
@@ -200,6 +200,15 @@ def main(script_id = 0):
     # Create logger
     log_not = Logger()
     initialize()
+    
+    if not internet_manager.check_dns_provider():
+        console.print("[red]❌ ERROR: DNS configuration is required!")
+        console.print("[red]The program cannot function correctly without proper DNS settings.")
+        console.print("[yellow]Please configure one of these DNS servers:")
+        console.print("[blue]• Cloudflare (1.1.1.1)")
+        console.print("[blue]• Quad9 (9.9.9.9)")
+        console.print("\n[yellow]⚠️ The program will not work until you configure your DNS settings.")
+        input("[yellow]Press Enter to exit...")
 
     # Load search functions
     search_functions = load_search_functions()
@@ -381,4 +390,4 @@ def main(script_id = 0):
                 # Delete script_id
                 script_id = TelegramSession.get_session()
                 if script_id != "unknown":
-                    TelegramSession.deleteScriptId(script_id)
+                    TelegramSession.deleteScriptId(script_id)