StreamingCommunity 3.3.9__py3-none-any.whl → 3.4.2__py3-none-any.whl

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

@@ -3,19 +3,12 @@
 import logging
 
 
-# External libraries
-import httpx
-
-
 # Internal utilities
 from StreamingCommunity.Util.headers import get_headers
-from StreamingCommunity.Util.config_json import config_manager
+from StreamingCommunity.Util.http_client import create_client
 from StreamingCommunity.Api.Player.Helper.Vixcloud.util import SeasonManager
 
 
-# Variable
-max_timeout = config_manager.get_int("REQUESTS", "timeout")
-
 
 class GetSerieInfo:
     def __init__(self, path_id: str):
@@ -23,16 +16,17 @@ class GetSerieInfo:
         self.base_url = "https://www.raiplay.it"
         self.path_id = path_id
         self.series_name = None
-        self.prog_tipology = "film"
         self.prog_description = None
         self.prog_year = None
         self.seasons_manager = SeasonManager()
+        self.season_block_mapping = {}      # Map season number to block_id
+        self.all_seasons_data = []          # Store all seasons before filtering
 
     def collect_info_title(self) -> None:
-        """Get series info including seasons."""
+        """Get series info including seasons from all multimedia blocks."""
         try:
             program_url = f"{self.base_url}/{self.path_id}"
-            response = httpx.get(url=program_url, headers=get_headers(), timeout=max_timeout)
+            response = create_client(headers=get_headers()).get(program_url)
             
             # If 404, content is not yet available
             if response.status_code == 404:
@@ -43,76 +37,118 @@ class GetSerieInfo:
             json_data = response.json()
 
             # Get basic program info
-            self.prog_description = json_data.get('program_info', '').get('vanity', '')
-            self.prog_year = json_data.get('program_info', '').get('year', '')
-            self.series_name = json_data.get('program_info', '').get('title', '')
+            program_info = json_data.get('program_info', {})
+            self.prog_description = program_info.get('vanity', '') or program_info.get('description', '')
+            self.prog_year = program_info.get('year', '')
+            self.series_name = program_info.get('title', '') or program_info.get('name', '')
+            
+            # Collect all seasons from all multimedia blocks
+            self.all_seasons_data = []
+            blocks_found = {}
             
-            # Look for seasons in the 'blocks' property
             for block in json_data.get('blocks', []):
-
-                # Check if block is a season block or episodi block
-                if block.get('type') == 'RaiPlay Multimedia Block':
-                    if block.get('name', '').lower() == 'episodi':
-                        self.publishing_block_id = block.get('id')
-
-                        # Extract seasons from sets array
-                        for season_set in block.get('sets', []):
-                            self.prog_tipology = "tv"
-
-                            if 'stagione' in season_set.get('name', '').lower():
-                                self._add_season(season_set, block.get('id'))
-                                
-                    elif 'stagione' in block.get('name', '').lower():
-                        self.publishing_block_id = block.get('id')
-                        self.prog_tipology = "tv"
-
-                        # Extract season directly from block's sets
-                        for season_set in block.get('sets', []):
-                            self._add_season(season_set, block.get('id'))
+                block_type = block.get('type', '')
+                block_name = block.get('name', 'N/A')
+                block_id = block.get('id', '')
+                
+                # Only process multimedia blocks with sets
+                if block_type == 'RaiPlay Multimedia Block' and 'sets' in block:
+                    sets = block.get('sets', [])
+                    
+                    for season_set in sets:
+                        episode_size = season_set.get('episode_size', {})
+                        episode_count = episode_size.get('number', 0)
+                        
+                        # Only add sets with episodes
+                        if episode_count > 0:
+                            self.all_seasons_data.append({
+                                'season_set': season_set,
+                                'block_id': block_id,
+                                'block_name': block_name
+                            })
+                            
+                            # Track which blocks we found
+                            if block_name not in blocks_found:
+                                blocks_found[block_name] = 0
+                            blocks_found[block_name] += 1
+            
+            # Add all collected seasons without any filtering (oldest first)
+            for season_data in reversed(self.all_seasons_data):
+                self._add_season(
+                    season_data['season_set'],
+                    season_data['block_id'],
+                    season_data['block_name']
+                )
 
         except Exception as e:
             logging.error(f"Unexpected error collecting series info: {e}")
 
-    def _add_season(self, season_set: dict, block_id: str):
+    def _add_season(self, season_set: dict, block_id: str, block_name: str):
+        """Add a season combining set name and block name."""
+        set_name = season_set.get('name', '')
+        season_number = len(self.seasons_manager.seasons) + 1
+        
+        # Store block_id mapping
+        self.season_block_mapping[season_number] = {
+            'block_id': block_id,
+            'set_id': season_set.get('id', '')
+        }
+        
         self.seasons_manager.add_season({
             'id': season_set.get('id', ''),
-            'number': len(self.seasons_manager.seasons) + 1,
-            'name': season_set.get('name', ''),
-            'path': season_set.get('path_id', ''),
-            'episodes_count': season_set.get('episode_size', {}).get('number', 0)
+            'number': season_number,
+            'name': set_name,
+            #'episodes_count': season_set.get('episode_size', {}).get('number', 0),
+            'type': block_name
         })
 
     def collect_info_season(self, number_season: int) -> None:
-        """Get episodes for a specific season."""
+        """Get episodes for a specific season using episodes.json endpoint."""
         try:
             season = self.seasons_manager.get_season_by_number(number_season)
-
-            # Se stai leggendo questo codice spieami perche hai fatto cosi.
-            url = f"{self.base_url}/{self.path_id.replace(".json", "")}/{self.publishing_block_id}/{season.id}/episodes.json"
-            response = httpx.get(url=url, headers=get_headers(), timeout=max_timeout)
+            block_info = self.season_block_mapping[number_season]
+            block_id = block_info['block_id']
+            set_id = block_info['set_id']
+            
+            # Build episodes endpoint URL
+            base_path = self.path_id.replace('.json', '')
+            url = f"{self.base_url}/{base_path}/{block_id}/{set_id}/episodes.json"
+            
+            response = create_client(headers=get_headers()).get(url)
             response.raise_for_status()
             
             episodes_data = response.json()
-            cards = []
             
-            # Extract episodes from different possible structures 
-            if 'seasons' in episodes_data:
-                for season_data in episodes_data.get('seasons', []):
-                    for episode_set in season_data.get('episodes', []):
-                        cards.extend(episode_set.get('cards', []))
+            # Navigate nested structure to find cards
+            cards = []
+            seasons = episodes_data.get('seasons', [])
+            if seasons:
+                for season_data in seasons:
+                    episodes = season_data.get('episodes', [])
+                    for episode in episodes:
+                        cards.extend(episode.get('cards', []))
             
+            # Fallback to direct cards if nested structure not found
             if not cards:
                 cards = episodes_data.get('cards', [])
 
             # Add episodes to season
             for ep in cards:
+                video_url = ep.get('video_url', '')
+                mpd_id = ''
+                if video_url and '=' in video_url:
+                    mpd_id = video_url.split("=")[1].strip()
+                
+                weblink = ep.get('weblink', '') or ep.get('url', '')
+                episode_url = f"{self.base_url}{weblink}" if weblink else ''
+                
                 episode = {
                     'id': ep.get('id', ''),
                     'number': ep.get('episode', ''),
-                    'name': ep.get('episode_title', '') or ep.get('toptitle', ''),
-                    'duration': ep.get('duration', ''),
-                    'url': f"{self.base_url}{ep.get('weblink', '')}" if 'weblink' in ep else f"{self.base_url}{ep.get('url', '')}",
-                    'mpd_id': ep.get('video_url').split("=")[1].strip()
+                    'name': ep.get('episode_title', '') or ep.get('name', '') or ep.get('toptitle', ''),
+                    'duration': ep.get('duration', '') or ep.get('duration_in_minutes', ''),
+                    'url': episode_url,
+                    'mpd_id': mpd_id
                 }
                 season.episodes.add(episode)
 

StreamingCommunity/Api/Site/raiplay/util/get_license.py

@@ -1,20 +1,11 @@
 # 16.03.25
 
 
-# External library
-import httpx
-
-
 # Internal utilities
-from StreamingCommunity.Util.config_json import config_manager
+from StreamingCommunity.Util.http_client import create_client
 from StreamingCommunity.Util.headers import get_headers
 
 
-# Variable
-MAX_TIMEOUT = config_manager.get_int("REQUESTS", "timeout")
-
-
-
 def generate_license_url(mpd_id: str):
     """
     Generates the URL to obtain the Widevine license.
@@ -29,8 +20,8 @@ def generate_license_url(mpd_id: str):
         'cont': mpd_id,
         'output': '62',
     }
-
-    response = httpx.get('https://mediapolisvod.rai.it/relinker/relinkerServlet.htm', params=params, headers=get_headers(), timeout=MAX_TIMEOUT)
+    
+    response = create_client(headers=get_headers()).get('https://mediapolisvod.rai.it/relinker/relinkerServlet.htm', params=params)
     response.raise_for_status() 
 
     # Extract the license URL from the response in two lines

StreamingCommunity/Api/Site/streamingcommunity/film.py

@@ -9,8 +9,9 @@ from rich.console import Console
 
 # Internal utilities
 from StreamingCommunity.Util.os import os_manager
+from StreamingCommunity.Util.config_json import config_manager
 from StreamingCommunity.Util.message import start_message
-from StreamingCommunity.TelegramHelp.telegram_bot import TelegramSession, get_bot_instance
+from StreamingCommunity.TelegramHelp.telegram_bot import TelegramSession
 
 
 # Logic class
@@ -25,6 +26,7 @@ from StreamingCommunity.Api.Player.vixcloud import VideoSource
 
 # Variable
 console = Console()
+extension_output = config_manager.get("M3U8_CONVERSION", "extension")
 
 
 def download_film(select_title: MediaItem) -> str:
@@ -38,19 +40,6 @@ def download_film(select_title: MediaItem) -> str:
     Return:
         - str: output path
     """
-    if site_constant.TELEGRAM_BOT:
-        bot = get_bot_instance()
-        bot.send_message(f"Download in corso:\n{select_title.name}", None)
-
-        # Viene usato per lo screen
-        console.print(f"## Download: [red]{select_title.name} ##")
-
-        # Get script_id
-        script_id = TelegramSession.get_session()
-        if script_id != "unknown":
-            TelegramSession.updateScriptId(script_id, select_title.name)
-
-    # Start message and display film information
     start_message()
     console.print(f"\n[bold yellow]Download:[/bold yellow] [red]{site_constant.SITE_NAME}[/red] → [cyan]{select_title.name}[/cyan] \n")
 
@@ -67,8 +56,8 @@ def download_film(select_title: MediaItem) -> str:
         return None
 
     # Define the filename and path for the downloaded film
-    title_name = os_manager.get_sanitize_file(select_title.name) + ".mp4"
-    mp4_path = os.path.join(site_constant.MOVIE_FOLDER, title_name.replace(".mp4", ""))
+    title_name = os_manager.get_sanitize_file(select_title.name, select_title.date) + extension_output
+    mp4_path = os.path.join(site_constant.MOVIE_FOLDER, title_name.replace(extension_output, ""))
 
     # Download the film using the m3u8 playlist, and output filename
     hls_process = HLS_Downloader(

StreamingCommunity/Api/Site/streamingcommunity/series.py

@@ -21,7 +21,8 @@ from StreamingCommunity.Api.Template.Util import (
     map_episode_title, 
     validate_selection, 
     validate_episode_selection, 
-    display_episodes_list
+    display_episodes_list,
+    display_seasons_list
 )
 from StreamingCommunity.Api.Template.config_loader import site_constant
 from StreamingCommunity.Api.Template.Class.SearchType import MediaItem
@@ -166,9 +167,6 @@ def download_series(select_season: MediaItem, season_selection: str = None, epis
     if site_constant.TELEGRAM_BOT:
         bot = get_bot_instance()
 
-    # Prompt user for season selection and download episodes
-    console.print(f"\n[green]Seasons found: [red]{seasons_count}")
-
     # If season_selection is provided, use it instead of asking for input
     if season_selection is None:
         if site_constant.TELEGRAM_BOT:
@@ -188,10 +186,8 @@ def download_series(select_season: MediaItem, season_selection: str = None, epis
             )
 
         else:
-            index_season_selected = msg.ask(
-                "\n[cyan]Insert season number [yellow](e.g., 1), [red]* [cyan]to download all seasons, "
-                "[yellow](e.g., 1-2) [cyan]for a range of seasons, or [yellow](e.g., 3-*) [cyan]to download from a specific season to the end"
-            )
+            index_season_selected = display_seasons_list(scrape_serie.seasons_manager)
+
     else:
         index_season_selected = season_selection
         console.print(f"\n[cyan]Using provided season selection: [yellow]{season_selection}")
@@ -211,7 +207,6 @@ def download_series(select_season: MediaItem, season_selection: str = None, epis
 
         if len(list_season_select) > 1 or index_season_selected == "*":
             download_episode(season_number, scrape_serie, video_source, download_all=True)
-            
         else:
             download_episode(season_number, scrape_serie, video_source, download_all=False, episode_selection=episode_selection)
 
@@ -221,4 +216,4 @@ def download_series(select_season: MediaItem, season_selection: str = None, epis
         # Get script_id
         script_id = TelegramSession.get_session()
         if script_id != "unknown":
-            TelegramSession.deleteScriptId(script_id)
+            TelegramSession.deleteScriptId(script_id)

StreamingCommunity/Api/Site/streamingcommunity/site.py

@@ -4,14 +4,13 @@ import json
 
 
 # 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.http_client import create_client
 from StreamingCommunity.Util.table import TVShowManager
 from StreamingCommunity.TelegramHelp.telegram_bot import get_bot_instance
 
@@ -25,8 +24,6 @@ from StreamingCommunity.Api.Template.Class.SearchType import MediaManager
 console = Console()
 media_search_manager = MediaManager()
 table_show_manager = TVShowManager()
-max_timeout = config_manager.get_int("REQUESTS", "timeout")
-ssl_verify = config_manager.get_bool("REQUESTS", "verify")
 
 
 def title_search(query: str) -> int:
@@ -46,13 +43,7 @@ def title_search(query: str) -> int:
     table_show_manager.clear()
 
     try:
-        response = httpx.get(
-            f"{site_constant.FULL_URL}/it", 
-            headers={'user-agent': get_userAgent()}, 
-            timeout=max_timeout,
-            verify=ssl_verify,
-	    follow_redirects=True
-        )
+        response = create_client(headers={'user-agent': get_userAgent()}).get(f"{site_constant.FULL_URL}/it")
         response.raise_for_status()
 
         soup = BeautifulSoup(response.text, 'html.parser')
@@ -66,17 +57,7 @@ def title_search(query: str) -> int:
     console.print(f"[cyan]Search url: [yellow]{search_url}")
 
     try:
-        response = httpx.get(
-            search_url, 
-            headers = {
-                'referer': site_constant.FULL_URL,
-                'user-agent': get_userAgent(),
-                'x-inertia': 'true',
-                'x-inertia-version': version
-            },
-            timeout=max_timeout,
-            verify=ssl_verify
-        )
+        response = create_client(headers={'user-agent': get_userAgent(), 'x-inertia': 'true', 'x-inertia-version': version}).get(search_url)
         response.raise_for_status()
 
     except Exception as e:

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

@@ -5,21 +5,15 @@ 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.Util.headers import get_headers
+from StreamingCommunity.Util.http_client import create_client
 from StreamingCommunity.Api.Player.Helper.Vixcloud.util import SeasonManager
 
 
-# Variable
-max_timeout = config_manager.get_int("REQUESTS", "timeout")
-ssl_verify = config_manager.get_bool("REQUESTS", "verify")
-
-
 class GetSerieInfo:
     def __init__(self, url, media_id: int = None, series_name: str = None):
         """
@@ -31,7 +25,7 @@ class GetSerieInfo:
             - series_name (str, optional): Name of the TV series
         """
         self.is_series = False
-        self.headers = {'user-agent': get_userAgent()}
+        self.headers = get_headers()
         self.url = url
         self.media_id = media_id
         self.seasons_manager = SeasonManager()
@@ -48,12 +42,7 @@ class GetSerieInfo:
             Exception: If there's an error fetching series information
         """
         try:
-            response = httpx.get(
-                url=f"{self.url}/titles/{self.media_id}-{self.series_name}",
-                headers=self.headers,
-                timeout=max_timeout,
-                verify=ssl_verify
-            )
+            response = create_client(headers=self.headers).get(f"{self.url}/titles/{self.media_id}-{self.series_name}")
             response.raise_for_status()
 
             # Extract series info from JSON response
@@ -75,7 +64,6 @@ class GetSerieInfo:
                     'number': season_data.get('number', 0),
                     'name': f"Season {season_data.get('number', 0)}",
                     'slug': season_data.get('slug', ''),
-                    'type': title_data.get('type', '')
                 })
 
         except Exception as e:
@@ -98,17 +86,13 @@ class GetSerieInfo:
             if not season:
                 logging.error(f"Season {number_season} not found")
                 return
-            
-            response = httpx.get(
-                url=f'{self.url}/titles/{self.media_id}-{self.series_name}/season-{number_season}', 
-                headers={
-                    'User-Agent': self.headers['user-agent'],
-                    'x-inertia': 'true',
-                    'x-inertia-version': self.version,
-                },
-                timeout=max_timeout,
-                verify=ssl_verify
-            )
+
+            custom_headers = self.headers.copy()
+            custom_headers.update({
+                'x-inertia': 'true',
+                'x-inertia-version': self.version,
+            })
+            response = create_client(headers=custom_headers).get(f"{self.url}/titles/{self.media_id}-{self.series_name}/season-{number_season}")
 
             # Extract episodes from JSON response
             json_response = response.json().get('props', {}).get('loadedSeason', {}).get('episodes', [])

StreamingCommunity/Api/Site/streamingwatch/__init__.py

@@ -3,6 +3,7 @@
 import sys
 import subprocess
 
+
 # External library
 from rich.console import Console
 from rich.prompt import Prompt

StreamingCommunity/Api/Site/streamingwatch/film.py

@@ -9,6 +9,7 @@ from rich.console import Console
 
 # Internal utilities
 from StreamingCommunity.Util.os import os_manager
+from StreamingCommunity.Util.config_json import config_manager
 from StreamingCommunity.Util.message import start_message
 
 
@@ -24,6 +25,7 @@ from StreamingCommunity.Api.Player.hdplayer import VideoSource
 
 # Variable
 console = Console()
+extension_output = config_manager.get("M3U8_CONVERSION", "extension")
 
 
 def download_film(select_title: MediaItem) -> str:
@@ -45,8 +47,8 @@ def download_film(select_title: MediaItem) -> str:
     master_playlist = video_source.get_m3u8_url(select_title.url)
 
     # Define the filename and path for the downloaded film
-    title_name = os_manager.get_sanitize_file(select_title.name) + ".mp4"
-    mp4_path = os.path.join(site_constant.MOVIE_FOLDER, title_name.replace(".mp4", ""))
+    title_name = os_manager.get_sanitize_file(select_title.name, select_title.date) + extension_output
+    mp4_path = os.path.join(site_constant.MOVIE_FOLDER, title_name.replace(extension_output, ""))
 
     # Download the film using the m3u8 playlist, and output filename
     hls_process = HLS_Downloader(

StreamingCommunity/Api/Site/streamingwatch/series.py

@@ -21,7 +21,8 @@ from StreamingCommunity.Api.Template.Util import (
     map_episode_title,
     validate_selection, 
     validate_episode_selection, 
-    display_episodes_list
+    display_episodes_list,
+    display_seasons_list
 )
 from StreamingCommunity.Api.Template.config_loader import site_constant
 from StreamingCommunity.Api.Template.Class.SearchType import MediaItem
@@ -53,7 +54,7 @@ def download_video(index_season_selected: int, index_episode_selected: int, scra
 
     # Get episode information
     obj_episode = scrape_serie.selectEpisode(index_season_selected, index_episode_selected-1)
-    console.print(f"\n[/bold yellow] [red]{site_constant.SITE_NAME}[/red] → [cyan]{scrape_serie.series_name}[/cyan] \\ [bold magenta]{obj_episode.name}[/bold magenta] ([cyan]S{index_season_selected}E{index_episode_selected}[/cyan]) \n")
+    console.print(f"\n[bold yellow]Download:[/bold yellow] [red]{site_constant.SITE_NAME}[/red] → [cyan]{scrape_serie.series_name}[/cyan] \\ [bold magenta]{obj_episode.name}[/bold magenta] ([cyan]S{index_season_selected}E{index_episode_selected}[/cyan]) \n")
 
     # 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"
@@ -134,20 +135,11 @@ def download_series(select_season: MediaItem, season_selection: str = None, epis
         - episode_selection (str, optional): Pre-defined episode selection that bypasses manual input
     """
     scrape_serie = GetSerieInfo(select_season.url)
-
-    # Get total number of seasons 
     seasons_count = scrape_serie.getNumberSeason()
     
-    # Prompt user for season selection and download episodes
-    console.print(f"\n[green]Seasons found: [red]{seasons_count}")
-
     # If season_selection is provided, use it instead of asking for input
     if season_selection is None:
-        index_season_selected = msg.ask(
-            "\n[cyan]Insert season number [yellow](e.g., 1), [red]* [cyan]to download all seasons, "
-            "[yellow](e.g., 1-2) [cyan]for a range of seasons, or [yellow](e.g., 3-*) [cyan]to download from a specific season to the end"
-        )
-
+        index_season_selected = display_seasons_list(scrape_serie.seasons_manager)
     else:
         index_season_selected = season_selection
         console.print(f"\n[cyan]Using provided season selection: [yellow]{season_selection}")
@@ -159,8 +151,6 @@ def download_series(select_season: MediaItem, season_selection: str = None, epis
     # Loop through the selected seasons and download episodes
     for i_season in list_season_select:
         if len(list_season_select) > 1 or index_season_selected == "*":
-            # Download all episodes if multiple seasons are selected or if '*' is used
             download_episode(i_season, scrape_serie, download_all=True)
         else:
-            # Otherwise, let the user select specific episodes for the single season
             download_episode(i_season, scrape_serie, download_all=False, episode_selection=episode_selection)

StreamingCommunity/Api/Site/streamingwatch/site.py

@@ -4,13 +4,12 @@ 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.http_client import create_client
 from StreamingCommunity.Util.headers import get_userAgent
 from StreamingCommunity.Util.table import TVShowManager
 
@@ -24,18 +23,13 @@ from StreamingCommunity.Api.Template.Class.SearchType import MediaManager
 console = Console()
 media_search_manager = MediaManager()
 table_show_manager = TVShowManager()
-max_timeout = config_manager.get_int("REQUESTS", "timeout")
 
 
 def extract_nonce() -> str:
     """Extract nonce value from the page script"""
-    response = httpx.get(
-        site_constant.FULL_URL, 
-        headers={'user-agent': get_userAgent()}, 
-        timeout=max_timeout
-    )
-    
+    response = create_client(headers={'user-agent': get_userAgent()}).get(site_constant.FULL_URL)
     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)
@@ -73,15 +67,7 @@ def title_search(query: str) -> int:
             '_wpnonce': _wpnonce
         }
 
-        response = httpx.post(
-            search_url,
-            headers={
-                'origin': site_constant.FULL_URL,
-                'user-agent': get_userAgent()
-            },
-            data=data,
-            timeout=max_timeout
-        )
+        response = create_client(headers={'origin': site_constant.FULL_URL, 'user-agent': get_userAgent()}).post(search_url, data=data)
         response.raise_for_status()
         soup = BeautifulSoup(response.text, 'html.parser')
 

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

@@ -11,12 +11,9 @@ from bs4 import BeautifulSoup
 # Internal utilities
 from StreamingCommunity.Util.headers import get_userAgent
 from StreamingCommunity.Util.http_client import create_client
-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:

StreamingCommunity/Api/Template/Util/__init__.py

@@ -6,7 +6,8 @@ from .manage_ep import (
     validate_episode_selection, 
     validate_selection, 
     dynamic_format_number,
-    display_episodes_list
+    display_episodes_list,
+    display_seasons_list
 )
 
 __all__ = [
@@ -15,5 +16,6 @@ __all__ = [
     "validate_episode_selection",
     "validate_selection",
     "dynamic_format_number",
-    "display_episodes_list"
+    "display_episodes_list",
+    display_seasons_list
 ]