idm-cli 0.1.0__tar.gz → 0.2.0__tar.gz

{idm_cli-0.1.0 → idm_cli-0.2.0}/PKG-INFO

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: idm-cli
-Version: 0.1.0
+Version: 0.2.0
 Requires-Dist: typer[all]>=0.9.0
 Requires-Dist: httpx>=0.24.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: yt-dlp>=2023.0.0
+Requires-Dist: imageio-ffmpeg>=0.4.0
 Dynamic: requires-dist

{idm_cli-0.1.0 → idm_cli-0.2.0}/README.md

@@ -8,11 +8,17 @@
 
 1. **🚀 Segmented / Concurrent Downloads**: Splitting the file into up to 32 parallel streams (default 8) to download at the absolute maximum speed your bandwidth allows.
 2. **💬 Interactive Shell Mode (REPL)**: Run the simple command `idm` anywhere, and it opens a persistent, visual download shell prompt where you can copy/paste links sequentially.
-3. **⏯️ Robust Pause & Resume**: Supports pausing a download (using `Ctrl+C`) and resuming it exactly where it was left off. It even automatically refreshes expired YouTube temporary signatures in the background on resume!
-4. **🔔 Auto-Update Notification**: Clean, latency-free updates checks based on a 24-hour cache. Informs you when a new global release is available on PyPI.
-5. **🔒 Atomic State Management**: To prevent corruption in case of unexpected crashes or power outages, states are written using an atomic two-step file operation (`.tmp` write followed by safe replacement).
-6. **💾 RAM-Efficient Chunk Merging**: Uses $O(1)$ constant-memory buffered streaming (1MB blocks) to merge segments. Safely handles gigantic files (e.g., 10GB+) without lagging or crashing your system's RAM.
-7. **🎨 Beautiful Terminal UI**: Multi-progress bar dashboards built with `rich`, showing connection progress, total speed, ETAs, percentages, and clean summary tables.
+3. **🎭 Dynamic Quality Selection & Automated Merging (1080p, 4K)**:
+   - When downloading YouTube/streaming videos, you are prompted with a beautiful visual menu showing all available resolutions (144p, 360p, 720p, 1080p, 2K, 4K).
+   - High resolutions are downloaded concurrently (video + audio separately) and automatically merged in less than **1 second** (using copy remuxing)!
+4. **🔌 Zero-Setup Plug & Play Concurrency**: 
+   - Historically, merging high-resolution videos required the user to manually install `ffmpeg` and configure system paths.
+   - **IDM-CLI solves this!** We bundle **`imageio-ffmpeg`** which automatically downloads the correct static, lightweight FFmpeg binary for your specific OS (Windows, macOS, Linux) in the background during installation. Enjoy 1080p+ downloads out-of-the-box with **zero manual configuration**!
+5. **⏯️ Robust Pause & Resume**: Supports pausing a download (using `Ctrl+C`) and resuming it exactly where it was left off. It automatically refreshes expired YouTube temporary signatures in the background on resume!
+6. **🔔 Auto-Update Notification**: Clean, latency-free updates checks based on a 24-hour cache. Informs you when a new global release is available on PyPI.
+7. **🔒 Atomic State Management**: To prevent corruption in case of unexpected crashes or power outages, states are written using an atomic two-step file operation (`.tmp` write followed by safe replacement).
+8. **💾 RAM-Efficient Chunk Merging**: Uses $O(1)$ constant-memory buffered streaming (1MB blocks) to merge segments. Safely handles gigantic files (e.g., 10GB+) without lagging or crashing your system's RAM.
+9. **🎨 Beautiful Terminal UI**: Multi-progress bar dashboards built with `rich`, showing connection progress, total speed, ETAs, percentages, and clean summary tables.
 
 ---
 
@@ -36,6 +42,7 @@ To install the tool in editable development mode:
 ```powershell
 pip install -e .
 ```
+*(Pip will automatically download the lightweight static FFmpeg binary for your OS in the background. Zero manual installation required!)*
 
 ---
 
@@ -50,15 +57,15 @@ idm
 ```
 This opens the persistent prompt:
 ```text
-+------------------------------ idm shell ------------------------------+
-|                                                                       |
-|  IDM-CLI Interactive Shell Mode                                       |
-|                                                                       |
-|  • Paste any HTTP/HTTPS URL or YouTube URL to download instantly.     |
-|  • Type resume <metadata_file> to resume a paused download.           |
-|  • Type exit or press Ctrl+C to quit the application.                 |
-|                                                                       |
-+-----------------------------------------------------------------------+
++-------------------------------- idm shell --------------------------------+
+|                                                                           |
+|  IDM-CLI Interactive Shell Mode                                           |
+|                                                                           |
+|  • Paste any HTTP/HTTPS URL or YouTube URL to download instantly.         |
+|  • Type resume <metadata_file> to resume a paused download.               |
+|  • Type exit or press Ctrl+C to quit the application.                     |
+|                                                                           |
++---------------------------------------------------------------------------+
 idm> 
 ```
 *Paste your links directly and hit Enter. Type `exit` or press `Ctrl+C` to quit.*
@@ -79,6 +86,12 @@ To use 16 threads and save it to a custom directory:
 idm download https://example.com/largefile.zip -c 16 -o C:\path\to\downloads
 ```
 
+#### Target a Specific Video Quality directly:
+To download a YouTube video in 1080p directly:
+```bash
+idm download https://www.youtube.com/watch?v=... -q 1080
+```
+
 #### Resume a Download:
 ```bash
 idm resume largefile.zip.dl.json

{idm_cli-0.1.0 → idm_cli-0.2.0}/idm_cli.egg-info/PKG-INFO

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: idm-cli
-Version: 0.1.0
+Version: 0.2.0
 Requires-Dist: typer[all]>=0.9.0
 Requires-Dist: httpx>=0.24.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: yt-dlp>=2023.0.0
+Requires-Dist: imageio-ffmpeg>=0.4.0
 Dynamic: requires-dist

{idm_cli-0.1.0 → idm_cli-0.2.0}/idm_cli.egg-info/requires.txt

@@ -2,3 +2,4 @@ typer[all]>=0.9.0
 httpx>=0.24.0
 rich>=13.0.0
 yt-dlp>=2023.0.0
+imageio-ffmpeg>=0.4.0

{idm_cli-0.1.0 → idm_cli-0.2.0}/setup.py

@@ -2,13 +2,14 @@ from setuptools import setup, find_packages
 
 setup(
     name="idm-cli",
-    version="0.1.0",
+    version="0.2.0",
     packages=find_packages(),
     install_requires=[
         "typer[all]>=0.9.0",
         "httpx>=0.24.0",
         "rich>=13.0.0",
         "yt-dlp>=2023.0.0",
+        "imageio-ffmpeg>=0.4.0",
     ],
     entry_points={
         "console_scripts": [

idm_cli-0.2.0/speedy_dl/__init__.py

@@ -0,0 +1,2 @@
+# speedy_dl Package
+__version__ = "0.2.0"

idm_cli-0.2.0/speedy_dl/cli.py

@@ -0,0 +1,424 @@
+import os
+import sys
+import asyncio
+import logging
+import typer
+from typing import Optional
+from rich.console import Console
+from rich.panel import Panel
+
+from speedy_dl.downloader import SpeedyDownloader
+from speedy_dl.state import load_state
+from speedy_dl.updater import check_for_updates
+
+app = typer.Typer(
+    name="idm-cli",
+    help="IDM-CLI: A premium, blazing-fast multi-threaded CLI download manager (Internet Download Manager Clone) in Python.",
+    add_completion=True
+)
+
+console = Console()
+
+# Configure basic logging to avoid spam but print crucial internal details if needed
+logging.basicConfig(
+    level=logging.ERROR,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+
+def run_async_downloader(downloader: SpeedyDownloader):
+    """Runs the downloader asynchronously and handles Ctrl+C gracefully."""
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    
+    download_task = loop.create_task(downloader.start_download())
+    
+    try:
+        loop.run_until_complete(download_task)
+    except KeyboardInterrupt:
+        # Cancel the task on Ctrl+C to trigger the downloader's clean pause block
+        download_task.cancel()
+        try:
+            loop.run_until_complete(download_task)
+        except asyncio.CancelledError:
+            pass
+    except Exception as e:
+        console.print(f"[bold red]An unexpected error occurred: {e}[/bold red]")
+        sys.exit(1)
+    finally:
+        loop.close()
+
+import subprocess
+from speedy_dl.extractor import is_streaming_url, is_ffmpeg_installed, extract_stream_info, get_ffmpeg_path
+
+def merge_video_audio(video_path: str, audio_path: str, output_path: str) -> bool:
+    """Invokes ffmpeg via subprocess to remux separate audio and video files without re-encoding."""
+    try:
+        ffmpeg_exe = get_ffmpeg_path()
+        cmd = [
+            ffmpeg_exe, "-y",
+            "-i", video_path,
+            "-i", audio_path,
+            "-c:v", "copy",
+            "-c:a", "aac",
+            "-map", "0:v:0",
+            "-map", "1:a:0",
+            output_path
+        ]
+        # Run subprocess silently
+        result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        return result.returncode == 0
+    except Exception:
+        return False
+
+def prompt_for_quality(url: str) -> Optional[int]:
+    """
+    Presents a beautiful menu of available resolutions for a streaming video
+    and returns the selected resolution height (e.g. 1080, 720, 360).
+    """
+    console.print("[bold cyan]Fetching available video formats...[/bold cyan]")
+    info = extract_stream_info(url)
+    if not info:
+        return None
+        
+    resolutions = info.get("resolutions", [])
+    if not resolutions:
+        return None
+        
+    console.print("\n[bold green]Available Qualities:[/bold green]")
+    
+    choices = {}
+    default_index = None
+    
+    # We display them sorted descending (highest first)
+    sorted_res = sorted(list(resolutions), reverse=True)
+    
+    for idx, res in enumerate(sorted_res, 1):
+        label = f"{res}p"
+        if res == 720:
+            label += " (Default)"
+            default_index = idx
+        elif res == 1080:
+            label += " (HD)"
+        elif res > 1080:
+            label += " (Ultra HD / 4K)"
+            
+        console.print(f" [{idx}] {label}")
+        choices[str(idx)] = res
+        choices[f"{res}"] = res
+        choices[f"{res}p"] = res
+        
+    # If 720p is not available, default index is the first one (highest quality)
+    if not default_index and resolutions:
+        default_res = sorted_res[0]
+        for idx, res in enumerate(sorted_res, 1):
+            if res == default_res:
+                default_index = idx
+                break
+    else:
+        default_res = 720
+        
+    prompt_text = f"\nSelect quality index or resolution [bold yellow][default: {default_res}p][/bold yellow]: "
+    user_choice = console.input(prompt_text).strip()
+    
+    if not user_choice:
+        return default_res
+        
+    return choices.get(user_choice, choices.get(user_choice.lower(), default_res))
+
+def download_streaming_video(url: str, output_path: Optional[str], connections: int, selected_res: Optional[int]):
+    """Orchestrates streaming video downloads with full-resolution split merging and combined fallback options."""
+    # Check if user wants high-res but ffmpeg is missing
+    ffmpeg_available = is_ffmpeg_installed()
+    
+    if selected_res and selected_res > 720 and not ffmpeg_available:
+        console.print(
+            f"\n[bold red]Warning: ffmpeg is not installed on this PC.[/bold red]\n"
+            f"[yellow]Resolutions higher than 720p require ffmpeg to merge video/audio streams.\n"
+            f"Falling back to the best available combined format...[/yellow]"
+        )
+        selected_res = None  # Fallback to combined
+        
+    info = extract_stream_info(url, selected_resolution=selected_res)
+    if not info:
+        console.print("[bold red]Error: Failed to extract streaming information.[/bold red]")
+        return
+        
+    is_split = info.get("is_split", False)
+    title = info.get("title")
+    filename = info.get("filename")
+    
+    # Establish output path
+    downloads_dir = os.path.join(os.path.expanduser("~"), "Downloads")
+    if output_path:
+        if os.path.isdir(output_path):
+            final_filepath = os.path.join(output_path, filename)
+        else:
+            final_filepath = output_path
+    else:
+        if os.path.exists(downloads_dir) and os.path.isdir(downloads_dir):
+            final_filepath = os.path.join(downloads_dir, filename)
+        else:
+            final_filepath = os.path.abspath(filename)
+            
+    if not is_split:
+        # Combined download
+        downloader = SpeedyDownloader(
+            url=info["stream_url"],
+            output_path=final_filepath,
+            connections=connections,
+            selected_resolution=selected_res,
+            stream_type="combined"
+        )
+        downloader.original_url = url
+        downloader.is_stream = True
+        run_async_downloader(downloader)
+    else:
+        # Separate Video + Audio download
+        console.print(Panel(
+            f"[bold yellow]Split Quality Mode Activated ({selected_res}p)[/bold yellow]\n"
+            f"Downloading separate Video and Audio streams concurrently...",
+            border_style="bold yellow"
+        ))
+        
+        video_temp = final_filepath + ".temp_video"
+        audio_temp = final_filepath + ".temp_audio"
+        
+        # 1. Download Video
+        console.print("\n[bold cyan]1. Downloading Video Track...[/bold cyan]")
+        video_downloader = SpeedyDownloader(
+            url=info["video_url"],
+            output_path=video_temp,
+            connections=connections,
+            selected_resolution=selected_res,
+            stream_type="video"
+        )
+        video_downloader.original_url = url
+        video_downloader.is_stream = True
+        run_async_downloader(video_downloader)
+        
+        # 2. Download Audio
+        console.print("\n[bold cyan]2. Downloading Audio Track...[/bold cyan]")
+        audio_downloader = SpeedyDownloader(
+            url=info["audio_url"],
+            output_path=audio_temp,
+            connections=min(connections, 4),
+            selected_resolution=selected_res,
+            stream_type="audio"
+        )
+        audio_downloader.original_url = url
+        audio_downloader.is_stream = True
+        run_async_downloader(audio_downloader)
+        
+        # 3. Merge streams using FFmpeg
+        console.print("\n[bold green]3. Merging Video and Audio tracks into final MP4...[/bold green]")
+        success = merge_video_audio(video_temp, audio_temp, final_filepath)
+        if success:
+            # Clean up temp files
+            for p in (video_temp, audio_temp):
+                if os.path.exists(p):
+                    try:
+                        os.remove(p)
+                    except OSError:
+                        pass
+            console.print(f"[bold gold1]* File successfully saved to: {final_filepath}[/bold gold1]")
+        else:
+            console.print(
+                f"[bold red]✖ Error: FFmpeg merging failed. Raw streams are saved at:[/bold red]\n"
+                f" - Video: {video_temp}\n"
+                f" - Audio: {audio_temp}\n"
+                f"Please merge them manually or verify your FFmpeg installation."
+            )
+
+@app.command()
+def download(
+    url: str = typer.Argument(..., help="The HTTP/HTTPS URL of the file to download."),
+    output_path: Optional[str] = typer.Option(
+        None, "--output-path", "-o",
+        help="Custom destination directory or full filename path."
+    ),
+    connections: int = typer.Option(
+        8, "--connections", "-c", min=1, max=32,
+        help="Number of concurrent connection threads (1-32)."
+    ),
+    quality: Optional[str] = typer.Option(
+        None, "--quality", "-q",
+        help="Target video quality for streaming links (e.g. 360, 720, 1080)."
+    )
+):
+    """
+    Downloads a file or video globally.
+    If it's a streaming link, prompts visually or uses quality parameter.
+    """
+    if not url.startswith(("http://", "https://")):
+        console.print("[bold red]Error: Invalid URL protocol. Only http:// and https:// are supported.[/bold red]")
+        raise typer.Exit(code=1)
+
+    is_stream = is_streaming_url(url)
+    
+    if is_stream:
+        # Resolve quality parameter or prompt
+        if quality:
+            try:
+                selected_res = int(quality.lower().replace("p", ""))
+            except ValueError:
+                selected_res = 720
+        else:
+            selected_res = prompt_for_quality(url)
+            
+        download_streaming_video(url, output_path, connections, selected_res)
+    else:
+        # Standard file download
+        downloader = SpeedyDownloader(
+            url=url,
+            output_path=output_path,
+            connections=connections
+        )
+        run_async_downloader(downloader)
+
+@app.command()
+def resume(
+    state_file: str = typer.Argument(
+        ...,
+        help="Path to the '.dl.json' status file generated by a paused download."
+    )
+):
+    """
+    Resumes a paused download using the saved metadata file.
+    """
+    if not os.path.exists(state_file):
+        console.print(f"[bold red]Error: The state file '{state_file}' does not exist.[/bold red]")
+        raise typer.Exit(code=1)
+
+    # Load state first to extract original URL
+    metadata = load_state(state_file)
+    if not metadata:
+        console.print(f"[bold red]Error: Could not parse or load state from '{state_file}'. It may be corrupted.[/bold red]")
+        raise typer.Exit(code=1)
+
+    url = metadata.get("url")
+    connections = metadata.get("connections", 8)
+    filepath = metadata.get("filepath")
+
+    if not url:
+        console.print("[bold red]Error: Invalid state file format. Missing original URL.[/bold red]")
+        raise typer.Exit(code=1)
+
+    console.print(f"[bold yellow]Found pause state for:[/bold yellow] [cyan]{os.path.basename(filepath)}[/cyan]")
+    
+    downloader = SpeedyDownloader(
+        url=url,
+        output_path=filepath,
+        connections=connections,
+        state_file=state_file
+    )
+    
+    run_async_downloader(downloader)
+
+def interactive_shell():
+    # 1. Run quick asynchronous/cached check for updates
+    try:
+        new_version = check_for_updates()
+        if new_version:
+            import speedy_dl
+            console.print(Panel(
+                f"[bold gold1]★ A new version of idm-cli is available![/bold gold1]\n"
+                f"[bold white]Local Version:[/bold white] [red]{speedy_dl.__version__}[/red] ➜ "
+                f"[bold white]Latest Version:[/bold white] [green]{new_version}[/green]\n"
+                f"Run [bold cyan]pip install --upgrade idm-cli[/bold cyan] to update globally!",
+                border_style="bold gold1",
+                title="[bold gold1]Update Available[/bold gold1]",
+                padding=(1, 2)
+            ))
+            console.print()  # Spacer
+    except Exception:
+        pass
+
+    console.print(Panel(
+        "[bold green]IDM-CLI Interactive Shell Mode[/bold green]\n"
+        "[bold white]Developed by:[/bold white] [cyan]Rehan Jamil[/cyan]\n"
+        "[bold white]GitHub Profile:[/bold white] [link=https://github.com/rj41-w2][cyan]github.com/rj41-w2[/cyan][/link] [dim](Ctrl + Click to Open)[/dim]\n\n"
+        "• Paste any HTTP/HTTPS URL or YouTube URL to download instantly.\n"
+        "• Type [bold yellow]resume <metadata_file>[/bold yellow] to resume a paused download.\n"
+        "• Type [bold yellow]help[/bold yellow] to see all available commands.\n"
+        "• Type [bold red]exit[/bold red] or press [bold red]Ctrl+C[/bold red] to quit the application.",
+        title="[bold yellow]idm-cli[/bold yellow]",
+        border_style="bold green",
+        padding=(1, 2)
+    ))
+    
+    # Import Table inside for clean scoping
+    from rich.table import Table
+
+    while True:
+        try:
+            url_input = console.input("[bold cyan]idm>[/bold cyan] ").strip()
+            if not url_input:
+                continue
+                
+            if url_input.lower() in ("help", "?"):
+                # Render a beautiful help commands table
+                help_table = Table(title="[bold yellow]IDM-CLI Shell Commands[/bold yellow]", border_style="bold cyan")
+                help_table.add_column("Command", style="bold green", justify="left")
+                help_table.add_column("Description", style="white", justify="left")
+                help_table.add_row("<URL>", "Paste a direct download link or YouTube/streaming video URL to download.")
+                help_table.add_row("resume <state_file>", "Resumes an interrupted or paused download using its JSON state file.")
+                help_table.add_row("help / ?", "Displays this help menu showing all available commands.")
+                help_table.add_row("exit / quit", "Safely quits the interactive IDM-CLI shell.")
+                console.print()
+                console.print(help_table)
+                console.print()
+                continue
+                
+            if url_input.lower() in ("exit", "quit"):
+                console.print("[bold yellow]Goodbye![/bold yellow]")
+                break
+                
+            if url_input.startswith("resume "):
+                state_file = url_input[7:].strip()
+                if not os.path.exists(state_file):
+                    console.print(f"[bold red]Error: State file '{state_file}' does not exist.[/bold red]")
+                    continue
+                metadata = load_state(state_file)
+                if not metadata:
+                    console.print(f"[bold red]Error: Could not load state from '{state_file}'.[/bold red]")
+                    continue
+                url = metadata.get("url")
+                connections = metadata.get("connections", 8)
+                filepath = metadata.get("filepath")
+                downloader = SpeedyDownloader(
+                    url=url,
+                    output_path=filepath,
+                    connections=connections,
+                    state_file=state_file
+                )
+                run_async_downloader(downloader)
+                continue
+                
+            if not url_input.startswith(("http://", "https://")):
+                console.print("[bold red]Error: Please enter a valid HTTP/HTTPS URL or 'resume <state_file>'.[/bold red]")
+                continue
+                
+            if is_streaming_url(url_input):
+                selected_res = prompt_for_quality(url_input)
+                if selected_res:
+                    download_streaming_video(url_input, None, 8, selected_res)
+            else:
+                downloader = SpeedyDownloader(url=url_input)
+                run_async_downloader(downloader)
+            
+        except KeyboardInterrupt:
+            console.print("\n[bold yellow]Exiting Interactive Shell. Goodbye![/bold yellow]")
+            break
+        except Exception as e:
+            console.print(f"[bold red]Error: {e}[/bold red]")
+
+@app.callback(invoke_without_command=True)
+def main(ctx: typer.Context):
+    """
+    Main entry point. If no subcommand is specified, launches the interactive shell.
+    """
+    if ctx.invoked_subcommand is None:
+        interactive_shell()
+
+if __name__ == "__main__":
+    app()

{idm_cli-0.1.0 → idm_cli-0.2.0}/speedy_dl/downloader.py

@@ -20,9 +20,12 @@ class SpeedyDownloader:
         url: str,
         output_path: Optional[str] = None,
         connections: int = 8,
-        state_file: Optional[str] = None
+        state_file: Optional[str] = None,
+        selected_resolution: Optional[int] = None,
+        stream_type: Optional[str] = None
     ):
         self.connections = connections
+        self.custom_filepath = output_path is not None and not os.path.isdir(output_path)
         
         # Recover original url / stream status if resuming from a saved state file
         loaded = None
@@ -33,10 +36,14 @@ class SpeedyDownloader:
             self.url = loaded.get("url", url)
             self.original_url = loaded.get("original_url", self.url)
             self.is_stream = loaded.get("is_stream", is_streaming_url(self.original_url))
+            self.selected_resolution = loaded.get("selected_resolution", selected_resolution)
+            self.stream_type = loaded.get("stream_type", stream_type)
         else:
             self.url = url
             self.original_url = url
             self.is_stream = is_streaming_url(url)
+            self.selected_resolution = selected_resolution
+            self.stream_type = stream_type
         
         # We will determine these later
         self.total_size = 0
@@ -97,18 +104,33 @@ class SpeedyDownloader:
         if self.is_stream:
             console.print("[bold cyan]Extracting streaming video link...[/bold cyan]")
             loop = asyncio.get_running_loop()
-            info = await loop.run_in_executor(None, extract_stream_info, self.original_url)
+            info = await loop.run_in_executor(
+                None, 
+                lambda: extract_stream_info(self.original_url, self.selected_resolution)
+            )
             if not info:
                 raise ValueError("Failed to extract streaming details from URL. The video may be private or restricted.")
             
-            self.url = info["stream_url"]
-            self.filename = info["filename"]
-            self.total_size = info["size"]
-            self.resumable = True
+            # Select correct stream URL and size based on stream_type
+            if self.stream_type == "video" and "video_url" in info:
+                self.url = info["video_url"]
+                self.total_size = info["video_size"]
+            elif self.stream_type == "audio" and "audio_url" in info:
+                self.url = info["audio_url"]
+                self.total_size = info["audio_size"]
+            else:
+                self.url = info.get("stream_url", self.url)
+                self.total_size = info.get("size", self.total_size)
             
-            # Re-evaluate filepath and state paths based on fetched streaming name
-            dir_name = os.path.dirname(self.filepath) if self.filepath else os.getcwd()
-            self.filepath = os.path.join(dir_name, self.filename)
+            # Preserve user's custom file path (such as temp split track names)
+            if not self.custom_filepath:
+                self.filename = info["filename"]
+                dir_name = os.path.dirname(self.filepath) if self.filepath else os.getcwd()
+                self.filepath = os.path.join(dir_name, self.filename)
+            else:
+                self.filename = os.path.basename(self.filepath)
+                
+            self.resumable = True
             self.state_filepath = f"{self.filepath}.dl.json"
             
             return {
@@ -118,16 +140,19 @@ class SpeedyDownloader:
             }
 
         async with httpx.AsyncClient(follow_redirects=True, timeout=15.0) as client:
+            headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"}
             try:
                 # 1. Try HEAD request
-                response = await client.head(self.url)
+                response = await client.head(self.url, headers=headers)
                 if response.status_code >= 400:
                     # Fallback to GET for servers that block HEAD requests
-                    response = await client.get(self.url, headers={"Range": "bytes=0-0"})
+                    headers["Range"] = "bytes=0-0"
+                    response = await client.get(self.url, headers=headers)
             except Exception as e:
                 # Direct GET fallback
                 async with httpx.AsyncClient(follow_redirects=True, timeout=15.0) as client2:
-                    response = await client2.get(self.url, headers={"Range": "bytes=0-0"})
+                    headers["Range"] = "bytes=0-0"
+                    response = await client2.get(self.url, headers=headers)
 
             # Handle response headers
             headers = response.headers
@@ -213,7 +238,9 @@ class SpeedyDownloader:
             "total_size": self.total_size,
             "resumable": self.resumable,
             "connections": self.connections,
-            "segments": self.segments
+            "segments": self.segments,
+            "selected_resolution": self.selected_resolution,
+            "stream_type": self.stream_type
         }
         save_state_atomic(self.state_filepath, self.state)
 
@@ -254,7 +281,9 @@ class SpeedyDownloader:
             segment["downloaded"]
         )
 
-        headers = {}
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+        }
         if self.resumable:
             start_range = segment["start"] + segment["downloaded"]
             headers["Range"] = f"bytes={start_range}-{segment['end']}"
@@ -305,14 +334,24 @@ class SpeedyDownloader:
             self.segments = loaded["segments"]
             self.connections = loaded["connections"]
             self.is_stream = loaded.get("is_stream", False)
+            self.selected_resolution = loaded.get("selected_resolution", self.selected_resolution)
+            self.stream_type = loaded.get("stream_type", self.stream_type)
             
             # If it's a stream URL, refresh the potentially expired signature link!
             if self.is_stream:
                 console.print("[bold yellow]Refreshing expired streaming signatures...[/bold yellow]")
                 loop = asyncio.get_running_loop()
-                info = await loop.run_in_executor(None, extract_stream_info, self.original_url)
+                info = await loop.run_in_executor(
+                    None,
+                    lambda: extract_stream_info(self.original_url, self.selected_resolution)
+                )
                 if info:
-                    self.url = info["stream_url"]
+                    if self.stream_type == "video" and "video_url" in info:
+                        self.url = info["video_url"]
+                    elif self.stream_type == "audio" and "audio_url" in info:
+                        self.url = info["audio_url"]
+                    else:
+                        self.url = info.get("stream_url", self.url)
                 else:
                     console.print("[bold red]Warning: Failed to refresh streaming link. Trying with old URL...[/bold red]")
         else:

idm_cli-0.2.0/speedy_dl/extractor.py

@@ -0,0 +1,193 @@
+import os
+import shutil
+import logging
+from typing import Dict, Any, Optional, List
+from urllib.parse import urlparse
+import yt_dlp
+
+logger = logging.getLogger("speedy_dl.extractor")
+
+def is_streaming_url(url: str) -> bool:
+    """
+    Checks if a URL belongs to a supported streaming site (YouTube, Vimeo, etc.).
+    This is a fast local check based on domains to avoid network delay.
+    """
+    streaming_domains = [
+        "youtube.com", "youtu.be", "vimeo.com", 
+        "dailymotion.com", "twitch.tv", "facebook.com",
+        "instagram.com", "tiktok.com"
+    ]
+    try:
+        parsed = urlparse(url)
+        netloc = parsed.netloc.lower()
+        return any(domain in netloc for domain in streaming_domains)
+    except Exception:
+        return False
+
+def is_ffmpeg_installed() -> bool:
+    """Checks if ffmpeg is installed globally in PATH or available via imageio-ffmpeg."""
+    if shutil.which("ffmpeg") is not None:
+        return True
+    try:
+        import imageio_ffmpeg
+        return imageio_ffmpeg.get_ffmpeg_exe() is not None
+    except ImportError:
+        return False
+
+def get_ffmpeg_path() -> str:
+    """Returns the path to the active ffmpeg executable (global or bundled)."""
+    if shutil.which("ffmpeg") is not None:
+        return "ffmpeg"
+    try:
+        import imageio_ffmpeg
+        bundled = imageio_ffmpeg.get_ffmpeg_exe()
+        if bundled:
+            return bundled
+    except ImportError:
+        pass
+    return "ffmpeg"
+
+def extract_stream_info(url: str, selected_resolution: Optional[int] = None) -> Optional[Dict[str, Any]]:
+    """
+    Extracts streaming video details. 
+    If the selected resolution has a combined (audio+video) stream, it uses it directly (is_split=False).
+    Otherwise, if ffmpeg is installed, downloads separate video and audio streams concurrently.
+    Falls back to the best available combined stream if separate streams are not available or ffmpeg is missing.
+    """
+    ydl_opts = {
+        "quiet": True,
+        "no_warnings": True,
+    }
+    
+    try:
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            info = ydl.extract_info(url, download=False)
+            if not info:
+                return None
+            
+            title = info.get("title", "streaming_video")
+            safe_title = "".join(c for c in title if c.isalnum() or c in "._- ").strip()
+            if not safe_title:
+                safe_title = "streaming_video"
+            
+            formats = info.get("formats", [])
+            
+            # Extract unique available video heights, converting safely to integers
+            available_heights = set()
+            for f in formats:
+                height = f.get("height")
+                if height is not None and f.get("vcodec") != "none":
+                    try:
+                        available_heights.add(int(height))
+                    except (ValueError, TypeError):
+                        pass
+            sorted_heights = sorted(list(available_heights), reverse=True)
+            
+            # Filter all combined formats containing both video and audio
+            combined_formats = [
+                f for f in formats 
+                if f.get("vcodec") != "none" 
+                and f.get("acodec") != "none" 
+                and f.get("url")
+            ]
+            combined_formats.sort(
+                key=lambda x: (x.get("height", 0) or 0, x.get("tbr", 0) or 0), 
+                reverse=True
+            )
+            best_combined = combined_formats[0] if combined_formats else None
+            
+            ffmpeg_available = is_ffmpeg_installed()
+            
+            # 1. Check if there is a direct combined format matching the selected resolution
+            # (e.g. if user chose 360p or 720p, and a combined 360p/720p format exists)
+            combined_match = None
+            if selected_resolution and combined_formats:
+                try:
+                    target_res = int(selected_resolution)
+                    matches = [
+                        f for f in combined_formats 
+                        if f.get("height") is not None and int(f.get("height")) == target_res
+                    ]
+                    if matches:
+                        combined_match = matches[0]
+                except (ValueError, TypeError):
+                    pass
+
+            if combined_match:
+                size = combined_match.get("filesize") or combined_match.get("filesize_approx") or 0
+                ext = combined_match.get("ext", "mp4")
+                return {
+                    "title": title,
+                    "filename": f"{safe_title}.{ext}",
+                    "is_split": False,
+                    "stream_url": combined_match.get("url"),
+                    "size": size,
+                    "resolutions": sorted_heights,
+                    "selected_resolution": selected_resolution
+                }
+            
+            # 2. Otherwise, if we have a chosen resolution and ffmpeg is installed, try splitting
+            if selected_resolution and ffmpeg_available:
+                try:
+                    target_res = int(selected_resolution)
+                    
+                    # Find separate video-only stream matching target resolution
+                    video_candidates = [
+                        f for f in formats 
+                        if f.get("height") is not None 
+                        and int(f.get("height")) == target_res
+                        and f.get("vcodec") != "none"
+                        and f.get("url")
+                    ]
+                    video_candidates.sort(key=lambda x: x.get("tbr", 0) or 0, reverse=True)
+                    
+                    # Find the best separate audio-only stream
+                    audio_candidates = [
+                        f for f in formats 
+                        if f.get("acodec") != "none" 
+                        and f.get("vcodec") == "none"
+                        and f.get("url")
+                    ]
+                    audio_candidates.sort(key=lambda x: x.get("tbr", 0) or 0, reverse=True)
+                    
+                    if video_candidates and audio_candidates:
+                        best_video = video_candidates[0]
+                        best_audio = audio_candidates[0]
+                        
+                        return {
+                            "title": title,
+                            "filename": f"{safe_title}.mp4",
+                            "is_split": True,
+                            "video_url": best_video.get("url"),
+                            "video_size": best_video.get("filesize") or best_video.get("filesize_approx") or 0,
+                            "audio_url": best_audio.get("url"),
+                            "audio_size": best_audio.get("filesize") or best_audio.get("filesize_approx") or 0,
+                            "resolutions": sorted_heights,
+                            "selected_resolution": selected_resolution
+                        }
+                except (ValueError, TypeError):
+                    pass
+            
+            # 3. Fallback to best available combined format (usually 360p or 720p)
+            if best_combined:
+                stream_url = best_combined.get("url")
+                size = best_combined.get("filesize") or best_combined.get("filesize_approx") or 0
+                ext = best_combined.get("ext", "mp4")
+            else:
+                stream_url = info.get("url")
+                size = info.get("filesize") or info.get("filesize_approx") or 0
+                ext = info.get("ext", "mp4")
+                
+            return {
+                "title": title,
+                "filename": f"{safe_title}.{ext}",
+                "is_split": False,
+                "stream_url": stream_url,
+                "size": size,
+                "resolutions": sorted_heights,
+                "selected_resolution": best_combined.get("height") if best_combined else None
+            }
+            
+    except Exception as e:
+        logger.error(f"Failed to extract stream info: {e}")
+        return None

idm_cli-0.1.0/speedy_dl/__init__.py

@@ -1,2 +0,0 @@
-# speedy_dl Package
-__version__ = "0.1.0"

idm_cli-0.1.0/speedy_dl/cli.py

@@ -1,199 +0,0 @@
-import os
-import sys
-import asyncio
-import logging
-import typer
-from typing import Optional
-from rich.console import Console
-from rich.panel import Panel
-
-from speedy_dl.downloader import SpeedyDownloader
-from speedy_dl.state import load_state
-from speedy_dl.updater import check_for_updates
-
-app = typer.Typer(
-    name="idm-cli",
-    help="IDM-CLI: A premium, blazing-fast multi-threaded CLI download manager (Internet Download Manager Clone) in Python.",
-    add_completion=True
-)
-
-console = Console()
-
-# Configure basic logging to avoid spam but print crucial internal details if needed
-logging.basicConfig(
-    level=logging.ERROR,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-)
-
-def run_async_downloader(downloader: SpeedyDownloader):
-    """Runs the downloader asynchronously and handles Ctrl+C gracefully."""
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-    
-    download_task = loop.create_task(downloader.start_download())
-    
-    try:
-        loop.run_until_complete(download_task)
-    except KeyboardInterrupt:
-        # Cancel the task on Ctrl+C to trigger the downloader's clean pause block
-        download_task.cancel()
-        try:
-            loop.run_until_complete(download_task)
-        except asyncio.CancelledError:
-            pass
-    except Exception as e:
-        console.print(f"[bold red]An unexpected error occurred: {e}[/bold red]")
-        sys.exit(1)
-    finally:
-        loop.close()
-
-@app.command()
-def download(
-    url: str = typer.Argument(..., help="The HTTP/HTTPS URL of the file to download."),
-    output_path: Optional[str] = typer.Option(
-        None, "--output-path", "-o",
-        help="Custom destination directory or full filename path."
-    ),
-    connections: int = typer.Option(
-        8, "--connections", "-c", min=1, max=32,
-        help="Number of concurrent connection threads (1-32)."
-    )
-):
-    """
-    Downloads a file using multi-threaded segmented requests.
-    Automatically checks if server supports resuming and generates status checkpoints.
-    """
-    if not url.startswith(("http://", "https://")):
-        console.print("[bold red]Error: Invalid URL protocol. Only http:// and https:// are supported.[/bold red]")
-        raise typer.Exit(code=1)
-
-    downloader = SpeedyDownloader(
-        url=url,
-        output_path=output_path,
-        connections=connections
-    )
-    
-    run_async_downloader(downloader)
-
-@app.command()
-def resume(
-    state_file: str = typer.Argument(
-        ...,
-        help="Path to the '.dl.json' status file generated by a paused download."
-    )
-):
-    """
-    Resumes a paused download using the saved metadata file.
-    """
-    if not os.path.exists(state_file):
-        console.print(f"[bold red]Error: The state file '{state_file}' does not exist.[/bold red]")
-        raise typer.Exit(code=1)
-
-    # Load state first to extract original URL
-    metadata = load_state(state_file)
-    if not metadata:
-        console.print(f"[bold red]Error: Could not parse or load state from '{state_file}'. It may be corrupted.[/bold red]")
-        raise typer.Exit(code=1)
-
-    url = metadata.get("url")
-    connections = metadata.get("connections", 8)
-    filepath = metadata.get("filepath")
-
-    if not url:
-        console.print("[bold red]Error: Invalid state file format. Missing original URL.[/bold red]")
-        raise typer.Exit(code=1)
-
-    console.print(f"[bold yellow]Found pause state for:[/bold yellow] [cyan]{os.path.basename(filepath)}[/cyan]")
-    
-    downloader = SpeedyDownloader(
-        url=url,
-        output_path=filepath,
-        connections=connections,
-        state_file=state_file
-    )
-    
-    run_async_downloader(downloader)
-
-def interactive_shell():
-    # 1. Run quick asynchronous/cached check for updates
-    try:
-        new_version = check_for_updates()
-        if new_version:
-            import speedy_dl
-            console.print(Panel(
-                f"[bold gold1]★ A new version of idm-cli is available![/bold gold1]\n"
-                f"[bold white]Local Version:[/bold white] [red]{speedy_dl.__version__}[/red] ➜ "
-                f"[bold white]Latest Version:[/bold white] [green]{new_version}[/green]\n"
-                f"Run [bold cyan]pip install --upgrade idm-cli[/bold cyan] to update globally!",
-                border_style="bold gold1",
-                title="[bold gold1]Update Available[/bold gold1]",
-                padding=(1, 2)
-            ))
-            console.print()  # Spacer
-    except Exception:
-        pass
-
-    console.print(Panel(
-        "[bold green]IDM-CLI Interactive Shell Mode[/bold green]\n\n"
-        "• Paste any HTTP/HTTPS URL or YouTube URL to download instantly.\n"
-        "• Type [bold yellow]resume <metadata_file>[/bold yellow] to resume a paused download.\n"
-        "• Type [bold red]exit[/bold bold red] or press [bold red]Ctrl+C[/bold red] to quit the application.",
-        title="[bold yellow]idm shell[/bold yellow]",
-        border_style="bold green",
-        padding=(1, 2)
-    ))
-    
-    while True:
-        try:
-            url_input = console.input("[bold cyan]idm>[/bold cyan] ").strip()
-            if not url_input:
-                continue
-                
-            if url_input.lower() in ("exit", "quit"):
-                console.print("[bold yellow]Goodbye![/bold yellow]")
-                break
-                
-            if url_input.startswith("resume "):
-                state_file = url_input[7:].strip()
-                if not os.path.exists(state_file):
-                    console.print(f"[bold red]Error: State file '{state_file}' does not exist.[/bold red]")
-                    continue
-                metadata = load_state(state_file)
-                if not metadata:
-                    console.print(f"[bold red]Error: Could not load state from '{state_file}'.[/bold red]")
-                    continue
-                url = metadata.get("url")
-                connections = metadata.get("connections", 8)
-                filepath = metadata.get("filepath")
-                downloader = SpeedyDownloader(
-                    url=url,
-                    output_path=filepath,
-                    connections=connections,
-                    state_file=state_file
-                )
-                run_async_downloader(downloader)
-                continue
-                
-            if not url_input.startswith(("http://", "https://")):
-                console.print("[bold red]Error: Please enter a valid HTTP/HTTPS URL or 'resume <state_file>'.[/bold red]")
-                continue
-                
-            downloader = SpeedyDownloader(url=url_input)
-            run_async_downloader(downloader)
-            
-        except KeyboardInterrupt:
-            console.print("\n[bold yellow]Exiting Interactive Shell. Goodbye![/bold yellow]")
-            break
-        except Exception as e:
-            console.print(f"[bold red]Error: {e}[/bold red]")
-
-@app.callback(invoke_without_command=True)
-def main(ctx: typer.Context):
-    """
-    Main entry point. If no subcommand is specified, launches the interactive shell.
-    """
-    if ctx.invoked_subcommand is None:
-        interactive_shell()
-
-if __name__ == "__main__":
-    app()

idm_cli-0.1.0/speedy_dl/extractor.py

@@ -1,88 +0,0 @@
-import logging
-from typing import Dict, Any, Optional
-from urllib.parse import urlparse
-import yt_dlp
-
-logger = logging.getLogger("speedy_dl.extractor")
-
-def is_streaming_url(url: str) -> bool:
-    """
-    Checks if a URL belongs to a supported streaming site (YouTube, Vimeo, etc.).
-    This is a fast local check based on domains to avoid network delay.
-    """
-    streaming_domains = [
-        "youtube.com", "youtu.be", "vimeo.com", 
-        "dailymotion.com", "twitch.tv", "facebook.com",
-        "instagram.com", "tiktok.com"
-    ]
-    try:
-        parsed = urlparse(url)
-        netloc = parsed.netloc.lower()
-        return any(domain in netloc for domain in streaming_domains)
-    except Exception:
-        return False
-
-def extract_stream_info(url: str) -> Optional[Dict[str, Any]]:
-    """
-    Programmatically invokes yt-dlp to extract the video title and the direct 
-    HTTPS streaming URL for the best available format that contains both video and audio.
-    """
-    ydl_opts = {
-        "quiet": True,
-        "no_warnings": True,
-        "format": "best",  # yt-dlp default fallback
-    }
-    
-    try:
-        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-            # Extract info without downloading the media
-            info = ydl.extract_info(url, download=False)
-            if not info:
-                return None
-            
-            title = info.get("title", "streaming_video")
-            # Sanitize title to make it a safe filename
-            safe_title = "".join(c for c in title if c.isalnum() or c in "._- ").strip()
-            if not safe_title:
-                safe_title = "streaming_video"
-            
-            formats = info.get("formats", [])
-            # Filter for formats containing BOTH video and audio so it plays out-of-the-box
-            combined_formats = [
-                f for f in formats 
-                if f.get("vcodec") != "none" 
-                and f.get("acodec") != "none" 
-                and f.get("url")
-            ]
-            
-            # Sort by resolution (height) then bitrate (tbr) descending
-            combined_formats.sort(
-                key=lambda x: (x.get("height", 0) or 0, x.get("tbr", 0) or 0), 
-                reverse=True
-            )
-            
-            if not combined_formats:
-                # Fallback to standard best format if no explicit combined filter matches
-                best_format = info
-                ext = info.get("ext", "mp4")
-            else:
-                best_format = combined_formats[0]
-                ext = best_format.get("ext", "mp4")
-                
-            stream_url = best_format.get("url")
-            size = best_format.get("filesize") or best_format.get("filesize_approx") or 0
-            
-            # Form clean filename
-            filename = f"{safe_title}.{ext}"
-            
-            return {
-                "title": title,
-                "filename": filename,
-                "stream_url": stream_url,
-                "size": size,
-                "ext": ext
-            }
-            
-    except Exception as e:
-        logger.error(f"Failed to extract stream info: {e}")
-        return None