idm-cli 0.0.1__py3-none-any.whl

idm_cli/__init__.py

@@ -0,0 +1 @@
+# IDM-CLI Package

idm_cli/cli.py

@@ -0,0 +1,522 @@
+import asyncio
+import os
+import sys
+import time
+import uuid
+import typer
+import signal
+import shlex
+import argparse
+from typing import Optional
+from rich.console import Console
+from rich.progress import (
+    Progress,
+    SpinnerColumn,
+    BarColumn,
+    TextColumn,
+    TimeElapsedColumn,
+    TimeRemainingColumn,
+    DownloadColumn,
+    TransferSpeedColumn
+)
+import pyfiglet
+import questionary
+from prompt_toolkit.lexers import Lexer
+
+try:
+    import msvcrt
+except ImportError:
+    msvcrt = None
+
+from idm_cli.extractors import get_extractor
+from idm_cli.downloader import download_file
+from idm_cli.muxer import mux_audio_video, convert_to_mp3
+from idm_cli.state import save_download, remove_download, get_incomplete_downloads
+
+custom_style = questionary.Style([
+    ('qmark', 'fg:cyan bold'),       
+    ('question', 'bold'),               
+    ('answer', 'fg:cyan bold'),      
+    ('pointer', 'fg:cyan bold'),     
+    ('highlighted', 'fg:cyan bold'), 
+    ('flags', 'fg:white'),
+])
+
+class IDMLexer(Lexer):
+    def lex_document(self, document):
+        def get_line(lineno):
+            line = document.lines[lineno]
+            idx = line.find(" -")
+            if idx != -1:
+                return [('class:answer', line[:idx]), ('class:flags', line[idx:])]
+            return [('class:answer', line)]
+        return get_line
+
+app = typer.Typer(help="IDM-CLI: A lightning-fast YouTube downloader.")
+console = Console()
+
+async def progress_listener(queue: asyncio.Queue, progress: Progress, pause_event: asyncio.Event = None, warning_state: dict = None):
+    """Listens for progress updates from the downloader and updates the Rich progress bar."""
+    while True:
+        if warning_state and warning_state.get("show"):
+            for task in progress.tasks:
+                if "[WARNING: Press Ctrl+C again to cancel]" not in task.description:
+                    progress.update(task.id, description=f"[bold yellow][WARNING: Press Ctrl+C again to cancel][/] {task.description}")
+            warning_state["show"] = False
+
+        if pause_event and msvcrt:
+            if msvcrt.kbhit():
+                key = msvcrt.getch().decode('utf-8', 'ignore').lower()
+                if key == 'p' and pause_event.is_set():
+                    pause_event.clear()
+                    for task in progress.tasks:
+                        if "Paused" not in task.description:
+                            progress.update(task.id, description=f"[bold yellow]Paused[/] {task.description}")
+                elif key == 'r' and not pause_event.is_set():
+                    pause_event.set()
+                    for task in progress.tasks:
+                        if "Paused" in task.description:
+                            new_desc = task.description.replace("[bold yellow]Paused[/] ", "")
+                            progress.update(task.id, description=new_desc)
+        
+        try:
+            update = await asyncio.wait_for(queue.get(), timeout=0.1)
+        except asyncio.TimeoutError:
+            continue
+            
+        if update is None:
+            break  # Signal to stop
+        
+        task_id = update.get('task_id')
+        if 'total_size' in update:
+            progress.update(task_id, total=update['total_size'])
+        elif 'bytes_downloaded' in update:
+            progress.advance(task_id, advance=update['bytes_downloaded'])
+            
+        queue.task_done()
+
+async def download_media(video_url: str, audio_url: str, headers: dict, chunks: int, video_dest: str, audio_dest: str, pause_event: asyncio.Event, warning_state: dict = None):
+    queue = asyncio.Queue()
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[bold blue]{task.description}", justify="right"),
+        BarColumn(bar_width=40),
+        "[progress.percentage]{task.percentage:>3.1f}%",
+        DownloadColumn(),
+        TransferSpeedColumn(),
+        TimeRemainingColumn(),
+        console=console
+    ) as progress:
+        video_task_id = progress.add_task("[cyan]Video", total=None) if video_url else None
+        audio_task_id = progress.add_task("[magenta]Audio", total=None) if audio_url else None
+
+        listener = asyncio.create_task(progress_listener(queue, progress, pause_event, warning_state))
+
+        v_task = asyncio.create_task(download_file(video_url, video_dest, headers, chunks, queue, video_task_id, pause_event)) if video_url else None
+        a_task = asyncio.create_task(download_file(audio_url, audio_dest, headers, chunks, queue, audio_task_id, pause_event)) if audio_url else None
+
+        tasks_to_gather = []
+        if a_task:
+            tasks_to_gather.append(a_task)
+        if v_task:
+            tasks_to_gather.append(v_task)
+
+        await asyncio.gather(*tasks_to_gather)
+
+        await queue.put(None)
+        await listener
+
+@app.command()
+def download(
+    url: Optional[str] = typer.Argument(None, help="The Video URL to download."),
+    chunks: int = typer.Option(8, "--chunks", "-c", help="Number of concurrent chunks per file."),
+    quality: Optional[str] = typer.Option(None, "--quality", "-q", help="Video quality (e.g., 720p, 1080p)."),
+    audio_only: bool = typer.Option(False, "--audio-only", "-a", help="Download audio only."),
+    video_only: bool = typer.Option(False, "--video", "-v", help="Download video + audio (bypasses prompt)."),
+    queue: bool = typer.Option(False, "--queue", "-Q", help="Add to queue instead of downloading immediately.")
+):
+    """
+    Download a YouTube video at maximum speed using parallel chunks.
+    """
+    banner = pyfiglet.figlet_format("IDM  CLI")
+    console.print(f"[bold green]{banner}[/bold green]")
+    console.print("[bold cyan]--- The Ultimate High-Speed CLI Downloader ---[/bold cyan]")
+    console.print("Type 'help' for available commands\n", style="white")
+    
+    is_interactive = (url is None)
+    last_ctrl_c_time = 0
+    show_warning = False
+    
+    while True:
+        loop_quality = quality
+        loop_audio_only = audio_only
+        loop_video_only = video_only
+        loop_queue = queue
+        loop_chunks = chunks
+
+        current_url = url
+        if not current_url:
+            prompt_str = "idm (Press again ctrl+c to exit) " if show_warning else "idm "
+            current_url = questionary.text(prompt_str, style=custom_style, lexer=IDMLexer()).ask(kbi_msg="")
+            if current_url is None:
+                if time.time() - last_ctrl_c_time <= 5:
+                    console.print("[bold red]Cancelled by user[/bold red]")
+                    raise typer.Exit()
+                else:
+                    last_ctrl_c_time = time.time()
+                    show_warning = True
+                    continue
+            elif not current_url.strip():
+                continue
+        
+        last_ctrl_c_time = 0
+        show_warning = False
+        found_task_id = None
+
+        if is_interactive and current_url and current_url.strip().lower() not in ["help", "exit", "start queue", "queue start", "resume"]:
+            try:
+                parts = shlex.split(current_url)
+                parser = argparse.ArgumentParser(add_help=False)
+                parser.add_argument('-q', '--quality')
+                parser.add_argument('-a', '--audio-only', action='store_true')
+                parser.add_argument('-v', '--video', action='store_true')
+                parser.add_argument('-Q', '--queue', action='store_true')
+                parser.add_argument('-c', '--chunks', type=int)
+                
+                parsed_args, unknown = parser.parse_known_args(parts)
+                loop_quality = parsed_args.quality or loop_quality
+                loop_audio_only = parsed_args.audio_only or loop_audio_only
+                loop_video_only = parsed_args.video or loop_video_only
+                loop_queue = parsed_args.queue or loop_queue
+                loop_chunks = parsed_args.chunks or loop_chunks
+                
+                urls = [u for u in unknown if not u.startswith('-')]
+                if urls:
+                    current_url = urls[0]
+            except Exception:
+                pass
+
+        fast_mode = not is_interactive or loop_quality or loop_audio_only or loop_video_only or loop_queue
+        if fast_mode and not loop_quality and not loop_audio_only:
+            loop_quality = "720p"
+
+        if current_url.strip().lower() == "help":
+            console.print("\n[bold cyan]Available Commands:[/bold cyan]")
+            console.print("  [bold green]<URL>[/bold green]    - Paste a YouTube URL to download")
+            console.print("  [bold green]resume[/bold green] - Resume or delete an incomplete download")
+            console.print("  [bold green]start queue[/bold green] - Start downloading queued videos")
+            console.print("  [bold green]help[/bold green]   - Show this help menu")
+            console.print("  [bold green]exit[/bold green]   - Exit the application\n")
+            continue
+            
+        if current_url.strip().lower() == "exit":
+            console.print("[bold green]Goodbye![/bold green]")
+            raise typer.Exit()
+
+        if current_url.strip().lower() in ["start queue", "queue start"]:
+            incomplete = get_incomplete_downloads()
+            queued = {tid: data for tid, data in incomplete.items() if data.get("status") == "queued"}
+            if not queued:
+                console.print("[bold green]No videos in queue![/]")
+                if not is_interactive:
+                    raise typer.Exit(code=0)
+                continue
+                
+            for tid, data in queued.items():
+                console.print(f"[bold yellow]Starting queued download:[/] {data['title']}\n")
+                url_to_extract = data['url']
+                format_id = data['format_id']
+                video_dest = data['video_dest']
+                audio_dest = data['audio_dest']
+                final_dest = data['final_dest']
+                title = data['title']
+                
+                with console.status("[bold cyan]Fetching metadata...", spinner="dots"):
+                    try:
+                        extractor = get_extractor(url_to_extract)
+                        info = extractor.fetch_all_info(url_to_extract)
+                    except Exception as e:
+                        console.print(f"[bold red]Error fetching info:[/] {e}")
+                        continue
+                
+                with console.status(f"[bold cyan]Extracting URLs...", spinner="dots"):
+                    try:
+                        extractor = get_extractor(url_to_extract)
+                        extracted = extractor.extract_urls(info, format_id)
+                        video_url = extracted.get("video_url")
+                        audio_url = extracted.get("audio_url")
+                        headers = extracted.get("headers", {})
+                        if not video_url: video_dest = ""
+                        if not audio_url: audio_dest = ""
+                    except Exception as e:
+                        console.print(f"[bold red]Error extracting URLs:[/] {e}")
+                        continue
+
+                pause_event = asyncio.Event()
+                pause_event.set()
+                warning_state = {"show": False}
+                
+                try:
+                    asyncio.run(download_media(video_url, audio_url, headers, loop_chunks, video_dest, audio_dest, pause_event, warning_state))
+                    with console.status("[bold magenta]Running FFmpeg...", spinner="bouncingBar"):
+                        if video_dest and audio_dest:
+                            mux_audio_video(video_dest, audio_dest, final_dest)
+                        elif audio_dest and not video_dest:
+                            convert_to_mp3(audio_dest, final_dest)
+                        elif video_dest and not audio_dest:
+                            import shutil
+                            shutil.move(video_dest, final_dest)
+                    remove_download(tid)
+                    console.print(f"\n[bold green]🎉 Success! Video saved as:[/] [bold white]{final_dest}[/]")
+                except KeyboardInterrupt:
+                    break
+                except Exception as e:
+                    console.print(f"[bold red]Download failed:[/] {e}")
+            if not is_interactive:
+                raise typer.Exit(code=0)
+            continue
+                
+        if current_url.strip().lower() == "resume":
+            incomplete = get_incomplete_downloads()
+            if not incomplete:
+                console.print("[bold green]No incomplete downloads found![/]")
+                if not is_interactive:
+                    raise typer.Exit(code=1)
+                continue
+                
+            choices = []
+            for tid, data in incomplete.items():
+                choices.append(f"[Resume] {data['title']}")
+                choices.append(f"[Delete] {data['title']}")
+            choices.append("[Back to Main]")
+                
+            selected = questionary.select("Select an action:", choices=choices, style=custom_style).ask(kbi_msg="")
+            if not selected:
+                console.print("[bold red]Cancelled by user[/bold red]")
+                if not is_interactive:
+                    raise typer.Exit(code=1)
+                continue
+                
+            if selected == "[Back to Main]":
+                console.print("[bold cyan]Returning to main menu...[/bold cyan]")
+                continue
+                
+            action = "Resume" if selected.startswith("[Resume]") else "Delete"
+            title_selected = selected.split("] ", 1)[1]
+            
+            task_id = None
+            task_data = None
+            for tid, data in incomplete.items():
+                if data['title'] == title_selected:
+                    task_id = tid
+                    task_data = data
+                    break
+                    
+            if action == "Delete":
+                remove_download(task_id)
+                # Remove any partial files if they exist
+                if os.path.exists(task_data['video_dest']): os.remove(task_data['video_dest'])
+                if os.path.exists(task_data['audio_dest']): os.remove(task_data['audio_dest'])
+                for i in range(32): # Clean parts up to 32 chunks
+                    v_part = f"{task_data['video_dest']}.part{i}"
+                    a_part = f"{task_data['audio_dest']}.part{i}"
+                    if os.path.exists(v_part): os.remove(v_part)
+                    if os.path.exists(a_part): os.remove(a_part)
+                console.print(f"[bold red]Deleted:[/] {title_selected}")
+                if not is_interactive:
+                    raise typer.Exit(code=0)
+                continue
+                
+            console.print(f"[bold yellow]Resuming download for:[/] {title_selected}\n")
+            url_to_extract = task_data['url']
+            format_id = task_data['format_id']
+            video_dest = task_data['video_dest']
+            audio_dest = task_data['audio_dest']
+            final_dest = task_data['final_dest']
+            title = task_data['title']
+            found_task_id = task_id
+        else:
+            url_to_extract = current_url
+            incomplete = get_incomplete_downloads()
+            
+            found_task_data = None
+            
+            for tid, data in incomplete.items():
+                if data.get('url') == url_to_extract:
+                    found_task_id = tid
+                    found_task_data = data
+                    break
+                    
+            if found_task_id:
+                console.print("[bold yellow]Found in resume list! Auto-resuming...[/]")
+                task_id = found_task_id
+                format_id = found_task_data['format_id']
+                video_dest = found_task_data['video_dest']
+                audio_dest = found_task_data['audio_dest']
+                final_dest = found_task_data['final_dest']
+                title = found_task_data['title']
+            else:
+                format_id = None
+                task_id = str(uuid.uuid4())
+                console.print(f"[bold yellow]Initializing download for:[/] {current_url}\n")
+                
+                if loop_audio_only:
+                    format_id = "audio_only"
+
+        with console.status("[bold cyan]Fetching metadata...", spinner="dots"):
+            try:
+                extractor = get_extractor(url_to_extract)
+                info = extractor.fetch_all_info(url_to_extract)
+                title = info.get("title", "download") if not found_task_id else title
+                if not found_task_id and format_id != "audio_only":
+                    resolutions = extractor.get_video_resolutions(info)
+            except Exception as e:
+                console.print(f"[bold red]Error fetching info:[/] {e}")
+                if not is_interactive:
+                    raise typer.Exit(code=1)
+                continue
+
+        if not found_task_id:
+            if format_id != "audio_only":
+                if not resolutions:
+                    console.print("[bold red]No video resolutions found.[/]")
+                    if not is_interactive:
+                        raise typer.Exit(code=1)
+                    continue
+
+                console.print(f"[bold green]✓[/] Fetched info for: [bold white]{title}[/]")
+                
+                if loop_quality:
+                    matched = next((r for r in resolutions if r['resolution'] == loop_quality), None)
+                    if matched:
+                        selected_res = matched['resolution']
+                    else:
+                        selected_res = resolutions[0]['resolution']
+                else:
+                    choices = [r['resolution'] for r in resolutions]
+                    selected_res = questionary.select("Choose video quality:", choices=choices, style=custom_style).ask(kbi_msg="")
+                    if not selected_res:
+                        console.print("[bold red]Cancelled by user[/bold red]")
+                        if not is_interactive:
+                            raise typer.Exit(code=1)
+                        continue
+
+                selected_format = next(r for r in resolutions if r['resolution'] == selected_res)
+                format_id = selected_format['format_id']
+            
+            safe_title = "".join([c for c in title if c.isalpha() or c.isdigit() or c in ' -_.']).rstrip()[:60].strip()
+            downloads_dir = os.path.join(os.path.expanduser("~"), "Downloads")
+            os.makedirs(downloads_dir, exist_ok=True)
+            
+            tmp_dir = os.path.expanduser("~/.idm_cli/tmp")
+            os.makedirs(tmp_dir, exist_ok=True)
+            
+            if format_id == "direct_file":
+                video_dest = os.path.join(tmp_dir, safe_title)
+                audio_dest = ""
+                final_dest = os.path.join(downloads_dir, safe_title)
+            elif format_id == "audio_only":
+                video_dest = ""
+                audio_dest = os.path.join(tmp_dir, f"{safe_title}_audio.m4a")
+                final_dest = os.path.join(downloads_dir, f"{safe_title}.mp3")
+            else:
+                video_dest = os.path.join(tmp_dir, f"{safe_title}_video.mp4")
+                audio_dest = os.path.join(tmp_dir, f"{safe_title}_audio.m4a")
+                final_dest = os.path.join(downloads_dir, f"{safe_title}.mp4")
+
+            if loop_queue:
+                action = "Add to Queue"
+            elif fast_mode:
+                action = "Download Now"
+            else:
+                action = questionary.select("Action:", choices=["Download Now", "Add to Queue"], style=custom_style).ask(kbi_msg="")
+            if not action:
+                console.print("[bold red]Cancelled by user[/bold red]")
+                continue
+            if action == "Add to Queue":
+                save_download(task_id, url_to_extract, format_id, title, video_dest, audio_dest, final_dest, status="queued")
+                console.print("[bold green]Added to queue![/]")
+                if not is_interactive:
+                    raise typer.Exit(code=0)
+                continue
+
+        with console.status(f"[bold cyan]Extracting URLs...", spinner="dots"):
+            try:
+                extractor = get_extractor(url_to_extract)
+                extracted = extractor.extract_urls(info, format_id)
+                video_url = extracted.get("video_url")
+                audio_url = extracted.get("audio_url")
+                headers = extracted.get("headers", {})
+                if not video_url: video_dest = ""
+                if not audio_url: audio_dest = ""
+            except Exception as e:
+                console.print(f"[bold red]Error extracting URLs:[/] {e}")
+                if not is_interactive:
+                    raise typer.Exit(code=1)
+                continue
+
+        # Save state before downloading
+        save_download(task_id, url_to_extract, format_id, title, video_dest, audio_dest, final_dest, status="interrupted")
+        
+        console.print(f"[bold green]✓[/] Using {loop_chunks} chunks per file.")
+        console.print("[bold cyan]Starting parallel downloads... (Press 'p' to pause, 'r' to resume)[/]\n")
+
+        pause_event = asyncio.Event()
+        pause_event.set()
+
+        last_dl_ctrl_c = 0.0
+        original_sigint = signal.getsignal(signal.SIGINT)
+        warning_state = {"show": False}
+
+        def custom_handler(signum, frame):
+            nonlocal last_dl_ctrl_c
+            if time.time() - last_dl_ctrl_c <= 5:
+                signal.signal(signal.SIGINT, original_sigint)
+                os.kill(os.getpid(), signal.SIGINT)
+            else:
+                warning_state["show"] = True
+                last_dl_ctrl_c = time.time()
+
+        signal.signal(signal.SIGINT, custom_handler)
+
+        try:
+            asyncio.run(download_media(video_url, audio_url, headers, loop_chunks, video_dest, audio_dest, pause_event, warning_state))
+        except KeyboardInterrupt:
+            console.print("\n[bold red]Download cancelled by user. Progress saved to resume later.[/bold red]")
+            continue
+        except Exception as e:
+            console.print(f"[bold red]Download failed:[/] {e}")
+            if not is_interactive:
+                raise typer.Exit(code=1)
+            continue
+        finally:
+            signal.signal(signal.SIGINT, original_sigint)
+
+        console.print("\n[bold green]✓[/] Downloads completed.")
+        console.print("[bold cyan]Muxing audio and video streams...[/]")
+
+        with console.status("[bold magenta]Running FFmpeg...", spinner="bouncingBar"):
+            try:
+                if video_dest and audio_dest:
+                    mux_audio_video(video_dest, audio_dest, final_dest)
+                elif audio_dest and not video_dest:
+                    convert_to_mp3(audio_dest, final_dest)
+                elif video_dest and not audio_dest:
+                    import shutil
+                    shutil.move(video_dest, final_dest)
+            except Exception as e:
+                console.print(f"[bold red]Muxing failed:[/] {e}")
+                if not is_interactive:
+                    raise typer.Exit(code=1)
+                continue
+
+        remove_download(task_id)
+        console.print(f"\n[bold green]🎉 Success! Video saved as:[/] [bold white]{final_dest}[/]")
+        
+        if not is_interactive:
+            raise typer.Exit(code=0)
+        url = None
+
+if __name__ == "__main__":
+    app()

idm_cli/downloader.py

@@ -0,0 +1,145 @@
+import asyncio
+import os
+import aiohttp
+import aiofiles
+
+async def _download_chunk(session: aiohttp.ClientSession, url: str, start: int, end: int, chunk_index: int, dest_path: str, headers: dict, progress_queue: asyncio.Queue, task_id, pause_event: asyncio.Event = None):
+    chunk_path = f"{dest_path}.part{chunk_index}"
+    max_retries = 5
+    retry_count = 0
+    
+    while retry_count < max_retries:
+        try:
+            # Determine how much of this chunk has already been downloaded (from prior failed attempts)
+            existing_size = 0
+            if os.path.exists(chunk_path):
+                existing_size = os.path.getsize(chunk_path)
+                
+            current_start = start + existing_size
+            
+            # If we've already downloaded this entire chunk, return immediately
+            if end is not None and current_start > end:
+                return chunk_path
+                
+            chunk_headers = headers.copy() if headers else {}
+            if end is None:
+                chunk_headers['Range'] = f'bytes={current_start}-'
+            else:
+                chunk_headers['Range'] = f'bytes={current_start}-{end}'
+            
+            async with session.get(url, headers=chunk_headers) as response:
+                response.raise_for_status()
+                # Use append mode ('ab') to resume writing if we already have data, avoiding overwrite
+                mode = 'ab' if existing_size > 0 else 'wb'
+                async with aiofiles.open(chunk_path, mode) as f:
+                    async for chunk in response.content.iter_chunked(1024 * 1024):
+                        if pause_event is not None:
+                            await pause_event.wait()
+                        if not chunk:
+                            break
+                        await f.write(chunk)
+                        if progress_queue is not None and task_id is not None:
+                            # IMPORTANT BUG PREVENTION: 
+                            # We ONLY report the newly downloaded bytes for this specific iteration.
+                            # We DO NOT report `existing_size` because those bytes were already sent 
+                            # to the progress queue during a previous attempt. 
+                            # Using `progress.advance()` in main.py accumulates these safely, 
+                            # preventing the progress bar from jumping, resetting, or duplicating.
+                            await progress_queue.put({
+                                'task_id': task_id,
+                                'chunk_index': chunk_index,
+                                'bytes_downloaded': len(chunk)
+                            })
+            return chunk_path
+        except (aiohttp.client_exceptions.ClientPayloadError, asyncio.TimeoutError, aiohttp.client_exceptions.ClientError) as e:
+            retry_count += 1
+            if retry_count >= max_retries:
+                raise Exception(f"Chunk {chunk_index} failed after {max_retries} retries: {e}")
+            await asyncio.sleep(2 ** retry_count)
+
+async def download_file(url: str, dest_path: str, headers: dict, num_chunks: int = 8, progress_queue: asyncio.Queue = None, task_id = None, pause_event: asyncio.Event = None):
+    """
+    Downloads a file in multiple chunks concurrently using aiohttp and aiofiles.
+    """
+    if os.path.exists(dest_path):
+        file_size = os.path.getsize(dest_path)
+        if progress_queue is not None and task_id is not None:
+            await progress_queue.put({'task_id': task_id, 'total_size': file_size})
+            await progress_queue.put({'task_id': task_id, 'bytes_downloaded': file_size})
+        return
+
+    if headers is None:
+        headers = {}
+        
+    async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=None)) as session:
+        file_size = None
+        
+        try:
+            async with session.head(url, headers=headers, allow_redirects=True) as response:
+                content_length = response.headers.get('Content-Length')
+                if content_length:
+                    file_size = int(content_length)
+        except aiohttp.ClientError:
+            pass
+            
+        if not file_size:
+            try:
+                # Use GET with Range bytes=0-0 to get total length from Content-Range
+                range_headers = headers.copy()
+                range_headers['Range'] = 'bytes=0-0'
+                async with session.get(url, headers=range_headers, allow_redirects=True) as response:
+                    content_range = response.headers.get('Content-Range')
+                    if content_range and '/' in content_range:
+                        file_size = int(content_range.split('/')[-1])
+                    else:
+                        content_length = response.headers.get('Content-Length')
+                        if content_length:
+                            file_size = int(content_length)
+            except aiohttp.ClientError:
+                pass
+                
+        if not file_size:
+            # Fallback to single chunk download
+            chunk_path = await _download_chunk(session, url, 0, None, 0, dest_path, headers, progress_queue, task_id, pause_event)
+            os.rename(chunk_path, dest_path)
+            return
+
+        if progress_queue is not None and task_id is not None:
+            await progress_queue.put({
+                'task_id': task_id,
+                'total_size': file_size
+            })
+            
+            total_existing_size = 0
+            for i in range(num_chunks):
+                chunk_path = f"{dest_path}.part{i}"
+                if os.path.exists(chunk_path):
+                    total_existing_size += os.path.getsize(chunk_path)
+            
+            if total_existing_size > 0:
+                await progress_queue.put({
+                    'task_id': task_id,
+                    'bytes_downloaded': total_existing_size
+                })
+
+        chunk_size = file_size // num_chunks
+        tasks = []
+        for i in range(num_chunks):
+            start = i * chunk_size
+            end = file_size - 1 if i == num_chunks - 1 else (start + chunk_size - 1)
+            tasks.append(
+                _download_chunk(session, url, start, end, i, dest_path, headers, progress_queue, task_id, pause_event)
+            )
+            
+        chunk_paths = await asyncio.gather(*tasks)
+        
+        # Merge chunks
+        async with aiofiles.open(dest_path, 'wb') as out_file:
+            for chunk_path in chunk_paths:
+                async with aiofiles.open(chunk_path, 'rb') as in_file:
+                    while True:
+                        data = await in_file.read(1024 * 1024)
+                        if not data:
+                            break
+                        await out_file.write(data)
+                os.remove(chunk_path)

idm_cli/extractors/__init__.py

@@ -0,0 +1,18 @@
+import importlib
+import urllib.request
+
+def get_extractor(url: str):
+    if "facebook.com" in url or "fb.watch" in url:
+        return importlib.import_module("idm_cli.extractors.facebook")
+    
+    try:
+        req = urllib.request.Request(url, method='HEAD', headers={'User-Agent': 'Mozilla/5.0'})
+        with urllib.request.urlopen(req, timeout=3) as response:
+            content_type = response.headers.get('Content-Type', '')
+            if content_type and 'text/html' not in content_type:
+                return importlib.import_module("idm_cli.extractors.direct")
+    except Exception:
+        pass
+
+    # Default to youtube (handles youtube, twitter, and generic sites mostly)
+    return importlib.import_module("idm_cli.extractors.youtube")

idm_cli/extractors/direct.py

@@ -0,0 +1,19 @@
+def fetch_all_info(url: str) -> dict:
+    """Extracts a filename from the URL and returns info."""
+    filename = url.split('/')[-1].split('?')[0]
+    if not filename:
+        filename = "file_download"
+    return {"title": filename, "url": url}
+
+def get_video_resolutions(info: dict) -> list[dict]:
+    """Returns a dummy resolution for direct files."""
+    return [{"resolution": "Direct File", "format_id": "direct_file"}]
+
+def extract_urls(info: dict, video_format_id: str) -> dict:
+    """Extracts download URLs."""
+    return {
+        "video_url": info.get("url"),
+        "audio_url": None,
+        "headers": {},
+        "title": info.get("title", "download")
+    }

idm_cli/extractors/facebook.py

@@ -0,0 +1,105 @@
+import yt_dlp
+
+def fetch_all_info(url: str) -> dict:
+    """
+    Fetches all video info from a Facebook URL using yt-dlp.
+    """
+    ydl_opts = {
+        'quiet': True,
+        'no_warnings': True,
+    }
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        info = ydl.extract_info(url, download=False)
+        return info
+
+def get_video_resolutions(info: dict) -> list[dict]:
+    """
+    Parses the formats from the info dict and returns a list of available resolutions.
+    """
+    resolutions_dict = {}
+    formats = info.get('formats', [])
+    
+    for fmt in formats:
+        if fmt.get('vcodec') == 'none':
+            continue
+            
+        format_id = str(fmt.get('format_id', ''))
+        height = fmt.get('height')
+        
+        if height:
+            resolution = f"{height}p"
+        else:
+            resolution = format_id.upper() if format_id else 'UNKNOWN'
+            
+        if resolution not in resolutions_dict:
+            resolutions_dict[resolution] = {
+                'resolution': resolution,
+                'format_id': format_id
+            }
+            
+    def parse_res(r):
+        res = r['resolution']
+        if res.endswith('p') and res[:-1].isdigit():
+            return int(res[:-1])
+        if res == 'HD': return 720
+        if res == 'SD': return 480
+        return 0
+        
+    return sorted(list(resolutions_dict.values()), key=parse_res, reverse=True)
+
+def extract_urls(info: dict, video_format_id: str) -> dict:
+    """
+    Given the info dict and a selected video format ID, returns the video URL,
+    audio URL (if not pre-muxed), headers, and title.
+    """
+    formats = info.get('formats', [])
+    
+    video_url = None
+    audio_url = None
+    headers = {}
+    
+    if video_format_id != "audio_only":
+        for fmt in formats:
+            if str(fmt.get('format_id')) == str(video_format_id):
+                video_url = fmt.get('url')
+                headers = fmt.get('http_headers', {})
+                
+                is_premuxed = (fmt.get('acodec') != 'none')
+                if is_premuxed:
+                    audio_url = None
+                else:
+                    # Find the best audio-only stream
+                    best_audio = None
+                    for a_fmt in formats:
+                        if a_fmt.get('vcodec') == 'none' and a_fmt.get('acodec') != 'none':
+                            if not best_audio or (a_fmt.get('abr') or 0) > (best_audio.get('abr') or 0):
+                                best_audio = a_fmt
+                    if best_audio:
+                        audio_url = best_audio.get('url')
+                break
+
+    if video_format_id == "audio_only":
+        best_audio = None
+        # First try to find pure audio stream
+        for a_fmt in formats:
+            if a_fmt.get('vcodec') == 'none' and a_fmt.get('acodec') != 'none':
+                if not best_audio or (a_fmt.get('abr') or 0) > (best_audio.get('abr') or 0):
+                    best_audio = a_fmt
+                    
+        # If no pure audio stream exists, grab the smallest pre-muxed video to extract audio from
+        if not best_audio:
+            premuxed = [f for f in formats if f.get('acodec') != 'none' and f.get('vcodec') != 'none']
+            if premuxed:
+                premuxed.sort(key=lambda x: (x.get('height') or 9999, x.get('tbr') or 9999))
+                best_audio = premuxed[0]
+                
+        if best_audio:
+            audio_url = best_audio.get('url')
+            headers = best_audio.get('http_headers', {})
+
+    return {
+        'video_url': video_url,
+        'audio_url': audio_url,
+        'headers': headers,
+        'title': info.get('title', 'Facebook Video')
+    }

idm_cli/extractors/youtube.py

@@ -0,0 +1,112 @@
+def fetch_all_info(url: str) -> dict:
+    """
+    Extracts all info without downloading, without strict format filtering.
+    """
+    import yt_dlp
+    ydl_opts = {
+        'noplaylist': True,
+        'quiet': True,
+        'extractor_args': {'youtube': ['player_client=android,ios']},
+    }
+    try:
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            return ydl.extract_info(url, download=False)
+    except Exception as e:
+        error_msg = str(e).lower()
+        if 'bot' in error_msg or 'cookie' in error_msg:
+            # Bypass 1: Use alternative player clients (Android, iOS, TV)
+            clients_to_try = ['android', 'ios', 'tv']
+            for client in clients_to_try:
+                ydl_opts['extractor_args'] = {'youtube': [f'player_client={client}']}
+                try:
+                    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                        return ydl.extract_info(url, download=False)
+                except Exception:
+                    continue
+                    
+            # Bypass 2: Local Browser Cookies
+            if 'extractor_args' in ydl_opts:
+                del ydl_opts['extractor_args']
+                
+            for browser in ['chrome', 'edge', 'firefox', 'brave', 'opera']:
+                ydl_opts['cookiesfrombrowser'] = (browser,)
+                try:
+                    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                        return ydl.extract_info(url, download=False)
+                except Exception:
+                    continue
+                    
+            raise Exception("YouTube bot protection blocked the request and bypass failed. Ensure your browser (Chrome/Edge) is FULLY CLOSED so cookies can be read, then try again.") from e
+        raise
+
+def get_video_resolutions(info: dict) -> list[dict]:
+    """
+    Parse formats from info, filter out audio-only streams,
+    group/deduplicate by resolution (e.g. '1080p', '720p'),
+    and return list of dicts with 'resolution' and 'format_id', sorted highest to lowest.
+    """
+    formats = info.get('formats', [])
+    resolutions = {}
+    
+    for fmt in formats:
+        # filter out audio-only streams
+        if fmt.get('vcodec') == 'none':
+            continue
+            
+        height = fmt.get('height')
+        if not height:
+            continue
+            
+        res_str = f"{height}p"
+        fmt_id = fmt.get('format_id')
+        
+        # Keep track of resolutions we've seen.
+        if height not in resolutions:
+            resolutions[height] = {
+                'resolution': res_str,
+                'format_id': fmt_id
+            }
+            
+    # Sort by height descending
+    sorted_heights = sorted(resolutions.keys(), reverse=True)
+    return [resolutions[h] for h in sorted_heights]
+
+def extract_urls(info: dict, video_format_id: str) -> dict:
+    """
+    Find specific video format URL using video_format_id.
+    Find best audio format URL (vcodec == 'none' and acodec != 'none').
+    Extract http_headers and title.
+    """
+    title = info.get('title', 'Unknown Title')
+    headers = info.get('http_headers', {}).copy()
+    
+    formats = info.get('formats', [])
+    video_url = None
+    audio_url = None
+    
+    # Find video
+    if video_format_id != "audio_only":
+        for fmt in formats:
+            if str(fmt.get('format_id')) == str(video_format_id):
+                video_url = fmt.get('url')
+                if fmt.get('http_headers'):
+                    headers.update(fmt.get('http_headers'))
+                break
+            
+    # Find best audio (yt-dlp normally sorts formats from worst to best overall, 
+    # but let's just find the last one that is audio-only, or sort by abr)
+    audio_formats = [f for f in formats if f.get('vcodec') == 'none' and f.get('acodec') != 'none']
+    if audio_formats:
+        # Sort by audio bitrate if available
+        audio_formats.sort(key=lambda x: x.get('abr', 0) or 0)
+        best_audio = audio_formats[-1]
+        audio_url = best_audio.get('url')
+        if best_audio.get('http_headers'):
+            headers.update(best_audio.get('http_headers'))
+            
+    return {
+        'video_url': video_url,
+        'audio_url': audio_url,
+        'headers': headers,
+        'title': title
+    }

idm_cli/muxer.py

@@ -0,0 +1,71 @@
+import os
+import subprocess
+import logging
+
+logger = logging.getLogger(__name__)
+
+def mux_audio_video(video_path: str, audio_path: str, output_path: str) -> None:
+    """
+    Muxes a video and audio file together into a single output file using ffmpeg.
+    Copies the streams without re-encoding.
+    Deletes the original video and audio files upon successful muxing.
+    """
+    if not os.path.exists(video_path):
+        raise FileNotFoundError(f"Video file not found: {video_path}")
+    if not os.path.exists(audio_path):
+        raise FileNotFoundError(f"Audio file not found: {audio_path}")
+
+    cmd = [
+        "ffmpeg",
+        "-y",  # Overwrite output file if it exists
+        "-i", video_path,
+        "-i", audio_path,
+        "-c", "copy",
+        output_path
+    ]
+
+    try:
+        logger.info(f"Muxing {video_path} and {audio_path} into {output_path}")
+        subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        
+        logger.info("Muxing successful. Deleting original files.")
+        try:
+            os.remove(video_path)
+            os.remove(audio_path)
+        except OSError as e:
+            logger.warning(f"Failed to delete original files: {e}")
+            
+    except subprocess.CalledProcessError as e:
+        logger.error(f"FFmpeg muxing failed: {e.stderr.decode('utf-8', errors='replace')}")
+        raise RuntimeError(f"FFmpeg muxing failed: {e}")
+
+def convert_to_mp3(audio_path: str, output_path: str) -> None:
+    """
+    Converts an audio file to mp3 using ffmpeg.
+    Deletes the original audio file upon success.
+    """
+    if not os.path.exists(audio_path):
+        raise FileNotFoundError(f"Audio file not found: {audio_path}")
+
+    cmd = [
+        "ffmpeg",
+        "-y",
+        "-i", audio_path,
+        "-q:a", "0",
+        "-map", "a",
+        output_path
+    ]
+
+    try:
+        logger.info(f"Converting {audio_path} into {output_path}")
+        subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        
+        logger.info("Conversion successful. Deleting original file.")
+        try:
+            os.remove(audio_path)
+        except OSError as e:
+            logger.warning(f"Failed to delete original file: {e}")
+            
+    except subprocess.CalledProcessError as e:
+        logger.error(f"FFmpeg conversion failed: {e.stderr.decode('utf-8', errors='replace')}")
+        raise RuntimeError(f"FFmpeg conversion failed: {e}")

idm_cli/state.py

@@ -0,0 +1,59 @@
+import json
+import os
+import tempfile
+
+STATE_DIR = os.path.expanduser("~/.idm_cli")
+STATE_FILE = os.path.join(STATE_DIR, "state.json")
+
+def _ensure_dir():
+    if not os.path.exists(STATE_DIR):
+        os.makedirs(STATE_DIR, exist_ok=True)
+
+def get_incomplete_downloads() -> dict:
+    """Returns the parsed JSON of incomplete downloads."""
+    if not os.path.exists(STATE_FILE):
+        return {}
+    
+    try:
+        with open(STATE_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError):
+        return {}
+
+def _write_state(state: dict):
+    """Writes the state to the JSON file atomically."""
+    _ensure_dir()
+    # Write atomically using a temporary file in the same directory
+    fd, temp_path = tempfile.mkstemp(dir=STATE_DIR, prefix="state_", suffix=".json")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            json.dump(state, f, indent=4)
+        
+        # Atomically replace the target file
+        os.replace(temp_path, STATE_FILE)
+    except Exception:
+        # Clean up temp file on error
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
+        raise
+
+def save_download(task_id: str, url: str, format_id: str, title: str, video_dest: str, audio_dest: str, final_dest: str, status: str = "interrupted"):
+    """Adds or updates a download in the JSON."""
+    state = get_incomplete_downloads()
+    state[task_id] = {
+        "url": url,
+        "format_id": format_id,
+        "title": title,
+        "video_dest": video_dest,
+        "audio_dest": audio_dest,
+        "final_dest": final_dest,
+        "status": status
+    }
+    _write_state(state)
+
+def remove_download(task_id: str):
+    """Removes the entry from JSON upon completion."""
+    state = get_incomplete_downloads()
+    if task_id in state:
+        del state[task_id]
+        _write_state(state)

idm_cli-0.0.1.dist-info/METADATA

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: idm-cli
+Version: 0.0.1
+Summary: A lightning-fast, universal command-line download manager
+Home-page: https://github.com/rj41-w2/idm-cli
+Author: Rehan
+Author-email: rehanjamilwattoo@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer
+Requires-Dist: rich
+Requires-Dist: aiohttp
+Requires-Dist: aiofiles
+Requires-Dist: yt-dlp
+Requires-Dist: pyfiglet
+Requires-Dist: questionary
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# IDM-CLI (Internet Download Manager CLI)
+
+A lightning-fast, powerful, and universal command-line download manager written in Python. IDM-CLI splits files into multiple parallel chunks (default 8, up to 32) to maximize your internet speed. It seamlessly supports downloading from **YouTube**, **Facebook**, and any **Direct File URL** (`.exe`, `.zip`, `.pdf`, etc.).
+
+## 🚀 Features
+
+- **Blazing Fast Speeds:** Splits downloads into multiple parallel chunks (like traditional IDM) to fully saturate your bandwidth.
+- **Universal Downloader:** Paste any direct URL (e.g., a `.pdf` or `.exe`). The built-in smart HTTP `HEAD` detector automatically recognizes file types and routes them to the parallel engine.
+- **Social Media Support:** Natively supports downloading from **YouTube** and **Facebook** via a modular extractor architecture. Auto-detects pre-muxed (SD/HD) vs separated streams.
+- **Audio Only / MP3 Conversion:** Easily download videos as audio. IDM-CLI automatically grabs the best audio stream and uses `ffmpeg` to perfectly convert it to `.mp3`.
+- **Smart Auto-Resume:** Internet dropped? Pressed `Ctrl+C`? No problem! IDM-CLI remembers the exact byte positions of all incomplete chunks. Paste the same link again to resume instantly.
+- **Persistent Queue System (`-Q`):** Add multiple files or videos to a queue and type `start queue` to automatically download all of them sequentially in the background.
+- **Pristine Downloads Folder:** All temporary chunks and raw media files are kept hidden in `~/.idm_cli/tmp/`. Only the fully assembled, 100% complete files are moved to your `~/Downloads` folder.
+- **Interactive UI:** A beautiful, responsive terminal interface powered by `rich` and `questionary` with real-time speed, ETA, and progress bars.
+- **Pause & Play:** Press `p` to pause the active downloads without losing progress, and `r` to resume them.
+
+## 🛠️ Prerequisites
+
+- **Python 3.8+**
+- **FFmpeg:** Required for muxing video and audio streams, and converting media to `.mp3`. Ensure `ffmpeg` is installed and added to your system's PATH.
+
+## 📦 Installation
+
+Clone the repository and install the required dependencies:
+
+```bash
+git clone https://github.com/rj41-w2/idm-cli.git
+cd IDM-CLI
+pip install -r requirements.txt
+```
+
+*(Note: If you plan to publish this to PyPI, users will simply be able to run `pip install idm-cli`)*
+
+## 💻 Usage
+
+Run the app interactively by simply typing:
+```bash
+idm
+```
+This will open a prompt where you can paste your link, select video resolutions, or choose to queue the download.
+
+### CLI Flags (Fast Mode)
+
+Skip the interactive menus by passing arguments directly!
+
+```bash
+# Download a video with auto-selected 1080p quality
+idm "https://youtube.com/watch?v=..." -q 1080p -v
+
+# Download Audio Only (converts to MP3)
+idm "https://youtube.com/watch?v=..." -a
+
+# Use 16 parallel chunks for maximum speed (default is 8)
+idm "https://example.com/largefile.zip" -c 16
+
+# Add a video to the Queue without downloading it right now
+idm "https://facebook.com/..." -Q
+```
+
+### Queue Management
+
+To start downloading all items currently in your queue, simply type:
+```bash
+idm start queue
+```
+*(You can also just type `start queue` into the interactive `idm` prompt!)*
+
+## ⚙️ Architecture Highlights
+
+- **`downloader.py`:** The core asynchronous engine handling `aiohttp` range requests, chunk merging, and resume states.
+- **`cli.py`:** The interactive orchestration layer utilizing `typer`, `rich`, and `questionary`.
+- **`muxer.py`:** Safe abstraction over `subprocess` calls to `ffmpeg` for media stream merging.
+- **`extractors/`:** Modular plugins (`youtube.py`, `facebook.py`, `direct.py`) for handling specialized metadata retrieval.
+
+## 📄 License
+
+This project is open-source and available under the MIT License.

idm_cli-0.0.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+idm_cli/__init__.py,sha256=txzQmfaWzjuImDpT4p2m93DgAMHVlKPiqbPYudUY5Bs,18
+idm_cli/cli.py,sha256=dC6sWDIMwU1jCI8oms8ZvooQDulI6SHsRyHHe0dpg2o,23497
+idm_cli/downloader.py,sha256=yt2qRv2FGx2Cgytlh9KIq6YluT6c4724vVjSwRm3gyw,6873
+idm_cli/muxer.py,sha256=W7AvKfT_ptx_49J64KZ5fZMu7o0jWhq1x6e08776Asg,2451
+idm_cli/state.py,sha256=DFRI90q7xu_uC0j5d-SQLfmbWYGiC2jdUXuG1Xed12o,1877
+idm_cli/extractors/__init__.py,sha256=p6sj75HD2Ygj2mv-1_vlZmToYSlOVb_O3nylXZH7dYI,753
+idm_cli/extractors/direct.py,sha256=f0IoxuwdQutHAvDV7F8_7kHE4ZSVNrVefAQ13musI8k,675
+idm_cli/extractors/facebook.py,sha256=RXW0OrXenkGX0nxD6kEIlUwkeUONLRCwGxT_Z-gzFtA,3693
+idm_cli/extractors/youtube.py,sha256=vZOh-4nmxTO55Y0JXrHNoMtkl3xWxEI5ZbIAm7DhqB0,4245
+idm_cli-0.0.1.dist-info/licenses/LICENSE,sha256=ISSxF6YLBU6mA1fme1HHStx1cXyv8MnhqLIhe1DMZCQ,1062
+idm_cli-0.0.1.dist-info/METADATA,sha256=qNeEa-U2XWhF4A5lq93K8zEwvpS4GFmT2YYk_mQE-KI,4771
+idm_cli-0.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+idm_cli-0.0.1.dist-info/entry_points.txt,sha256=R-b5b67D3EmeIj_EIfEltdaZCdt0gie6SZaFblz4jnE,40
+idm_cli-0.0.1.dist-info/top_level.txt,sha256=yAjcrNJHpInrKlhJXbAM1ORfW3_9CEEOqdvYRohhJoI,8
+idm_cli-0.0.1.dist-info/RECORD,,

idm_cli-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

idm_cli-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+idm = idm_cli.cli:app

idm_cli-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rehan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

idm_cli-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+idm_cli