StreamingCommunity 3.3.1__py3-none-any.whl → 3.3.2__py3-none-any.whl

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

@@ -9,7 +9,12 @@ import xml.etree.ElementTree as ET
 # External library
 import httpx
 from rich.console import Console
-from seleniumbase import Driver
+try:
+    from seleniumbase import Driver
+    SELENIUMBASE_AVAILABLE = True
+except ImportError:
+    SELENIUMBASE_AVAILABLE = False
+    Driver = None
 
 
 # Internal utilities
@@ -40,6 +45,17 @@ def save_network_data(data):
 
 
 def generate_betoken(username: str, password: str, sleep_action: float = 1.0) -> str:
+    """Generate beToken using browser automation"""
+    
+    if not SELENIUMBASE_AVAILABLE:
+        console.print("[red]Error: seleniumbase is not installed. Cannot perform browser login.")
+        console.print("[yellow]Install seleniumbase with: pip install seleniumbase")
+        return None
+    
+    if not Driver:
+        console.print("[red]Error: seleniumbase Driver is not available.")
+        return None
+    
     driver = Driver(uc=True, uc_cdp_events=True, incognito=True, headless=True)
     
     try:
@@ -155,6 +171,7 @@ def generate_betoken(username: str, password: str, sleep_action: float = 1.0) ->
     finally:
         driver.quit()
 
+
 def get_bearer_token():
     """
     Gets the BEARER_TOKEN for authentication.
@@ -173,6 +190,11 @@ def get_bearer_token():
     password = config_manager.get_dict("SITE_LOGIN", "mediasetinfinity").get("password", "")
     
     if username and password:
+        if not SELENIUMBASE_AVAILABLE:
+            console.print("[yellow]Warning: seleniumbase not available. Cannot perform automatic login.")
+            console.print("[yellow]Please manually obtain beToken and set it in config.")
+            return config_manager.get_dict("SITE_LOGIN", "mediasetinfinity")["beToken"]
+        
         beToken = generate_betoken(username, password)
         
         if beToken is not None:
@@ -187,6 +209,7 @@ def get_bearer_token():
             
     return config_manager.get_dict("SITE_LOGIN", "mediasetinfinity")["beToken"]
 
+
 def get_playback_url(BEARER_TOKEN, CONTENT_ID):
     """
     Gets the playback URL for the specified content.
@@ -231,6 +254,7 @@ def get_playback_url(BEARER_TOKEN, CONTENT_ID):
     except Exception as e:
         raise RuntimeError(f"Failed to get playback URL: {e}")
 
+
 def parse_tracking_data(tracking_value):
     """
     Parses the trackingData string into a dictionary.
@@ -243,6 +267,7 @@ def parse_tracking_data(tracking_value):
     """
     return dict(item.split('=', 1) for item in tracking_value.split('|') if '=' in item)
 
+
 def parse_smil_for_tracking_and_video(smil_xml):
     """
     Extracts all video_src and trackingData pairs from the SMIL.
@@ -283,6 +308,7 @@ def parse_smil_for_tracking_and_video(smil_xml):
 
     return results
 
+
 def get_tracking_info(BEARER_TOKEN, PLAYBACK_JSON):
     """
     Retrieves tracking information from the playback JSON.
@@ -326,6 +352,7 @@ def get_tracking_info(BEARER_TOKEN, PLAYBACK_JSON):
     except Exception:
         return None
 
+
 def generate_license_url(BEARER_TOKEN, tracking_info):
     """
     Generates the URL to obtain the Widevine license.

StreamingCommunity/Api/Site/raiplay/site.py

@@ -42,7 +42,7 @@ def determine_media_type(item):
 
         scraper = GetSerieInfo(program_name)
         scraper.collect_info_title()
-        return "tv" if scraper.getNumberSeason() > 0 else "film"
+        return scraper.prog_tipology, scraper.prog_description, scraper.prog_year
     
     except Exception as e:
         console.print(f"[red]Error determining media type: {e}[/red]")
@@ -91,18 +91,20 @@ def title_search(query: str) -> int:
         return 0
 
     # Limit to only 15 results for performance
-    data = response.json().get('agg').get('titoli').get('cards')
-    data = data[:15] if len(data) > 15 else data
+    data = response.json().get('agg').get('titoli').get('cards')[:15]
     
     # Process each item and add to media manager
     for item in data:
+        media_type, prog_description, prog_year = determine_media_type(item)
         media_search_manager.add_media({
             'id': item.get('id', ''),
             'name': item.get('titolo', ''),
-            'type': determine_media_type(item),
+            'type': media_type,
             'path_id': item.get('path_id', ''),
             'url': f"https://www.raiplay.it{item.get('url', '')}",
             'image': f"https://www.raiplay.it{item.get('immagine', '')}",
+            'desc': prog_description,
+            'year': prog_year
         })
           
     return media_search_manager.get_length()

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

@@ -23,6 +23,9 @@ class GetSerieInfo:
         self.base_url = "https://www.raiplay.it"
         self.program_name = program_name
         self.series_name = program_name
+        self.prog_tipology = None
+        self.prog_description = None
+        self.prog_year = None
         self.seasons_manager = SeasonManager()
 
     def collect_info_title(self) -> None:
@@ -38,6 +41,9 @@ class GetSerieInfo:
                 
             response.raise_for_status()
             json_data = response.json()
+            self.prog_tipology = "tv" if "tv" in json_data.get('track_info').get('typology') else "film"
+            self.prog_description = json_data.get('program_info', '').get('vanity', '')
+            self.prog_year = json_data.get('program_info', '').get('year', '')
             
             # Look for seasons in the 'blocks' property
             for block in json_data.get('blocks', []):
@@ -59,8 +65,6 @@ class GetSerieInfo:
                         for season_set in block.get('sets', []):
                             self._add_season(season_set, block.get('id'))
 
-        except httpx.HTTPError as e:
-            logging.error(f"Error collecting series info: {e}")
         except Exception as e:
             logging.error(f"Unexpected error collecting series info: {e}")
 

StreamingCommunity/Api/Site/streamingcommunity/site.py

@@ -59,9 +59,6 @@ def title_search(query: str) -> int:
         version = json.loads(soup.find('div', {'id': "app"}).get("data-page"))['version']
 
     except Exception as e:
-        if "WinError" in str(e) or "Errno" in str(e): 
-            console.print("\n[bold yellow]Please make sure you have enabled and configured a valid proxy.[/bold yellow]")
-            
         console.print(f"[red]Site: {site_constant.SITE_NAME} version, request error: {e}")
         return 0
 

StreamingCommunity/Api/Site/streamingwatch/site.py

@@ -86,9 +86,6 @@ def title_search(query: str) -> int:
         soup = BeautifulSoup(response.text, 'html.parser')
 
     except Exception as e:
-        if "WinError" in str(e) or "Errno" in str(e): 
-            console.print("\n[bold yellow]Please make sure you have enabled and configured a valid proxy.[/bold yellow]")
-            
         console.print(f"[red]Site: {site_constant.SITE_NAME}, request search error: {e}")
         return 0
 

StreamingCommunity/Lib/Downloader/DASH/cdm_helpher.py

@@ -29,29 +29,11 @@ def get_widevine_keys(pssh, license_url, cdm_device_path, headers=None, payload=
     Returns:
         list: List of dicts {'kid': ..., 'key': ...} (only CONTENT keys) or None if error.
     """
-
-    # Check if PSSH is a valid base64 string
-    try:
-        base64.b64decode(pssh)
-    except Exception:
-        console.print("[bold red] Invalid PSSH base64 string.[/bold red]")
-        return None
-
     try:
         device = Device.load(cdm_device_path)
         cdm = Cdm.from_device(device)
         session_id = cdm.open()
 
-        # Display security level in a more readable format
-        security_levels = {1: "L1 (Hardware)", 2: "L2 (Software)", 3: "L3 (Software)"}
-        security_level_str = security_levels.get(device.security_level, 'Unknown')
-        logging.info(f"Security Level: {security_level_str}")
-
-        # Only allow L3, otherwise warn and exit
-        if device.security_level != 3:
-            console.print(f"[bold yellow]⚠️ Only L3 (Software) security level is supported. Current: {security_level_str}[/bold yellow]")
-            return None
-
         try:
             challenge = cdm.get_license_challenge(session_id, PSSH(pssh))
             req_headers = headers or {}
@@ -108,6 +90,7 @@ def get_widevine_keys(pssh, license_url, cdm_device_path, headers=None, payload=
             content_keys = []
             for key in cdm.get_keys(session_id):
                 if key.type == "CONTENT":
+                    
                     kid = key.kid.hex() if isinstance(key.kid, bytes) else str(key.kid)
                     key_val = key.key.hex() if isinstance(key.key, bytes) else str(key.key)
 

StreamingCommunity/Lib/Downloader/DASH/downloader.py

@@ -12,7 +12,7 @@ from rich.panel import Panel
 # Internal utilities
 from StreamingCommunity.Util.config_json import config_manager
 from StreamingCommunity.Util.os import internet_manager
-from ...FFmpeg import print_duration_table
+from ...FFmpeg import print_duration_table, join_audios, join_video
 
 
 # Logic class
@@ -174,25 +174,26 @@ class DASH_Downloader:
 
     def finalize_output(self):
 
-        # Use the original output path for the final file
+        # Definenition of decrypted files
+        video_file = os.path.join(self.decrypted_dir, "video.mp4")
+        audio_file = os.path.join(self.decrypted_dir, "audio.mp4")
         output_file = self.original_output_path
         
         # Set the output file path for status tracking
         self.output_file = output_file
         use_shortest = False
 
-        """if os.path.exists(video_file) and os.path.exists(audio_file):
+        if os.path.exists(video_file) and os.path.exists(audio_file):
             audio_tracks = [{"path": audio_file}]
-            out_audio_path, use_shortest = join_audios(video_file, audio_tracks, output_file)
+            _, use_shortest = join_audios(video_file, audio_tracks, output_file)
 
         elif os.path.exists(video_file):
-            out_video_path = join_video(video_file, output_file, codec=None)
-        
+            _ = join_video(video_file, output_file, codec=None)
+
         else:
-            print("Video file missing, cannot export")
+            console.print("[red]Video file missing, cannot export[/red]")
             return None
-        """
-
+        
         # Handle failed sync case
         if use_shortest:
             new_filename = output_file.replace(".mp4", "_failed_sync.mp4")
@@ -204,18 +205,22 @@ class DASH_Downloader:
         if os.path.exists(output_file):
             file_size = internet_manager.format_file_size(os.path.getsize(output_file))
             duration = print_duration_table(output_file, description=False, return_string=True)
+
             panel_content = (
                 f"[cyan]File size: [bold red]{file_size}[/bold red]\n"
                 f"[cyan]Duration: [bold]{duration}[/bold]\n"
                 f"[cyan]Output: [bold]{os.path.abspath(output_file)}[/bold]"
             )
-            
+
             console.print(Panel(
                 panel_content,
                 title=f"{os.path.basename(output_file.replace('.mp4', ''))}",
                 border_style="green"
             ))
 
+        else:
+            console.print(f"[red]Output file not found: {output_file}")
+
         # Clean up: delete only the tmp directory, not the main directory
         if os.path.exists(self.tmp_dir):
             shutil.rmtree(self.tmp_dir, ignore_errors=True)
@@ -226,13 +231,12 @@ class DASH_Downloader:
         
         # Check if out_path is different from the actual output directory
         # and if it's empty, then it's safe to remove
-        if (self.out_path != output_dir and 
-            os.path.exists(self.out_path) and 
-            not os.listdir(self.out_path)):
+        if (self.out_path != output_dir and os.path.exists(self.out_path) and not os.listdir(self.out_path)):
             try:
                 os.rmdir(self.out_path)
+
             except Exception as e:
-                print(f"[WARN] Cannot remove directory {self.out_path}: {e}")
+                console.print(f"[red]Cannot remove directory {self.out_path}: {e}")
 
         # Verify the final file exists before returning
         if os.path.exists(output_file):

StreamingCommunity/Lib/Downloader/HLS/downloader.py

@@ -39,6 +39,7 @@ DOWNLOAD_SPECIFIC_AUDIO = config_manager.get_list('M3U8_DOWNLOAD', 'specific_lis
 DOWNLOAD_SPECIFIC_SUBTITLE = config_manager.get_list('M3U8_DOWNLOAD', 'specific_list_subtitles')
 MERGE_SUBTITLE = config_manager.get_bool('M3U8_DOWNLOAD', 'merge_subs')
 CLEANUP_TMP = config_manager.get_bool('M3U8_DOWNLOAD', 'cleanup_tmp_folder')
+GET_ONLY_LINK = config_manager.get_int('M3U8_DOWNLOAD', 'get_only_link')
 FILTER_CUSTOM_RESOLUTION = str(config_manager.get('M3U8_CONVERSION', 'force_resolution')).strip().lower()
 RETRY_LIMIT = config_manager.get_int('REQUESTS', 'max_retry')
 MAX_TIMEOUT = config_manager.get_int("REQUESTS", "timeout")
@@ -63,7 +64,6 @@ class HLSClient:
         Returns:
             Response content/text or None if all retries fail
         """
-        # Use unified HTTP client (inherits timeout/verify/proxy from config)
         client = create_client(headers=self.headers)
 
         for attempt in range(RETRY_LIMIT):
@@ -211,10 +211,10 @@ class M3U8Manager:
         # Get available subtitles and their languages
         available_subtitles = self.parser._subtitle.get_all_uris_and_names() or []
         available_sub_languages = [sub.get('language') for sub in available_subtitles]
-        
+
         # If "*" is in DOWNLOAD_SPECIFIC_SUBTITLE, all languages are downloadable
         downloadable_sub_languages = available_sub_languages if "*" in DOWNLOAD_SPECIFIC_SUBTITLE else list(set(available_sub_languages) & set(DOWNLOAD_SPECIFIC_SUBTITLE))
-            
+
         if available_sub_languages:
             console.print(
                 f"[cyan bold]Subtitle [/cyan bold] [green]Available:[/green] [purple]{', '.join(available_sub_languages)}[/purple] | "
@@ -260,7 +260,7 @@ class DownloadManager:
 
         if result.get('stopped', False):
             self.stopped = True
-        
+
         return self.stopped
 
     def download_audio(self, audio: Dict):
@@ -304,7 +304,7 @@ class DownloadManager:
         """
         return_stopped = False
         video_file = os.path.join(self.temp_dir, 'video', '0.ts')
-        
+
         if not os.path.exists(video_file):
             if self.download_video(video_url):
                 if not return_stopped:
@@ -421,8 +421,20 @@ class HLS_Downloader:
                 - is_master: Whether the M3U8 was a master playlist
             Or raises an exception if there's an error
         """
+
+        if GET_ONLY_LINK:
+            console.print(f"URL: [bold red]{self.m3u8_url}[/bold red]")
+            return {
+                'path': None,
+                'url': self.m3u8_url,
+                'is_master': getattr(self.m3u8_manager, 'is_master', None),
+                'msg': None,
+                'error': None,
+                'stopped': True
+            }
+
         console.print("[cyan]You can safely stop the download with [bold]Ctrl+c[bold] [cyan] \n")
-        
+
         if TELEGRAM_BOT:
             bot = get_bot_instance()
 
@@ -440,7 +452,7 @@ class HLS_Downloader:
                 if TELEGRAM_BOT:
                     bot.send_message("Contenuto già scaricato!", None)
                 return response
-        
+
             self.path_manager.setup_directories()
 
             # Parse M3U8 and determine if it's a master playlist
@@ -524,7 +536,7 @@ class HLS_Downloader:
 
         if missing_ts:
             panel_content += f"\n{missing_info}"
-            
+
         new_filename = self.path_manager.output_path
         if missing_ts and use_shortest:
             new_filename = new_filename.replace(".mp4", "_failed_sync_ts.mp4")
@@ -532,7 +544,7 @@ class HLS_Downloader:
             new_filename = new_filename.replace(".mp4", "_failed_ts.mp4")
         elif use_shortest:
             new_filename = new_filename.replace(".mp4", "_failed_sync.mp4")
-            
+
         if missing_ts or use_shortest:
             os.rename(self.path_manager.output_path, new_filename)
             self.path_manager.output_path = new_filename
@@ -541,4 +553,4 @@ class HLS_Downloader:
             panel_content,
             title=f"{os.path.basename(self.path_manager.output_path.replace('.mp4', ''))}",
             border_style="green"
-        ))
+        ))

StreamingCommunity/Lib/M3U8/decryptor.py

@@ -78,18 +78,4 @@ class M3U8_Decryption:
         else:
             raise ValueError("Invalid or unsupported method")
 
-        """
-        end = time.perf_counter_ns()
-
-        # Calculate the elapsed time with high precision
-        elapsed_nanoseconds = end - start
-        elapsed_milliseconds = elapsed_nanoseconds / 1_000_000
-        elapsed_seconds = elapsed_nanoseconds / 1_000_000_000
-
-        # Log performance metrics
-        logging.info("[Crypto Decryption Performance]")
-        logging.info(f"Method: {self.method}")
-        logging.info(f"Decryption Time: {elapsed_milliseconds:.4f} ms ({elapsed_seconds:.6f} s)")
-        logging.info(f"Decrypted Content Length: {len(decrypted_content)} bytes")
-        """
         return decrypted_content

StreamingCommunity/Lib/TMBD/tmdb.py

@@ -1,7 +1,6 @@
 # 24.08.24
 
 import sys
-from typing import Dict
 
 
 # External libraries
@@ -95,7 +94,6 @@ class TheMovieDB:
         """
         self.api_key = api_key
         self.base_url = "https://api.themoviedb.org/3"
-        #self.genres = self._fetch_genres()
         self._cached_trending_tv = None
         self._cached_trending_movies = None
 
@@ -120,16 +118,6 @@ class TheMovieDB:
         
         return response.json()
 
-    def _fetch_genres(self) -> Dict[int, str]:
-        """
-        Fetch and return the genre names from TheMovieDB.
-
-        Returns:
-            Dict[int, str]: A dictionary mapping genre IDs to genre names.
-        """
-        genres = self._make_request("genre/movie/list")
-        return {genre['id']: genre['name'] for genre in genres.get('genres', [])}
-
     def _display_top_5(self, category: str, data, name_key='title'):
         """
         Display top 5 most popular items in a single line with colors.

StreamingCommunity/Upload/version.py

@@ -1,5 +1,5 @@
 __title__ = 'StreamingCommunity'
-__version__ = '3.3.1'
+__version__ = '3.3.2'
 __author__ = 'Arrowar'
 __description__ = 'A command-line program to download film'
 __copyright__ = 'Copyright 2025'

StreamingCommunity/Util/{bento4_installer.py → installer/bento4_install.py}

@@ -1,10 +1,9 @@
 # 18.07.25
 
 import os
-import platform
-import logging
 import shutil
 import zipfile
+import logging
 
 
 # External library
@@ -13,12 +12,15 @@ from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, BarColumn, TextColumn, TimeRemainingColumn
 
 
+# Internal utilities
+from .binary_paths import binary_paths
+
+
 # Variable
 console = Console()
 
 BENTO4_CONFIGURATION = {
     'windows': {
-        'base_dir': lambda home: os.path.join(os.path.splitdrive(home)[0] + os.sep, 'binary'),
         'download_url': 'https://www.bok.net/Bento4/binaries/Bento4-SDK-{version}.{platform}.zip',
         'versions': {
             'x64': 'x86_64-microsoft-win32',
@@ -27,7 +29,6 @@ BENTO4_CONFIGURATION = {
         'executables': ['mp4decrypt.exe']
     },
     'darwin': {
-        'base_dir': lambda home: os.path.join(home, 'Applications', 'binary'),
         'download_url': 'https://www.bok.net/Bento4/binaries/Bento4-SDK-{version}.{platform}.zip',
         'versions': {
             'x64': 'universal-apple-macosx',
@@ -36,7 +37,6 @@ BENTO4_CONFIGURATION = {
         'executables': ['mp4decrypt']
     },
     'linux': {
-        'base_dir': lambda home: os.path.join(home, '.local', 'bin', 'binary'),
         'download_url': 'https://www.bok.net/Bento4/binaries/Bento4-SDK-{version}.{platform}.zip',
         'versions': {
             'x64': 'x86_64-unknown-linux',
@@ -50,26 +50,11 @@ BENTO4_CONFIGURATION = {
 
 class Bento4Downloader:
     def __init__(self):
-        self.os_name = platform.system().lower()
-        self.arch = self._detect_arch()
-        self.home_dir = os.path.expanduser('~')
-        self.base_dir = BENTO4_CONFIGURATION[self.os_name]['base_dir'](self.home_dir)
+        self.os_name = binary_paths.system
+        self.arch = binary_paths.arch
+        self.home_dir = binary_paths.home_dir
+        self.base_dir = binary_paths.ensure_binary_directory()
         self.version = "1-6-0-641"  # Latest stable version as of Nov 2023
-        os.makedirs(self.base_dir, exist_ok=True)
-
-    def _detect_arch(self) -> str:
-        machine = platform.machine().lower()
-        arch_map = {
-            'amd64': 'x64', 
-            'x86_64': 'x64',
-            'x64': 'x64',
-            'arm64': 'arm64',
-            'aarch64': 'arm64',
-            'x86': 'x86',
-            'i386': 'x86',
-            'i686': 'x86'
-        }
-        return arch_map.get(machine, machine)
 
     def _download_file(self, url: str, destination: str) -> bool:
         try:
@@ -160,32 +145,29 @@ class Bento4Downloader:
             console.print(f"[bold red]Error downloading Bento4: {str(e)}[/]")
             return []
 
+
 def check_mp4decrypt() -> str:
     """Check for mp4decrypt in the system and download if not found."""
     try:
         # First check if mp4decrypt is in PATH
-        mp4decrypt = "mp4decrypt.exe" if platform.system().lower() == "windows" else "mp4decrypt"
+        mp4decrypt = "mp4decrypt.exe" if binary_paths.system == "windows" else "mp4decrypt"
         mp4decrypt_path = shutil.which(mp4decrypt)
         
         if mp4decrypt_path:
             return mp4decrypt_path
 
         # If not found, check in binary directory
-        downloader = Bento4Downloader()
-        base_dir = downloader.base_dir
-        local_path = os.path.join(base_dir, mp4decrypt)
+        binary_dir = binary_paths.get_binary_directory()
+        local_path = os.path.join(binary_dir, mp4decrypt)
         
         if os.path.exists(local_path):
             return local_path
 
         # Download if not found
+        downloader = Bento4Downloader()
         extracted_files = downloader.download()
         return extracted_files[0] if extracted_files else None
 
     except Exception as e:
         logging.error(f"Error checking or downloading mp4decrypt: {e}")
-        return None
-    
-    except Exception as e:
-        logging.error(f"Error checking or downloading mp4decrypt: {e}")
-        return None
+        return None

StreamingCommunity/Util/installer/binary_paths.py

@@ -0,0 +1,83 @@
+# 19.09.25
+
+import os
+import platform
+
+
+class BinaryPaths:
+    def __init__(self):
+        self.system = self._detect_system()
+        self.arch = self._detect_arch()
+        self.home_dir = os.path.expanduser('~')
+    
+    def _detect_system(self) -> str:
+        """
+        Detect and normalize the operating system name.
+        
+        Returns:
+            str: Normalized operating system name ('windows', 'darwin', or 'linux')
+        
+        Raises:
+            ValueError: If the operating system is not supported
+        """
+        system = platform.system().lower()
+        supported_systems = ['windows', 'darwin', 'linux']
+        
+        if system not in supported_systems:
+            raise ValueError(f"Unsupported operating system: {system}. Supported: {supported_systems}")
+        
+        return system
+    
+    def _detect_arch(self) -> str:
+        """
+        Detect and normalize the system architecture.
+        
+        Returns:
+            str: Normalized architecture name
+        """
+        machine = platform.machine().lower()
+        arch_map = {
+            'amd64': 'x64', 
+            'x86_64': 'x64',
+            'x64': 'x64',
+            'arm64': 'arm64',
+            'aarch64': 'arm64',
+            'armv7l': 'arm',
+            'i386': 'ia32',
+            'i686': 'ia32',
+            'x86': 'x86'
+        }
+        return arch_map.get(machine, machine)
+    
+    def get_binary_directory(self) -> str:
+        """
+        Get the binary directory path based on the operating system.
+        
+        Returns:
+            str: Path to the binary directory
+        """
+        if self.system == 'windows':
+            return os.path.join(os.path.splitdrive(self.home_dir)[0] + os.path.sep, 'binary')
+        
+        elif self.system == 'darwin':
+            return os.path.join(self.home_dir, 'Applications', 'binary')
+        
+        else:  # linux
+            return os.path.join(self.home_dir, '.local', 'bin', 'binary')
+    
+    def ensure_binary_directory(self, mode: int = 0o755) -> str:
+        """
+        Create the binary directory if it doesn't exist and return its path.
+        
+        Args:
+            mode (int, optional): Directory permissions. Defaults to 0o755.
+        
+        Returns:
+            str: Path to the binary directory
+        """
+        binary_dir = self.get_binary_directory()
+        os.makedirs(binary_dir, mode=mode, exist_ok=True)
+        return binary_dir
+
+
+binary_paths = BinaryPaths()