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

StreamingCommunity/Api/Site/ilcorsaronero/site.py

@@ -2,6 +2,7 @@
 
 
 # Internal utilities
+from StreamingCommunity.Util._jsonConfig import config_manager
 from StreamingCommunity.Util.table import TVShowManager
 
 
@@ -13,9 +14,11 @@ from .util.ilCorsarScraper import IlCorsaroNeroScraper
 
 
 # Variable
-from .costant import SITE_NAME
+from .costant import SITE_NAME, DOMAIN_NOW
 media_search_manager = MediaManager()
 table_show_manager = TVShowManager()
+max_timeout = config_manager.get_int("REQUESTS", "timeout")
+disable_searchDomain = config_manager.get_bool("DEFAULT", "disable_searchDomain")
 
 
 async def title_search(word_to_search: str) -> int:
@@ -32,25 +35,31 @@ async def title_search(word_to_search: str) -> int:
     table_show_manager.clear()
 
     # Find new domain if prev dont work
-    domain_to_use, _ = search_domain(SITE_NAME, f"https://{SITE_NAME}")
+    domain_to_use = DOMAIN_NOW
+    
+    if not disable_searchDomain:
+        domain_to_use, base_url = search_domain(SITE_NAME, f"https://{SITE_NAME}")
 
     # Create scraper and collect result
     print("\n")
     scraper = IlCorsaroNeroScraper(f"https://{SITE_NAME}.{domain_to_use}/", 1)
     results = await scraper.search(word_to_search)
 
-    # Add all result to media manager
     for i, torrent in enumerate(results):
-        media_search_manager.add_media({
-            'name': torrent['name'],
-            'type': torrent['type'],
-            'seed': torrent['seed'],
-            'leech': torrent['leech'],
-            'size': torrent['size'],
-            'date': torrent['date'],
-            'url': torrent['url']
-        })
-
+        try:
+            
+            media_search_manager.add_media({
+                'name': torrent['name'],
+                'type': torrent['type'],
+                'seed': torrent['seed'],
+                'leech': torrent['leech'],
+                'size': torrent['size'],
+                'date': torrent['date'],
+                'url': torrent['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/ilcorsaronero/title.py

@@ -15,7 +15,7 @@ from StreamingCommunity.Api.Template.Class.SearchType import MediaItem
 
 
 # Config
-from .costant import ROOT_PATH, MOVIE_FOLDER
+from .costant import MOVIE_FOLDER
 
 
 def download_title(select_title: MediaItem):
@@ -27,13 +27,13 @@ def download_title(select_title: MediaItem):
     """
 
     start_message()
-    console.print(f"[yellow]Download:  [red]{select_title.name} \n")
+    console.print(f"[yellow]Download: [red]{select_title.name} \n")
     print() 
 
     # Define output path
     title_name = os_manager.get_sanitize_file(select_title.name)
     mp4_path = os_manager.get_sanitize_path(
-        os.path.join(ROOT_PATH, MOVIE_FOLDER, title_name.replace(".mp4", ""))
+        os.path.join(MOVIE_FOLDER, title_name.replace(".mp4", ""))
     )
 
     # Create output folder

StreamingCommunity/Api/Site/mostraguarda/costant.py

@@ -11,5 +11,9 @@ SITE_NAME = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
 ROOT_PATH = config_manager.get('DEFAULT', 'root_path')
 DOMAIN_NOW = config_manager.get_dict('SITE', SITE_NAME)['domain']
 
-SERIES_FOLDER = config_manager.get('DEFAULT', 'serie_folder_name')
-MOVIE_FOLDER = config_manager.get('DEFAULT', 'movie_folder_name')
+SERIES_FOLDER = os.path.join(ROOT_PATH, config_manager.get('DEFAULT', 'serie_folder_name'))
+MOVIE_FOLDER = os.path.join(ROOT_PATH, config_manager.get('DEFAULT', 'movie_folder_name'))
+
+if config_manager.get_bool("DEFAULT", "add_siteName"):
+    SERIES_FOLDER = os.path.join(ROOT_PATH, SITE_NAME, config_manager.get('DEFAULT', 'serie_folder_name'))
+    MOVIE_FOLDER = os.path.join(ROOT_PATH, SITE_NAME, config_manager.get('DEFAULT', 'movie_folder_name'))   

StreamingCommunity/Api/Site/mostraguarda/film.py

@@ -33,7 +33,7 @@ from StreamingCommunity.Lib.TMBD import Json_film
 
 
 # Config
-from .costant import ROOT_PATH, SITE_NAME, DOMAIN_NOW, MOVIE_FOLDER
+from .costant import SITE_NAME, DOMAIN_NOW, MOVIE_FOLDER
 
 
 def download_film(movie_details: Json_film) -> str:
@@ -75,7 +75,7 @@ def download_film(movie_details: Json_film) -> str:
     
     # Define output path
     title_name = os_manager.get_sanitize_file(movie_details.title) + ".mp4"
-    mp4_path = os.path.join(ROOT_PATH, MOVIE_FOLDER, title_name.replace(".mp4", ""))
+    mp4_path = os.path.join(MOVIE_FOLDER, title_name.replace(".mp4", ""))
 
     # Get m3u8 master playlist
     master_playlist = video_source.get_playlist()

StreamingCommunity/Api/Site/streamingcommunity/costant.py

@@ -9,7 +9,11 @@ from StreamingCommunity.Util._jsonConfig import config_manager
 
 SITE_NAME = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
 ROOT_PATH = config_manager.get('DEFAULT', 'root_path')
-DOMAIN_NOW = config_manager.get('SITE', SITE_NAME)
+DOMAIN_NOW = config_manager.get_dict('SITE', SITE_NAME)['domain']
 
-SERIES_FOLDER = config_manager.get('DEFAULT', 'serie_folder_name')
-MOVIE_FOLDER = config_manager.get('DEFAULT', 'movie_folder_name')
+SERIES_FOLDER = os.path.join(ROOT_PATH, config_manager.get('DEFAULT', 'serie_folder_name'))
+MOVIE_FOLDER = os.path.join(ROOT_PATH, config_manager.get('DEFAULT', 'movie_folder_name'))
+
+if config_manager.get_bool("DEFAULT", "add_siteName"):
+    SERIES_FOLDER = os.path.join(ROOT_PATH, SITE_NAME, config_manager.get('DEFAULT', 'serie_folder_name'))
+    MOVIE_FOLDER = os.path.join(ROOT_PATH, SITE_NAME, config_manager.get('DEFAULT', 'movie_folder_name'))   

StreamingCommunity/Api/Site/streamingcommunity/film.py

@@ -22,7 +22,7 @@ from StreamingCommunity.Api.Player.vixcloud import VideoSource
 
 
 # Variable
-from .costant import ROOT_PATH, SITE_NAME, MOVIE_FOLDER
+from .costant import SITE_NAME, MOVIE_FOLDER
         
 
 def download_film(select_title: MediaItem) -> str:
@@ -51,8 +51,8 @@ def download_film(select_title: MediaItem) -> str:
     master_playlist = video_source.get_playlist()
 
     # Define the filename and path for the downloaded film
-    title_name = os_manager.get_sanitize_file(select_title.slug) + ".mp4"
-    mp4_path = os.path.join(ROOT_PATH, MOVIE_FOLDER, select_title.slug)
+    title_name = os_manager.get_sanitize_file(select_title.name) + ".mp4"
+    mp4_path = os.path.join(MOVIE_FOLDER, select_title.name)
 
     # Download the film using the m3u8 playlist, and output filename
     r_proc = HLS_Downloader(

StreamingCommunity/Api/Site/streamingcommunity/series.py

@@ -24,7 +24,7 @@ from StreamingCommunity.Api.Player.vixcloud import VideoSource
 
 
 # Variable
-from .costant import ROOT_PATH, SITE_NAME, SERIES_FOLDER
+from .costant import SITE_NAME, SERIES_FOLDER
 
 
 
@@ -48,7 +48,7 @@ def download_video(index_season_selected: int, index_episode_selected: int, scra
 
     # Define filename and path for the downloaded video
     mp4_name = f"{map_episode_title(scrape_serie.series_name, index_season_selected, index_episode_selected, obj_episode.name)}.mp4"
-    mp4_path = os.path.join(ROOT_PATH, SERIES_FOLDER, scrape_serie.series_name, f"S{index_season_selected}")
+    mp4_path = os.path.join(SERIES_FOLDER, scrape_serie.series_name, f"S{index_season_selected}")
 
     # Retrieve scws and if available master playlist
     video_source.get_iframe(obj_episode.id)

StreamingCommunity/Api/Site/streamingcommunity/site.py

@@ -26,30 +26,36 @@ from StreamingCommunity.Api.Template.Class.SearchType import MediaManager
 
 
 # Config
-from .costant import SITE_NAME
+from .costant import SITE_NAME, DOMAIN_NOW
 
 
 # Variable
 media_search_manager = MediaManager()
 table_show_manager = TVShowManager()
 max_timeout = config_manager.get_int("REQUESTS", "timeout")
+disable_searchDomain = config_manager.get_bool("DEFAULT", "disable_searchDomain")
 
 
-def get_version(text: str):
+def get_version(domain: str):
     """
     Extracts the version from the HTML text of a webpage.
 
     Parameters:
-        - text (str): The HTML text of the webpage.
+        - domain (str): The domain of the site.
 
     Returns:
         str: The version extracted from the webpage.
-        list: Top 10 titles headlines for today.
     """
     try:
+        response = httpx.get(
+            url=f"https://{SITE_NAME}.{domain}/", 
+            headers={'User-Agent': get_headers()}, 
+            timeout=max_timeout
+        )
+        response.raise_for_status()
 
         # Parse request to site
-        soup = BeautifulSoup(text, "html.parser")
+        soup = BeautifulSoup(response.text, "html.parser")
 
         # Extract version
         version = json.loads(soup.find("div", {"id": "app"}).get("data-page"))['version']
@@ -72,22 +78,13 @@ def get_version_and_domain():
     """
 
     # Find new domain if prev dont work
-    domain_to_use, base_url = search_domain(SITE_NAME, f"https://{SITE_NAME}")
+    domain_to_use = DOMAIN_NOW
 
-    # Extract version from the response
-    try:
-        version = get_version(
-            httpx.get(
-                url=base_url, 
-                headers={'User-Agent': get_headers()}, 
-                timeout=max_timeout
-            ).text
-        )
-        
-    except:
-        console.print("[green]Auto generate version ...")
-        version = secrets.token_hex(32 // 2)
+    if not disable_searchDomain:
+        domain_to_use, base_url = search_domain(SITE_NAME, f"https://{SITE_NAME}")
 
+    version = get_version(domain_to_use)
+        
     return version, domain_to_use
 
 
@@ -116,16 +113,20 @@ def title_search(title_search: str, domain: str) -> int:
     except Exception as e:
         console.print(f"Site: {SITE_NAME}, request search error: {e}")
 
-    # Add found titles to media search manager
     for dict_title in response.json()['data']:
-        media_search_manager.add_media({
-            'id': dict_title.get('id'),
-            'slug': dict_title.get('slug'),
-            'name': dict_title.get('name'),
-            'type': dict_title.get('type'),
-            'date': dict_title.get('last_air_date'),
-            'score': dict_title.get('score')
-        })
+        try:
+
+            media_search_manager.add_media({
+                'id': dict_title.get('id'),
+                'slug': dict_title.get('slug'),
+                'name': dict_title.get('name'),
+                'type': dict_title.get('type'),
+                'date': dict_title.get('last_air_date'),
+                'score': dict_title.get('score')
+            })
+
+        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/streamingcommunity/util/ScrapeSerie.py

@@ -1,10 +1,12 @@
 # 01.03.24
 
+import json
 import logging
 
 
 # External libraries
 import httpx
+from bs4 import BeautifulSoup
 
 
 # Internal utilities
@@ -56,33 +58,33 @@ class ScrapeSerie:
         Raises:
             Exception: If there's an error fetching season information
         """
-        self.headers = {
-            'user-agent': get_headers(),
-            'x-inertia': 'true', 
-            'x-inertia-version': self.version,
-        }
-
         try:
-
             response = httpx.get(
-                url=f"https://{self.base_name}.{self.domain}/titles/{self.media_id}-{self.series_name}", 
-                headers=self.headers, 
+                url=f"https://{self.base_name}.{self.domain}/titles/{self.media_id}-{self.series_name}",
+                headers=self.headers,
                 timeout=max_timeout
             )
             response.raise_for_status()
 
             # Extract seasons from JSON response
-            json_response = response.json().get('props')
+            soup = BeautifulSoup(response.text, "html.parser")
+            json_response = json.loads(soup.find("div", {"id": "app"}).get("data-page"))
+                  
+            """
+            response = httpx.post(
+                url=f'https://{self.base_name}.{self.domain}/api/titles/preview/{self.media_id}', 
+                headers={'User-Agent': get_headers()}
+            )
+            response.raise_for_status()
+            
+
+            # Extract seasons from JSON response
+            json_response = response.json()
+            """
 
             # Collect info about season
-            self.season_manager = Season(json_response.get('title'))
-            self.season_manager.collect_images(self.base_name, self.domain)
+            self.season_manager = Season(json_response.get("props").get("title"))
 
-            # Collect first episode info
-            for i, ep in enumerate(json_response.get('loadedSeason').get('episodes')):
-                self.season_manager.episodes.add(ep)
-                self.season_manager.episodes.get(i).collect_image(self.base_name, self.domain)
-            
         except Exception as e:
             logging.error(f"Error collecting season info: {e}")
             raise
@@ -97,16 +99,14 @@ class ScrapeSerie:
         Raises:
             Exception: If there's an error fetching episode information
         """
-        self.headers = {
-            'user-agent': get_headers(),
-            'x-inertia': 'true', 
-            'x-inertia-version': self.version,
-        }
-
         try:
             response = httpx.get(
                 url=f'https://{self.base_name}.{self.domain}/titles/{self.media_id}-{self.series_name}/stagione-{number_season}', 
-                headers=self.headers, 
+                headers={
+                    'User-Agent': get_headers(),
+                    'x-inertia': 'true', 
+                    'x-inertia-version': self.version,
+                },
                 timeout=max_timeout
             )
             response.raise_for_status()

StreamingCommunity/Api/Template/Util/get_domain.py

@@ -1,6 +1,5 @@
 # 18.06.24
 
-import sys
 from urllib.parse import urlparse
 
 
@@ -15,160 +14,124 @@ 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.
-
-    Args:
-        query (str): The search query to execute on Google.
+def get_base_domain(url_str):
+    """Extract base domain without protocol, www and path"""
+    parsed = urlparse(url_str)
+    domain = parsed.netloc.lower()
+    if domain.startswith('www.'):
+        domain = domain[4:]
+    return domain.split('.')[0]
 
-    Returns:
-        str: The first URL result from the search, or None if no result is found.
+def validate_url(url, base_url, max_timeout):
     """
-    # 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 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.
+    Validate if URL is accessible and matches expected base domain
     """
+    console.print(f"\n[cyan]Starting validation for URL[white]: [yellow]{url}")
+    
+    def check_response(response, check_num):
+        if response.status_code == 403:
+            console.print(f"[red]Check {check_num} failed: Access forbidden (403)")
+            return False
+        if response.status_code >= 400:
+            console.print(f"[red]Check {check_num} failed: HTTP {response.status_code}")
+            return False
+        console.print(f"[green]Check {check_num} passed: HTTP {response.status_code}")
+        return True
 
-    # Create a client with redirects enabled
     try:
+        
+        # Check 1: Initial request without following redirects
+        console.print("[cyan]Performing initial connection check...")
         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,
+            headers={'User-Agent': get_headers()},
+            follow_redirects=False,
             timeout=max_timeout
-
         ) as client:
-            response = client.get(initial_url)
+            response = client.get(url)
+            if not check_response(response, 1):
+                return False
 
-            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()
+        # Check 2: Follow redirects and verify final domain
+        console.print("[cyan]Checking redirect destination...")
+        with httpx.Client(
+            headers={'User-Agent': get_headers()},
+            follow_redirects=True,
+            timeout=max_timeout
+        ) as client:
+            
+            response = client.get(url)
+            if not check_response(response, 2):
+                return False
+            
+            # Compare base domains
+            original_base = get_base_domain(url)
+            final_base = get_base_domain(str(response.url))
+            
+            console.print(f"[cyan]Comparing domains:")
+            console.print(f"Original base domain: [yellow]{original_base}")
+            console.print(f"Final base domain: [yellow]{final_base}")
+            
+            if original_base != final_base:
+                console.print(f"[red]Domain mismatch: Redirected to different base domain")
+                return False
+            
+            # Verify against expected base_url
+            expected_base = get_base_domain(base_url)
+            if final_base != expected_base:
+                console.print(f"[red]Domain mismatch: Final domain does not match expected base URL")
+                console.print(f"Expected: [yellow]{expected_base}")
+                return False
+                
+            console.print(f"[green]All checks passed: URL is valid and matches expected domain")
+            return True
             
-            # Capture the final URL after all redirects
-            final_url = response.url
-        
-        return final_url
-    
     except Exception as e:
-        console.print(f"\n[cyan]Test url[white]: [red]{initial_url}, [cyan]error[white]: [red]{e}")
-        return None
+        console.print(f"[red]Error during validation: {str(e)}")
+        return False
 
 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.
-
-    Returns:
-        tuple: The found domain and the complete URL.
+    Search for valid domain matching site name and base URL.
     """
-    
-    # Extract config domain
     max_timeout = config_manager.get_int("REQUESTS", "timeout")
     domain = str(config_manager.get_dict("SITE", site_name)['domain'])
+    test_url = f"{base_url}.{domain}"
 
+    console.print(f"\n[cyan]Testing initial URL[white]: [yellow]{test_url}")
+    
     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()
-
+        if validate_url(test_url, base_url, max_timeout):
+            parsed_url = urlparse(test_url)
+            tld = parsed_url.netloc.split('.')[-1]
+            config_manager.config['SITE'][site_name]['domain'] = tld
+            config_manager.write_config()
+            console.print(f"[green]Successfully validated initial URL")
+            return tld, test_url
+        
     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}")
+        console.print(f"[red]Error testing initial URL: {str(e)}")
 
-            # 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}"
+    # Google search phase
+    query = base_url.split("/")[-1]
+    console.print(f"\n[cyan]Performing Google search for[white]: [yellow]{query}")
+    search_results = list(search(query, num_results=15, lang="it"))
+    
+    for idx, result_url in enumerate(search_results, 1):
+        console.print(f"\n[cyan]Checking Google result {idx}/15[white]: [yellow]{result_url}")
+        
+        if validate_url(result_url, base_url, max_timeout):
+            parsed_result = urlparse(result_url)
+            new_domain = parsed_result.netloc.split(".")[-1]
+            
+            if get_first or msg.ask(
+                f"\n[cyan]Do you want to update site[white] [red]'{site_name}'[cyan] with domain[white] [red]'{new_domain}'",
+                choices=["y", "n"],
+                default="y"
+            ).lower() == "y":
+                
+                config_manager.config['SITE'][site_name]['domain'] = new_domain
+                config_manager.write_config()
+                return new_domain, f"{base_url}.{new_domain}"
+
+    console.print("[bold red]No valid URLs found matching the base URL.")
+    return domain, f"{base_url}.{domain}"

StreamingCommunity/Lib/Downloader/HLS/downloader.py

@@ -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):