pyfetchy 0.1.0__tar.gz

pyfetchy-0.1.0/.gitignore

@@ -0,0 +1,32 @@
+# Python
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+*.so
+*.egg
+*.egg-info/
+dist/
+build/
+.eggs/
+.venv/
+venv/
+env/
+
+# fetchy state files
+*.fetchy
+
+# pytest
+.pytest_cache/
+.coverage
+htmlcov/
+
+# editors
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db

pyfetchy-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 fetchy contributors
+
+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.

pyfetchy-0.1.0/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: pyfetchy
+Version: 0.1.0
+Summary: A fast, open-source download manager with parallel segments and resume support
+Project-URL: Homepage, https://github.com/Uruskus/fetchy
+Project-URL: Issues, https://github.com/Uruskus/fetchy/issues
+Author: fetchy contributors
+License: MIT
+License-File: LICENSE
+Keywords: cli,download,manager,parallel,resume
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.12.0
+Description-Content-Type: text/markdown
+
+# fetchy
+
+> A fast, open-source CLI download manager — a free alternative to IDM.
+
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue)](https://python.org)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+[![PyPI](https://img.shields.io/pypi/v/fetchy)](https://pypi.org/project/fetchy)
+
+fetchy splits files into parallel segments using HTTP Range Requests, giving you faster downloads and the ability to resume interrupted transfers — right from your terminal.
+
+---
+
+## Features
+
+- **Parallel downloads** — splits files into N segments downloaded simultaneously
+- **Resume support** — interrupted downloads continue from where they left off
+- **Live progress** — per-segment bars with speed and ETA
+- **Retry logic** — transient errors are retried automatically with exponential backoff
+- **Cross-platform** — works on Windows, macOS, and Linux
+- **Zero config** — sensible defaults, fully configurable via flags
+
+---
+
+## Installation
+
+```bash
+pip install fetchy
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/yourusername/fetchy.git
+cd fetchy
+pip install -e .
+```
+
+---
+
+## Usage
+
+```bash
+# Basic download (4 segments by default)
+fetchy get https://example.com/largefile.zip
+
+# Save to a specific directory or filename
+fetchy get https://example.com/largefile.zip -o ~/Downloads/
+fetchy get https://example.com/largefile.zip -o ~/Downloads/myfile.zip
+
+# Use 8 parallel segments
+fetchy get https://example.com/largefile.zip -s 8
+
+# Disable resume (start fresh even if a state file exists)
+fetchy get https://example.com/largefile.zip --no-resume
+
+# Show version
+fetchy --version
+```
+
+**Resuming:** if you press `Ctrl+C` during a download, fetchy saves a `.fetchy` state file next to the output file. Run the same command again to resume automatically.
+
+---
+
+## How it works
+
+1. fetchy sends a `HEAD` request to check the file size and whether the server supports `Range` requests.
+2. If supported, the file is split into N equally-sized byte ranges.
+3. Each segment is downloaded in parallel using async HTTP (httpx).
+4. Segments are written directly to their correct offset in the pre-allocated output file — no temp files to merge.
+5. Progress and speed are tracked per segment and shown in a live Rich display.
+6. On completion the `.fetchy` state file is deleted automatically.
+
+---
+
+## Options
+
+| Flag | Default | Description |
+|---|---|---|
+| `-o`, `--output` | `.` (current dir) | Output file or directory |
+| `-s`, `--segments` | `4` | Number of parallel segments |
+| `-r`, `--retries` | `5` | Max retries per segment |
+| `--resume / --no-resume` | `--resume` | Resume interrupted downloads |
+
+---
+
+## Development
+
+```bash
+# Install with dev dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Run a local download test
+fetchy get https://speed.hetzner.de/100MB.bin -s 8
+```
+
+### Project structure
+
+```
+fetchy/
+├── src/
+│   └── fetchy/
+│       ├── __init__.py      # version
+│       ├── cli.py           # Typer CLI entry point
+│       ├── downloader.py    # core engine (segments, resume, retry)
+│       └── progress.py      # Rich progress display
+├── tests/
+│   └── test_downloader.py
+├── pyproject.toml
+└── README.md
+```
+
+---
+
+## Contributing
+
+Contributions are welcome! Please open an issue first to discuss what you'd like to change.
+
+1. Fork the repo
+2. Create a feature branch (`git checkout -b feature/your-feature`)
+3. Commit your changes
+4. Open a pull request
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).

pyfetchy-0.1.0/README.md

@@ -0,0 +1,130 @@
+# fetchy
+
+> A fast, open-source CLI download manager — a free alternative to IDM.
+
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue)](https://python.org)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+[![PyPI](https://img.shields.io/pypi/v/fetchy)](https://pypi.org/project/fetchy)
+
+fetchy splits files into parallel segments using HTTP Range Requests, giving you faster downloads and the ability to resume interrupted transfers — right from your terminal.
+
+---
+
+## Features
+
+- **Parallel downloads** — splits files into N segments downloaded simultaneously
+- **Resume support** — interrupted downloads continue from where they left off
+- **Live progress** — per-segment bars with speed and ETA
+- **Retry logic** — transient errors are retried automatically with exponential backoff
+- **Cross-platform** — works on Windows, macOS, and Linux
+- **Zero config** — sensible defaults, fully configurable via flags
+
+---
+
+## Installation
+
+```bash
+pip install fetchy
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/yourusername/fetchy.git
+cd fetchy
+pip install -e .
+```
+
+---
+
+## Usage
+
+```bash
+# Basic download (4 segments by default)
+fetchy get https://example.com/largefile.zip
+
+# Save to a specific directory or filename
+fetchy get https://example.com/largefile.zip -o ~/Downloads/
+fetchy get https://example.com/largefile.zip -o ~/Downloads/myfile.zip
+
+# Use 8 parallel segments
+fetchy get https://example.com/largefile.zip -s 8
+
+# Disable resume (start fresh even if a state file exists)
+fetchy get https://example.com/largefile.zip --no-resume
+
+# Show version
+fetchy --version
+```
+
+**Resuming:** if you press `Ctrl+C` during a download, fetchy saves a `.fetchy` state file next to the output file. Run the same command again to resume automatically.
+
+---
+
+## How it works
+
+1. fetchy sends a `HEAD` request to check the file size and whether the server supports `Range` requests.
+2. If supported, the file is split into N equally-sized byte ranges.
+3. Each segment is downloaded in parallel using async HTTP (httpx).
+4. Segments are written directly to their correct offset in the pre-allocated output file — no temp files to merge.
+5. Progress and speed are tracked per segment and shown in a live Rich display.
+6. On completion the `.fetchy` state file is deleted automatically.
+
+---
+
+## Options
+
+| Flag | Default | Description |
+|---|---|---|
+| `-o`, `--output` | `.` (current dir) | Output file or directory |
+| `-s`, `--segments` | `4` | Number of parallel segments |
+| `-r`, `--retries` | `5` | Max retries per segment |
+| `--resume / --no-resume` | `--resume` | Resume interrupted downloads |
+
+---
+
+## Development
+
+```bash
+# Install with dev dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Run a local download test
+fetchy get https://speed.hetzner.de/100MB.bin -s 8
+```
+
+### Project structure
+
+```
+fetchy/
+├── src/
+│   └── fetchy/
+│       ├── __init__.py      # version
+│       ├── cli.py           # Typer CLI entry point
+│       ├── downloader.py    # core engine (segments, resume, retry)
+│       └── progress.py      # Rich progress display
+├── tests/
+│   └── test_downloader.py
+├── pyproject.toml
+└── README.md
+```
+
+---
+
+## Contributing
+
+Contributions are welcome! Please open an issue first to discuss what you'd like to change.
+
+1. Fork the repo
+2. Create a feature branch (`git checkout -b feature/your-feature`)
+3. Commit your changes
+4. Open a pull request
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).

pyfetchy-0.1.0/fetchy/__init__.py

@@ -0,0 +1,3 @@
+"""fetchy – a fast, open-source CLI download manager."""
+
+__version__ = "0.1.0"

pyfetchy-0.1.0/fetchy/cli.py

@@ -0,0 +1,172 @@
+"""
+fetchy CLI – entry point.
+
+Usage examples:
+    fetchy https://example.com/file.zip
+    fetchy https://example.com/file.zip -o ~/Downloads/
+    fetchy https://example.com/file.zip -s 8
+    fetchy https://example.com/file.zip --resume
+"""
+
+import asyncio
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from fetchy import __version__
+from fetchy.downloader import download, _get_file_info, _load_state
+from fetchy.progress import DownloadProgress
+
+import httpx
+
+app = typer.Typer(
+    name="fetchy",
+    help="A fast, open-source CLI download manager with parallel segments.",
+    add_completion=False,
+)
+console = Console()
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        console.print(f"fetchy {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: Optional[bool] = typer.Option(
+        None,
+        "--version",
+        "-v",
+        callback=_version_callback,
+        is_eager=True,
+        help="Show version and exit.",
+    ),
+) -> None:
+    """fetchy – download files fast with parallel HTTP segments."""
+
+
+@app.command()
+def get(
+    url: str = typer.Argument(..., help="URL of the file to download"),
+    output: Optional[Path] = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Output file or directory (default: current directory)",
+    ),
+    segments: int = typer.Option(
+        4,
+        "--segments",
+        "-s",
+        min=1,
+        max=32,
+        help="Number of parallel download segments",
+    ),
+    retries: int = typer.Option(
+        5,
+        "--retries",
+        "-r",
+        help="Max retries per segment on error",
+    ),
+    resume: bool = typer.Option(
+        True,
+        "--resume/--no-resume",
+        help="Resume an interrupted download if a .fetchy state file exists",
+    ),
+) -> None:
+    """Download a file from URL using parallel segments."""
+
+    # Resolve output path
+    out = output or Path(".")
+
+    # Check for existing resume state before probing the server
+    if out.is_dir():
+        # We don't know the filename yet – probe first
+        existing_state = None
+    else:
+        existing_state = _load_state(out) if resume else None
+
+    # Run the async download
+    try:
+        asyncio.run(
+            _run_download(url, out, segments, retries, resume)
+        )
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Download paused.[/yellow] Run the same command to resume.")
+        raise typer.Exit(1)
+    except Exception as exc:
+        console.print(f"\n[red]Error:[/red] {exc}")
+        raise typer.Exit(1)
+
+
+async def _run_download(
+    url: str,
+    output: Path,
+    num_segments: int,
+    max_retries: int,
+    resume: bool,
+) -> None:
+    """Async wrapper that wires up the progress display and calls the downloader."""
+
+    # Probe the server to get file info for the progress display
+    async with httpx.AsyncClient(timeout=30) as client:
+        total_size, supports_ranges, filename = await _get_file_info(client, url)
+
+    # If output is a directory, figure out the final path
+    if output.is_dir():
+        final_path = output / filename
+    else:
+        final_path = output
+        filename = final_path.name
+
+    # Adjust segment count if the server doesn't support ranges
+    effective_segments = num_segments if supports_ranges and total_size > 0 else 1
+    if effective_segments == 1 and num_segments > 1:
+        console.print(
+            "[yellow]Server does not support Range requests – using single-stream download.[/yellow]"
+        )
+
+    # Check for resume state
+    existing = _load_state(final_path) if resume else None
+    if existing and not existing.completed:
+        console.print(f"[green]Resuming[/green] interrupted download of [bold]{filename}[/bold]")
+        already_downloaded = sum(s.downloaded for s in existing.segments)
+        console.print(
+            f"  {_fmt_bytes(already_downloaded)} of {_fmt_bytes(total_size)} already downloaded"
+        )
+    else:
+        console.print(f"[bold]Downloading[/bold] [cyan]{filename}[/cyan]")
+        if total_size:
+            console.print(f"  Size: {_fmt_bytes(total_size)}  |  Segments: {effective_segments}")
+
+    with DownloadProgress(total_size, effective_segments, filename) as dp:
+        # Pre-advance progress bars for already-downloaded bytes (resume case)
+        if existing and not existing.completed:
+            for seg in existing.segments:
+                if seg.downloaded > 0:
+                    dp._progress.advance(dp._overall_task, seg.downloaded)
+                    if seg.index in dp._segment_tasks:
+                        dp._progress.advance(dp._segment_tasks[seg.index], seg.downloaded)
+
+        await download(
+            url=url,
+            output_path=final_path,
+            num_segments=effective_segments,
+            on_progress=dp.update,
+            max_retries=max_retries,
+        )
+
+    console.print(f"\n[bold green]Done![/bold green] Saved to [cyan]{final_path}[/cyan]")
+
+
+def _fmt_bytes(n: int) -> str:
+    """Format a byte count as a human-readable string."""
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if n < 1024:
+            return f"{n:.1f} {unit}"
+        n /= 1024
+    return f"{n:.1f} PB"