megaloader-cli 0.1.0__py3-none-any.whl

megaloader_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

megaloader_cli/commands.py

@@ -0,0 +1,220 @@
+import dataclasses
+import sys
+
+from fnmatch import fnmatch
+from pathlib import Path
+from typing import Any
+
+import megaloader as mgl
+
+from megaloader.exceptions import MegaloaderError
+from megaloader.plugins import get_plugin_class
+from rich.progress import (
+    BarColumn,
+    DownloadColumn,
+    Progress,
+    TextColumn,
+    TimeRemainingColumn,
+    TransferSpeedColumn,
+)
+
+from megaloader_cli.io import download_file
+from megaloader_cli.utils import console, sanitize_for_filesystem
+
+
+def extract_command(url: str, output_json: bool) -> None:
+    """
+    Handle extract command logic.
+
+    Fetches metadata and displays items without downloading.
+    """
+    try:
+        # Show which plugin is being used (only in human-readable mode)
+        if not output_json and (plugin_name := _get_plugin_name(url)):
+            console.print(f"[green]✓[/green] Using plugin: [bold]{plugin_name}[/bold]")
+
+        # Stream items as they're discovered
+        items = []
+        if output_json:
+            # Silent extraction for JSON mode
+            for item in mgl.extract(url):
+                items.append(item)
+        else:
+            # Show progress for human-readable mode
+            with Progress(
+                TextColumn("[bold blue]Extracting metadata..."),
+                BarColumn(),
+                console=console,
+            ) as progress:
+                task = progress.add_task("", total=None)
+
+                for item in mgl.extract(url):
+                    items.append(item)
+                    progress.update(task, advance=1)
+
+        # Display results
+        if output_json:
+            _print_json(url, items)
+        else:
+            _print_human_readable(items)
+
+    except MegaloaderError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        sys.exit(1)
+
+
+def download_command(
+    url: str,
+    output_dir: str,
+    flat: bool,
+    pattern: str | None,
+    options: dict[str, Any],
+) -> None:
+    """
+    Handle download command logic.
+
+    Extracts metadata, filters items, and downloads files with progress tracking.
+    """
+    try:
+        # Show which plugin is being used
+        if plugin_name := _get_plugin_name(url):
+            console.print(f"[green]✓[/green] Using plugin: [bold]{plugin_name}[/bold]")
+
+        # Stream and collect items
+        items = []
+        with Progress(
+            TextColumn("[bold blue]Discovering files..."),
+            BarColumn(),
+            console=console,
+        ) as progress:
+            task = progress.add_task("", total=None)
+
+            for item in mgl.extract(url, **options):
+                items.append(item)
+                progress.update(task, advance=1)
+
+        # Apply filter if specified
+        if pattern:
+            original_count = len(items)
+            items = [item for item in items if fnmatch(item.filename, pattern)]
+            console.print(f"[dim]Filtered: {original_count} → {len(items)} files[/dim]")
+
+        if not items:
+            console.print("[yellow]⚠ No files to download.[/yellow]")
+            return
+
+        console.print(f"[green]✓[/green] Found [bold]{len(items)}[/bold] files.")
+
+        # Download files with progress tracking
+        _download_with_progress(items, Path(output_dir), flat)
+
+    except MegaloaderError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        sys.exit(1)
+
+
+def _download_with_progress(
+    items: list[mgl.DownloadItem],
+    base_dir: Path,
+    flat: bool,
+) -> None:
+    """
+    Download all items with rich progress bars.
+
+    Shows individual file progress and overall completion.
+    """
+    success_count = 0
+    failed_count = 0
+
+    progress = Progress(
+        TextColumn("[bold blue]{task.fields[filename]}", justify="right"),
+        BarColumn(bar_width=None),
+        "[progress.percentage]{task.percentage:>3.0f}%",
+        "•",
+        DownloadColumn(),
+        "•",
+        TransferSpeedColumn(),
+        "•",
+        TimeRemainingColumn(),
+        console=console,
+    )
+
+    with progress:
+        # Overall progress tracker
+        overall = progress.add_task(
+            "Overall Progress",
+            total=len(items),
+            filename="Batch",
+        )
+
+        for item in items:
+            # Determine destination path
+            if flat or not item.collection_name:
+                dest_dir = base_dir
+            else:
+                dest_dir = base_dir / sanitize_for_filesystem(item.collection_name)
+
+            dest_path = dest_dir / sanitize_for_filesystem(item.filename)
+
+            # Create individual file task
+            file_task = progress.add_task(
+                "download",
+                filename=item.filename,
+                start=False,
+            )
+
+            # Perform download
+            if download_file(item, dest_path, progress, file_task):
+                success_count += 1
+            else:
+                failed_count += 1
+
+            # Update overall progress
+            progress.remove_task(file_task)
+            progress.advance(overall)
+
+    # Summary
+    console.print()
+    if failed_count == 0:
+        console.print(
+            f"[bold green]✓ Success![/bold green] Downloaded {success_count} files."
+        )
+        console.print(f"[dim]Location: {base_dir.absolute()}[/dim]")
+    else:
+        console.print(
+            f"[bold yellow]⚠ Completed with errors.[/bold yellow] "
+            f"{success_count} succeeded, {failed_count} failed."
+        )
+        sys.exit(1)
+
+
+def _get_plugin_name(url: str) -> str | None:
+    """Get plugin name for UI feedback."""
+    from urllib.parse import urlparse
+
+    domain = urlparse(url).netloc
+    plugin_class = get_plugin_class(domain)
+    return plugin_class.__name__ if plugin_class else None
+
+
+def _print_json(url: str, items: list[mgl.DownloadItem]) -> None:
+    data = {
+        "source": url,
+        "count": len(items),
+        "items": [dataclasses.asdict(item) for item in items],
+    }
+    console.print_json(data=data)
+
+
+def _print_human_readable(items: list[mgl.DownloadItem]) -> None:
+    console.print(f"\n[bold]Found {len(items)} files:[/bold]\n")
+
+    for i, item in enumerate(items, 1):
+        console.print(f"  [cyan]{i:02d}.[/cyan] {item.filename}")
+
+        if item.collection_name:
+            console.print(f"      [dim]Collection: {item.collection_name}[/dim]")
+
+        if item.size_bytes:
+            size_mb = item.size_bytes / (1024 * 1024)
+            console.print(f"      [dim]Size: {size_mb:.2f} MB[/dim]")

megaloader_cli/io.py

@@ -0,0 +1,75 @@
+from pathlib import Path
+
+import requests
+
+from megaloader.item import DownloadItem
+from rich.progress import Progress, TaskID
+
+
+def download_file(
+    item: DownloadItem,
+    destination: Path,
+    progress: Progress,
+    task_id: TaskID,
+) -> bool:
+    """
+    Download a file with progress tracking.
+
+    Args:
+        item: Download metadata including URL and required headers
+        destination: Full path where file will be saved
+        progress: Rich progress instance for UI updates
+        task_id: Task ID for this specific download
+
+    Returns:
+        True if successful or skipped, False if failed
+    """
+    try:
+        # Skip if file already exists
+        if destination.exists():
+            progress.console.print(
+                f"[yellow]⊙[/yellow] Skipped (exists): {item.filename}"
+            )
+            progress.advance(task_id, 100)
+            return True
+
+        # Ensure parent directory exists
+        destination.parent.mkdir(parents=True, exist_ok=True)
+
+        # Build headers
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
+            **item.headers,
+        }
+
+        # Stream download
+        with requests.get(
+            item.download_url,
+            stream=True,
+            timeout=60,
+            headers=headers,
+        ) as response:
+            response.raise_for_status()
+
+            # Get file size for progress bar
+            total_size = int(response.headers.get("content-length", 0))
+            progress.update(task_id, total=total_size)
+
+            # Write to disk in chunks
+            with destination.open("wb") as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    if chunk:
+                        f.write(chunk)
+                        progress.advance(task_id, len(chunk))
+
+        return True
+
+    except (requests.RequestException, OSError) as e:
+        # Print error above progress bar
+        progress.console.print(f"[red]✗[/red] Failed: {item.filename} ({e!s})")
+
+        # Clean up partial download
+        if destination.exists():
+            destination.unlink(missing_ok=True)
+
+        return False

megaloader_cli/main.py

@@ -0,0 +1,95 @@
+import click
+
+from megaloader.plugins import PLUGIN_REGISTRY
+
+from megaloader_cli.commands import download_command, extract_command
+from megaloader_cli.utils import console, setup_logging
+
+
+@click.group()
+@click.version_option(prog_name="megaloader")
+def cli() -> None:
+    """
+    Megaloader: Extract and download content from file hosting platforms.
+
+    Examples:
+      megaloader extract https://pixeldrain.com/l/abc123
+      megaloader download https://gofile.io/d/xyz456 ./downloads
+      megaloader plugins
+    """
+
+
+@cli.command(name="extract")
+@click.argument("url")
+@click.option(
+    "--json",
+    "output_json",
+    is_flag=True,
+    help="Output JSON instead of human-readable text",
+)
+@click.option("-v", "--verbose", is_flag=True, help="Enable debug logging")
+def extract_cmd(url: str, output_json: bool, verbose: bool) -> None:
+    """
+    Extract metadata from URL without downloading (dry run).
+
+    Shows what would be downloaded including filenames, sizes, and URLs.
+    """
+    setup_logging(verbose)
+    extract_command(url, output_json)
+
+
+@cli.command(name="download")
+@click.argument("url")
+@click.argument("output_dir", type=click.Path(), default="./downloads")
+@click.option("-v", "--verbose", is_flag=True, help="Enable debug logging")
+@click.option(
+    "--flat",
+    is_flag=True,
+    help="Save all files to output_dir (no collection subfolders)",
+)
+@click.option(
+    "--filter",
+    "pattern",
+    help="Filter files by glob pattern (e.g., *.jpg, *.mp4)",
+)
+@click.option(
+    "--password",
+    help="Password for protected content (Gofile)",
+)
+def download_cmd(
+    url: str,
+    output_dir: str,
+    verbose: bool,
+    flat: bool,
+    pattern: str | None,
+    password: str | None,
+) -> None:
+    """
+    Download content from URL to OUTPUT_DIR.
+
+    By default, files are organized into subfolders by collection.
+    Use --flat to disable this behavior.
+    """
+    setup_logging(verbose)
+
+    options = {}
+    if password:
+        options["password"] = password
+
+    download_command(url, output_dir, flat, pattern, options)
+
+
+@cli.command(name="plugins")
+def list_plugins_cmd() -> None:
+    """List all supported websites and domains."""
+    console.print("\n[bold]Supported Platforms:[/bold]\n")
+
+    for domain in sorted(PLUGIN_REGISTRY.keys()):
+        plugin = PLUGIN_REGISTRY[domain]
+        console.print(f"  • [cyan]{domain:<20}[/cyan] ({plugin.__name__})")
+
+    console.print()
+
+
+if __name__ == "__main__":
+    cli()

megaloader_cli/utils.py

@@ -0,0 +1,50 @@
+import logging
+import re
+
+from rich.console import Console
+from rich.logging import RichHandler
+
+
+# Shared console instance
+console = Console()
+
+
+def setup_logging(verbose: bool) -> None:
+    level = logging.DEBUG if verbose else logging.WARNING
+
+    logging.basicConfig(
+        level=level,
+        format="%(message)s",
+        datefmt="[%X]",
+        handlers=[
+            RichHandler(
+                console=console,
+                rich_tracebacks=True,
+                markup=True,
+            )
+        ],
+    )
+
+
+def sanitize_for_filesystem(name: str) -> str:
+    """
+    Sanitize a string to be safe for use as a filename or directory name.
+    Removes/replaces characters that are invalid on Windows/Unix filesystems.
+
+    Args:
+        name: Input string (e.g., "Video: Title?")
+
+    Returns:
+        Safe string (e.g., "Video_ Title_")
+    """
+    # Replace invalid characters with underscore
+    sanitized = re.sub(r'[<>:"/\\|?*]', "_", name)
+
+    # Collapse multiple underscores
+    sanitized = re.sub(r"_+", "_", sanitized)
+
+    # Remove leading/trailing whitespace and underscores
+    sanitized = sanitized.strip().strip("_")
+
+    # Ensure not empty
+    return sanitized or "unnamed"

megaloader_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: megaloader-cli
+Version: 0.1.0
+Summary: Command-line interface for Megaloader
+Maintainer-email: David Duran <dadch1404@gmail.com>
+License-Expression: Apache-2.0
+Requires-Python: >=3.10
+Requires-Dist: click>=8.1.0
+Requires-Dist: megaloader
+Requires-Dist: requests>=2.32.0
+Requires-Dist: rich>=13.7.0
+Description-Content-Type: text/markdown
+
+# [pkg]: megaloader-cli
+
+[![PyPI version](https://badge.fury.io/py/megaloader-cli.svg)](https://badge.fury.io/py/megaloader-cli)
+
+Command-line interface for the megaloader library. Extract metadata and download
+files from supported hosting platforms directly in your terminal.
+
+## Installation
+
+```bash
+pip install megaloader-cli
+```
+
+The CLI installs the core megaloader library as a dependency. Both packages can
+be used independently.
+
+## Basic usage
+
+List available files without downloading:
+
+```bash
+megaloader extract https://pixeldrain.com/l/abc123
+```
+
+Download files to a directory:
+
+```bash
+megaloader download https://pixeldrain.com/l/abc123 ./downloads
+```
+
+List supported platforms:
+
+```bash
+megaloader plugins
+```
+
+## Commands
+
+The `extract` command shows file metadata without downloading anything. Add
+`--json` for machine-readable output or `--verbose` for debug logs:
+
+```bash
+megaloader extract https://pixeldrain.com/l/abc123
+megaloader extract https://gofile.io/d/xyz456 --json
+megaloader extract https://cyberdrop.me/a/album --verbose
+```
+
+The `download` command saves files to the specified directory. Defaults to
+`./downloads` when omitted. Files are grouped into collection subfolders by
+default:
+
+```bash
+megaloader download https://pixeldrain.com/l/abc123
+megaloader download https://cyberdrop.me/a/album ./my-files
+megaloader download https://bunkr.si/a/xyz789 ./downloads --verbose
+```
+
+Add `--flat` to disable subfolders and write all files directly to the output
+directory. Use `--filter` to download only files matching a glob pattern:
+
+```bash
+megaloader download https://pixeldrain.com/l/abc123 ./downloads --flat
+megaloader download https://cyberdrop.me/a/album ./videos --filter "*.mp4"
+megaloader download https://bunkr.si/a/xyz789 ./images --filter "*.{jpg,png}"
+```
+
+GoFile password-protected content requires the `--password` argument:
+
+```bash
+megaloader download https://gofile.io/d/protected ./downloads --password secret123
+```
+
+The `plugins` command lists all supported platforms and domains.
+
+## Common patterns
+
+Preview files before downloading:
+
+```bash
+megaloader extract https://pixeldrain.com/l/abc123
+megaloader download https://pixeldrain.com/l/abc123 ./downloads
+```
+
+Filter by type to download only what you need:
+
+```bash
+megaloader download https://cyberdrop.me/a/album ./videos --filter "*.mp4"
+megaloader download https://bunkr.si/a/xyz ./images --filter "*.jpg"
+```
+
+Control file organization with the `--flat` flag:
+
+```bash
+megaloader download https://pixeldrain.com/l/abc ./organized
+megaloader download https://pixeldrain.com/l/abc ./flat --flat
+```
+
+Enable verbose logging for troubleshooting:
+
+```bash
+megaloader download https://example.com/file ./downloads --verbose
+```
+
+## Relationship to core library
+
+The CLI wraps the core megaloader library. It handles argument parsing, output
+formatting, and file downloads. The core library performs URL detection,
+metadata extraction, and platform-specific logic.
+
+Use the CLI for terminal workflows, quick downloads, and platform exploration.
+Use the core library for Python integration, custom handling, progress tracking,
+and batch processing. See the core library documentation for programmatic usage.
+
+## Development
+
+The CLI is part of a uv workspace. Install from the repository root:
+
+```bash
+uv sync
+uv run megaloader --help
+```
+
+Install in editable mode for development:
+
+```bash
+uv pip install -e packages/cli
+```
+
+Run `uv run ruff format .` and the test suite before committing.
+
+## Contributing
+
+Contributions are welcome. See the repository contributing guide for setup and
+submission details. Report bugs and request features through GitHub Discussions.
+Include your Python version, error messages, and problematic URLs.

megaloader_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+megaloader_cli/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+megaloader_cli/commands.py,sha256=OaiktrZbkwsdRID0EM7ymphAH_vVr2BvkMD0I3PEOFc,6478
+megaloader_cli/io.py,sha256=8WvvVbzihM6T5aJd0f7APWF_mlhkWDszoB422oZ9zQM,2174
+megaloader_cli/main.py,sha256=SZfiLOBLDzRrifty6hY1B-_IQfjk9R5on-ggbbbFq9c,2464
+megaloader_cli/utils.py,sha256=yQEZYqLDv-xGTpm3v73SolD2izXtvNF7ygcx3myhj5g,1203
+megaloader_cli-0.1.0.dist-info/METADATA,sha256=c9pAsUCKo0hdNDnxHjhXqf3L7DgzWIXCAV7YMLOn6jU,4115
+megaloader_cli-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+megaloader_cli-0.1.0.dist-info/entry_points.txt,sha256=xjDAeezSoZ1KOUmxQh-mImSGbaLIJSyiXOLokVY7dug,55
+megaloader_cli-0.1.0.dist-info/RECORD,,

megaloader_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

megaloader_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+megaloader = megaloader_cli.main:cli