idm-cli 0.2.3__tar.gz → 0.2.4__tar.gz

{idm_cli-0.2.3 → idm_cli-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: idm-cli
-Version: 0.2.3
+Version: 0.2.4
 Requires-Dist: typer[all]>=0.9.0
 Requires-Dist: httpx>=0.24.0
 Requires-Dist: rich>=13.0.0

idm_cli-0.2.4/idm_cli/__init__.py

@@ -0,0 +1,2 @@
+# idm_cli Package
+__version__ = "0.2.4"

{idm_cli-0.2.3 → idm_cli-0.2.4}/idm_cli/cli.py

@@ -3,7 +3,7 @@ import sys
 import asyncio
 import logging
 import typer
-from typing import Optional
+from typing import Optional, Any
 from rich.console import Console
 from rich.panel import Panel
 
@@ -42,8 +42,8 @@ def run_async_downloader(downloader: IDMDownloader):
         except asyncio.CancelledError:
             pass
     except Exception as e:
-        console.print(f"[bold red]An unexpected error occurred: {e}[/bold red]")
-        sys.exit(1)
+        # Re-raise the exception instead of calling sys.exit(1) to avoid killing the shell/server process.
+        raise e
     finally:
         loop.close()
 
@@ -255,25 +255,28 @@ def download(
 
     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
+    try:
+        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:
-            selected_res = prompt_for_quality(url)
-            
-        download_streaming_video(url, output_path, connections, selected_res)
-    else:
-        # Standard file download
-        downloader = IDMDownloader(
-            url=url,
-            output_path=output_path,
-            connections=connections
-        )
-        run_async_downloader(downloader)
+            # Standard file download
+            downloader = IDMDownloader(
+                url=url,
+                output_path=output_path,
+                connections=connections
+            )
+            run_async_downloader(downloader)
+    except Exception:
+        raise typer.Exit(code=1)
 
 @app.command()
 def resume(
@@ -312,7 +315,44 @@ def resume(
         state_file=state_file
     )
     
-    run_async_downloader(downloader)
+    try:
+        run_async_downloader(downloader)
+    except Exception:
+        raise typer.Exit(code=1)
+
+def handle_incoming_url(url: str, quality: Optional[Any] = None):
+    """Callback triggered sequentially by the queue worker when it's this URL's turn to download."""
+    console.print(f"\n[bold green]▶ [Queue Download Started]:[/bold green] [cyan]{url}[/cyan]")
+    try:
+        if is_streaming_url(url):
+            target_quality = quality if quality is not None else 720
+            try:
+                if isinstance(target_quality, str):
+                    target_quality = int(target_quality.lower().replace("p", ""))
+                else:
+                    target_quality = int(target_quality)
+            except (ValueError, TypeError):
+                target_quality = 720
+            console.print(f"[bold yellow]Routing stream download to {target_quality}p...[/bold yellow]")
+            download_streaming_video(url, None, 8, target_quality)
+        else:
+            downloader = IDMDownloader(url=url)
+            run_async_downloader(downloader)
+        
+        console.print(f"[bold green]✓ Download completed successfully.[/bold green]")
+        
+        # Check if more items are waiting in the queue
+        from idm_cli.server import _queue_lock, _queue_items
+        with _queue_lock:
+            waiting = sum(1 for qi in _queue_items if qi["status"] == "waiting")
+        if waiting > 0:
+            console.print(f"[bold cyan]⏳ {waiting} more download(s) waiting in queue. Starting next...[/bold cyan]")
+        
+        # Reprint the prompt cleanly
+        console.print("\n[bold cyan]idm>[/bold cyan] ", end="")
+    except Exception as e:
+        console.print(f"[bold red]✖ Download failed: {e}[/bold red]")
+        console.print("\n[bold cyan]idm>[/bold cyan] ", end="")
 
 def interactive_shell():
     # 1. Run quick asynchronous/cached check for updates
@@ -333,8 +373,9 @@ def interactive_shell():
     except Exception:
         pass
 
+    import idm_cli
     console.print(Panel(
-        "[bold green]IDM-CLI Interactive Shell Mode[/bold green]\n"
+        f"[bold green]IDM-CLI Interactive Shell Mode[/bold green] [yellow]v{idm_cli.__version__}[/yellow]\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"
@@ -348,6 +389,18 @@ def interactive_shell():
         padding=(1, 2)
     ))
     
+    # Start the local HTTP background server for browser extension integration
+    import threading
+    from idm_cli.server import start_server
+    
+    server_thread = threading.Thread(
+        target=start_server, 
+        args=(18944, handle_incoming_url), 
+        daemon=True
+    )
+    server_thread.start()
+    console.print("[bold green]✓ Browser Integration Server listening on http://localhost:18944[/bold green]\n")
+    
     # Import Table inside for clean scoping
     from rich.table import Table
 

{idm_cli-0.2.3 → idm_cli-0.2.4}/idm_cli/downloader.py

@@ -257,7 +257,7 @@ class IDMDownloader:
         segment: Dict[str, Any],
         ui: IDMProgress
     ):
-        """Downloads a single file byte segment concurrently."""
+        """Downloads a single file byte segment concurrently with automatic retries."""
         seg_id = segment["id"]
         part_path = segment["part_path"]
         
@@ -268,7 +268,7 @@ class IDMDownloader:
 
         async with self._write_lock:
             segment["downloaded"] = current_disk_bytes
-            if segment["downloaded"] >= (segment["end"] - segment["start"] + 1) and segment["end"] > 0:
+            if segment["end"] > 0 and segment["downloaded"] >= (segment["end"] - segment["start"] + 1):
                 segment["completed"] = True
                 ui.set_segment_total(seg_id, segment["end"] - segment["start"] + 1, segment["downloaded"])
                 ui.mark_segment_completed(seg_id)
@@ -281,45 +281,61 @@ class IDMDownloader:
             segment["downloaded"]
         )
 
-        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']}"
+        max_retries = 5
+        last_error = None
 
-        mode = "ab" if segment["downloaded"] > 0 else "wb"
-        
-        try:
-            async with client.stream("GET", self.url, headers=headers, timeout=30.0) as response:
-                if response.status_code not in (200, 206):
-                    raise httpx.HTTPStatusError(
-                        f"Bad status code {response.status_code}", 
-                        request=response.request, 
-                        response=response
-                    )
-                
-                # Dynamic write buffer matching
-                with open(part_path, mode) as f:
-                    async for chunk in response.aiter_bytes(chunk_size=16384):
-                        f.write(chunk)
-                        chunk_len = len(chunk)
-                        
-                        async with self._write_lock:
-                            segment["downloaded"] += chunk_len
-                        
-                        ui.update_segment(seg_id, chunk_len)
+        for attempt in range(max_retries):
+            # Calculate range dynamically based on current downloaded bytes
+            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"]
+                if start_range > segment["end"]:
+                    break
+                headers["Range"] = f"bytes={start_range}-{segment['end']}"
 
-            async with self._write_lock:
-                segment["completed"] = True
-            ui.mark_segment_completed(seg_id)
-
-        except asyncio.CancelledError:
-            # Handle graceful cancellation state updates
-            raise
-        except Exception as e:
-            logger.error(f"Error in connection {seg_id + 1}: {e}")
-            raise e
+            # Append mode if we already have some bytes written to disk
+            mode = "ab" if segment["downloaded"] > 0 else "wb"
+            
+            try:
+                async with client.stream("GET", self.url, headers=headers, timeout=30.0) as response:
+                    if response.status_code not in (200, 206):
+                        raise httpx.HTTPStatusError(
+                            f"Bad status code {response.status_code}", 
+                            request=response.request, 
+                            response=response
+                        )
+                    
+                    # Dynamic write buffer matching
+                    with open(part_path, mode) as f:
+                        async for chunk in response.aiter_bytes(chunk_size=16384):
+                            f.write(chunk)
+                            chunk_len = len(chunk)
+                            
+                            async with self._write_lock:
+                                segment["downloaded"] += chunk_len
+                            
+                            ui.update_segment(seg_id, chunk_len)
+
+                # Successfully downloaded this segment
+                async with self._write_lock:
+                    segment["completed"] = True
+                ui.mark_segment_completed(seg_id)
+                return
+
+            except asyncio.CancelledError:
+                # Handle graceful cancellation state updates
+                raise
+            except Exception as e:
+                last_error = e
+                logger.warning(f"Connection {seg_id + 1} failed (attempt {attempt + 1}/{max_retries}): {e}")
+                # Wait before retrying (exponential backoff)
+                await asyncio.sleep(1.5 * (attempt + 1))
+
+        # If we exhausted all retries, raise the error
+        logger.error(f"Error in connection {seg_id + 1} after {max_retries} attempts: {last_error}", exc_info=True)
+        raise last_error
 
     async def start_download(self):
         """Orchestrates the entire multi-threaded download process."""

{idm_cli-0.2.3 → idm_cli-0.2.4}/idm_cli/extractor.py

@@ -54,9 +54,26 @@ def extract_stream_info(url: str, selected_resolution: Optional[int] = None) ->
     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.
     """
+    # Clean YouTube URL to strip playlist and other non-essential query parameters
+    if "youtube.com" in url or "youtu.be" in url:
+        from urllib.parse import urlparse, parse_qs, urlencode, urlunparse
+        try:
+            parsed = urlparse(url)
+            query = parse_qs(parsed.query)
+            if "v" in query:
+                new_query = {"v": query["v"]}
+                new_query_str = urlencode(new_query, doseq=True)
+                parsed = parsed._replace(query=new_query_str)
+                url = urlunparse(parsed)
+        except Exception:
+            pass
+
     ydl_opts = {
         "quiet": True,
         "no_warnings": True,
+        "noplaylist": True,
+        "youtube_include_dash_manifest": False,
+        "youtube_include_hls_manifest": False,
     }
     
     try:

idm_cli-0.2.4/idm_cli/server.py

@@ -0,0 +1,189 @@
+import json
+import logging
+import queue
+from http.server import BaseHTTPRequestHandler, HTTPServer
+import threading
+import urllib.parse
+
+logger = logging.getLogger("idm_cli.server")
+
+# Global reference to trigger downloads in the main CLI thread
+_download_callback = None
+
+# Thread-safe download queue (max 10 items)
+MAX_QUEUE_SIZE = 10
+_download_queue = queue.Queue(maxsize=MAX_QUEUE_SIZE)
+
+# Tracking for display: list of dicts with url, quality, status
+_queue_lock = threading.Lock()
+_queue_items = []  # [{url, quality, status: "waiting"/"downloading"/"done"}]
+_current_download = None  # url string of item currently downloading
+
+
+def _queue_worker():
+    """Background worker that processes the download queue sequentially."""
+    global _current_download
+    while True:
+        # Block until an item is available
+        item = _download_queue.get()
+        if item is None:
+            break  # Poison pill to stop worker
+
+        url = item["url"]
+        quality = item["quality"]
+
+        # Mark as downloading
+        with _queue_lock:
+            _current_download = url
+            for qi in _queue_items:
+                if qi["url"] == url and qi["status"] == "waiting":
+                    qi["status"] = "downloading"
+                    break
+
+        # Execute the download callback
+        try:
+            if _download_callback:
+                _download_callback(url, quality)
+        except Exception as e:
+            logger.error(f"Queue download failed for {url}: {e}")
+
+        # Mark as done and remove from tracking list
+        with _queue_lock:
+            _current_download = None
+            _queue_items[:] = [qi for qi in _queue_items if not (qi["url"] == url and qi["status"] == "downloading")]
+
+        _download_queue.task_done()
+
+
+class IDMRequestHandler(BaseHTTPRequestHandler):
+    def log_message(self, format, *args):
+        # Prevent default logging to keep terminal UI clean
+        pass
+
+    def _send_json(self, status_code, data):
+        """Helper to send a JSON response with CORS headers."""
+        self.send_response(status_code)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.end_headers()
+        self.wfile.write(json.dumps(data).encode("utf-8"))
+
+    def do_GET(self):
+        parsed_url = urllib.parse.urlparse(self.path)
+        if parsed_url.path == "/ping":
+            self._send_json(200, {"status": "alive"})
+        elif parsed_url.path == "/info":
+            query_params = urllib.parse.parse_qs(parsed_url.query)
+            url_list = query_params.get("url")
+            url = url_list[0] if url_list else None
+            
+            if not url:
+                self._send_json(400, {"error": "Missing URL"})
+                return
+            
+            from idm_cli.extractor import extract_stream_info
+            try:
+                info = extract_stream_info(url)
+                if info:
+                    response_data = {
+                        "title": info.get("title", ""),
+                        "resolutions": info.get("resolutions", [])
+                    }
+                else:
+                    response_data = {"error": "Failed to extract info"}
+            except Exception as e:
+                response_data = {"error": str(e)}
+                
+            self._send_json(200, response_data)
+        elif parsed_url.path == "/queue":
+            # Return current queue status
+            with _queue_lock:
+                items_info = []
+                for qi in _queue_items:
+                    items_info.append({
+                        "url": qi["url"],
+                        "quality": qi["quality"],
+                        "status": qi["status"]
+                    })
+            self._send_json(200, {
+                "queue_size": len(items_info),
+                "max_size": MAX_QUEUE_SIZE,
+                "items": items_info
+            })
+        else:
+            self.send_response(404)
+            self.end_headers()
+
+    def do_POST(self):
+        parsed_url = urllib.parse.urlparse(self.path)
+        if parsed_url.path == "/download":
+            content_length = int(self.headers.get('Content-Length', 0))
+            post_data = self.rfile.read(content_length)
+            
+            try:
+                data = json.loads(post_data.decode('utf-8'))
+                url = data.get("url")
+                quality = data.get("quality")
+            except Exception:
+                url = None
+                quality = None
+
+            if not url:
+                self._send_json(400, {"error": "Missing URL"})
+                return
+
+            # Check if queue is full
+            with _queue_lock:
+                waiting_count = sum(1 for qi in _queue_items if qi["status"] in ("waiting", "downloading"))
+                if waiting_count >= MAX_QUEUE_SIZE:
+                    self._send_json(429, {
+                        "error": "Queue is full",
+                        "message": f"Maximum {MAX_QUEUE_SIZE} downloads allowed. Please wait for current downloads to finish.",
+                        "queue_size": waiting_count,
+                        "max_size": MAX_QUEUE_SIZE
+                    })
+                    return
+
+            # Add to queue
+            item = {"url": url, "quality": quality}
+            try:
+                _download_queue.put_nowait(item)
+                with _queue_lock:
+                    _queue_items.append({"url": url, "quality": quality, "status": "waiting"})
+                    position = sum(1 for qi in _queue_items if qi["status"] in ("waiting", "downloading"))
+                
+                self._send_json(200, {
+                    "status": "queued",
+                    "position": position,
+                    "queue_size": position,
+                    "max_size": MAX_QUEUE_SIZE
+                })
+            except queue.Full:
+                self._send_json(429, {
+                    "error": "Queue is full",
+                    "message": f"Maximum {MAX_QUEUE_SIZE} downloads allowed.",
+                    "max_size": MAX_QUEUE_SIZE
+                })
+        else:
+            self.send_response(404)
+            self.end_headers()
+
+    def do_OPTIONS(self):
+        # Handle CORS preflight options request from browser extension
+        self.send_response(200)
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.send_header("Access-Control-Allow-Methods", "POST, GET, OPTIONS")
+        self.send_header("Access-Control-Allow-Headers", "Content-Type")
+        self.end_headers()
+
+def start_server(port=18944, download_callback=None):
+    """Starts the local HTTP server in a blocking loop with a sequential download queue worker."""
+    global _download_callback
+    _download_callback = download_callback
+    
+    # Start the sequential queue worker thread
+    worker = threading.Thread(target=_queue_worker, daemon=True)
+    worker.start()
+    
+    server = HTTPServer(("localhost", port), IDMRequestHandler)
+    server.serve_forever()

{idm_cli-0.2.3 → idm_cli-0.2.4}/idm_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: idm-cli
-Version: 0.2.3
+Version: 0.2.4
 Requires-Dist: typer[all]>=0.9.0
 Requires-Dist: httpx>=0.24.0
 Requires-Dist: rich>=13.0.0

{idm_cli-0.2.3 → idm_cli-0.2.4}/idm_cli.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ idm_cli/__init__.py
 idm_cli/cli.py
 idm_cli/downloader.py
 idm_cli/extractor.py
+idm_cli/server.py
 idm_cli/state.py
 idm_cli/ui.py
 idm_cli/updater.py

{idm_cli-0.2.3 → idm_cli-0.2.4}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="idm-cli",
-    version="0.2.3",
+    version="0.2.4",
     packages=find_packages(),
     install_requires=[
         "typer[all]>=0.9.0",

idm_cli-0.2.3/idm_cli/__init__.py

@@ -1,2 +0,0 @@
-# idm_cli Package
-__version__ = "0.2.3"