nercone-fastget 6.0.0__tar.gz

nercone_fastget-6.0.0/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.3
+Name: nercone-fastget
+Version: 6.0.0
+Summary: High-speed File Downloading Tool
+Author: Nercone
+Author-email: Nercone <nercone@diamondgotcat.net>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Dist: rich
+Requires-Dist: httpx[http2]
+Requires-Dist: uvloop ; sys_platform != 'win32'
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+
+<img width="1920" alt="fastget" src="https://github.com/user-attachments/assets/fb4b6013-f65b-4c34-ae86-848011e7bfcf" />
+
+# FastGet
+High-speed File Downloading Tool
+
+## How
+It's using Multiple Thread Download.
+
+This is need Range-select feature, in Server-side.
+
+## Requiments
+- CPython 3.9+
+- `uv` [PyPI↗︎](https://pypi.org/project/uv/) or `pip3` [PyPI↗︎](https://pypi.org/project/pip/) 
+- `nercone-modern` [PyPI↗︎](https://pypi.org/project/nercone-modern/) for Modern CLI Visual
+- `httpx[http2]` [PyPI↗︎](https://pypi.org/project/httpx/) for HTTP Connection
+- `uvloop` [PyPI↗︎](https://pypi.org/project/uvloop/) for Fast Asynchronous Processing (non-Windows only)
+
+## Installation
+
+### uv (recommended)
+```
+uv tool install nercone-fastget
+```
+
+### pip3
+
+**System Python:**
+```
+pip3 install nercone-fastget --break-system-packages
+```
+
+**Venv Python:**
+```
+pip3 install nercone-fastget
+```
+
+## Update
+
+### uv
+```
+uv tool install nercone-fastget --upgrade
+```
+
+### pip3
+
+**System Python:**
+```
+pip3 install nercone-fastget --upgrade --break-system-packages
+```
+
+**Venv Python:**
+```
+pip3 install nercone-fastget --upgrade
+```
+
+## Usage
+
+### Show helps
+```
+fastget [-h] [--help]
+```
+
+```
+nercone@demo ~/Downloads> fastget -h
+usage: fastget [-h] [-o OUTPUT] [-X {GET,POST}] [-d DATA] [-H HEADER] [-t THREADS] [-p] [-s] [-m] [--no-verify] [--no-info] [--no-http1] [--no-http2] url
+
+Modern High-Performance Downloader
+
+positional arguments:
+  url                   Target URL
+
+options:
+  -h, --help            show this help message and exit
+  -o OUTPUT, --output OUTPUT
+                        File destination
+  -X {GET,POST}, --method {GET,POST}
+                        HTTP method (GET/POST)
+  -d DATA, --data DATA  Data for POST method
+  -H HEADER, --header HEADER
+                        Custom Headers
+  -t THREADS, --threads THREADS
+                        Number of threads to use for downloading
+  -p, --print           Output data directly to stdout without saving to a file
+  -s, --storage, --low-memory
+                        Utilize storage efficiently to reduce memory usage during internal processes such as downloading and merging.
+  -m, --memory, --low-storage
+                        Utilize memory efficiently to reduce maximum concurrent storage usage during internal processes such as downloading and merging.
+  --no-verify           In the case of HTTPS, if a secure connection cannot be established, the system will continue to operate normally.
+  --no-info             Suppresses all displays such as progress bars. If --print is used, only data is output to stdout.
+  --no-http1            Do not use HTTP/1 or HTTP/1.1
+  --no-http2            Do not use HTTP/2
+```
+
+### Download
+```
+fastget [-o OUTPUT] [-X {GET,POST}] [-d DATA] [-H HEADER] [-t THREADS] [-p] [-s] [-m] [--no-verify] [--no-info] [--no-http1] [--no-http2] url
+```
+
+```
+nercone@demo ~> fastget https://download.fedoraproject.org/pub/fedora/linux/releases/43/Server/aarch64/iso/Fedora-Server-netinst-aarch64-43-1.6.iso
+[2025-12-05T17:24:31Z INFO     fastget] File size: 1,198,647,296 bytes
+[2025-12-05T17:24:31Z INFO     fastget] Connection Type: HTTPS (HTTP/1.1, TLS, Verified)
+[2025-12-05T17:24:31Z INFO     fastget] Threads: 8
+[-------------------------------------] Total DONE No Message
+[-------------------------------------] DL #1 DONE No Message
+[-------------------------------------] DL #2 DONE No Message
+[-------------------------------------] DL #3 DONE No Message
+[-------------------------------------] DL #4 DONE No Message
+[-------------------------------------] DL #5 DONE No Message
+[-------------------------------------] DL #6 DONE No Message
+[-------------------------------------] DL #7 DONE No Message
+[-------------------------------------] DL #8 DONE No Message
+[-------------------------------------] Marge DONE No Message
+[2025-12-05T17:24:46Z INFO     fastget] Completed in 16222.00ms
+[2025-12-05T17:24:46Z INFO     fastget] Saved to: Fedora-Server-netinst-aarch64-43-1.6.iso
+```
+
+![PyPI - Version](https://img.shields.io/pypi/v/nercone-fastget)

nercone_fastget-6.0.0/README.md

@@ -0,0 +1,119 @@
+
+<img width="1920" alt="fastget" src="https://github.com/user-attachments/assets/fb4b6013-f65b-4c34-ae86-848011e7bfcf" />
+
+# FastGet
+High-speed File Downloading Tool
+
+## How
+It's using Multiple Thread Download.
+
+This is need Range-select feature, in Server-side.
+
+## Requiments
+- CPython 3.9+
+- `uv` [PyPI↗︎](https://pypi.org/project/uv/) or `pip3` [PyPI↗︎](https://pypi.org/project/pip/) 
+- `nercone-modern` [PyPI↗︎](https://pypi.org/project/nercone-modern/) for Modern CLI Visual
+- `httpx[http2]` [PyPI↗︎](https://pypi.org/project/httpx/) for HTTP Connection
+- `uvloop` [PyPI↗︎](https://pypi.org/project/uvloop/) for Fast Asynchronous Processing (non-Windows only)
+
+## Installation
+
+### uv (recommended)
+```
+uv tool install nercone-fastget
+```
+
+### pip3
+
+**System Python:**
+```
+pip3 install nercone-fastget --break-system-packages
+```
+
+**Venv Python:**
+```
+pip3 install nercone-fastget
+```
+
+## Update
+
+### uv
+```
+uv tool install nercone-fastget --upgrade
+```
+
+### pip3
+
+**System Python:**
+```
+pip3 install nercone-fastget --upgrade --break-system-packages
+```
+
+**Venv Python:**
+```
+pip3 install nercone-fastget --upgrade
+```
+
+## Usage
+
+### Show helps
+```
+fastget [-h] [--help]
+```
+
+```
+nercone@demo ~/Downloads> fastget -h
+usage: fastget [-h] [-o OUTPUT] [-X {GET,POST}] [-d DATA] [-H HEADER] [-t THREADS] [-p] [-s] [-m] [--no-verify] [--no-info] [--no-http1] [--no-http2] url
+
+Modern High-Performance Downloader
+
+positional arguments:
+  url                   Target URL
+
+options:
+  -h, --help            show this help message and exit
+  -o OUTPUT, --output OUTPUT
+                        File destination
+  -X {GET,POST}, --method {GET,POST}
+                        HTTP method (GET/POST)
+  -d DATA, --data DATA  Data for POST method
+  -H HEADER, --header HEADER
+                        Custom Headers
+  -t THREADS, --threads THREADS
+                        Number of threads to use for downloading
+  -p, --print           Output data directly to stdout without saving to a file
+  -s, --storage, --low-memory
+                        Utilize storage efficiently to reduce memory usage during internal processes such as downloading and merging.
+  -m, --memory, --low-storage
+                        Utilize memory efficiently to reduce maximum concurrent storage usage during internal processes such as downloading and merging.
+  --no-verify           In the case of HTTPS, if a secure connection cannot be established, the system will continue to operate normally.
+  --no-info             Suppresses all displays such as progress bars. If --print is used, only data is output to stdout.
+  --no-http1            Do not use HTTP/1 or HTTP/1.1
+  --no-http2            Do not use HTTP/2
+```
+
+### Download
+```
+fastget [-o OUTPUT] [-X {GET,POST}] [-d DATA] [-H HEADER] [-t THREADS] [-p] [-s] [-m] [--no-verify] [--no-info] [--no-http1] [--no-http2] url
+```
+
+```
+nercone@demo ~> fastget https://download.fedoraproject.org/pub/fedora/linux/releases/43/Server/aarch64/iso/Fedora-Server-netinst-aarch64-43-1.6.iso
+[2025-12-05T17:24:31Z INFO     fastget] File size: 1,198,647,296 bytes
+[2025-12-05T17:24:31Z INFO     fastget] Connection Type: HTTPS (HTTP/1.1, TLS, Verified)
+[2025-12-05T17:24:31Z INFO     fastget] Threads: 8
+[-------------------------------------] Total DONE No Message
+[-------------------------------------] DL #1 DONE No Message
+[-------------------------------------] DL #2 DONE No Message
+[-------------------------------------] DL #3 DONE No Message
+[-------------------------------------] DL #4 DONE No Message
+[-------------------------------------] DL #5 DONE No Message
+[-------------------------------------] DL #6 DONE No Message
+[-------------------------------------] DL #7 DONE No Message
+[-------------------------------------] DL #8 DONE No Message
+[-------------------------------------] Marge DONE No Message
+[2025-12-05T17:24:46Z INFO     fastget] Completed in 16222.00ms
+[2025-12-05T17:24:46Z INFO     fastget] Saved to: Fedora-Server-netinst-aarch64-43-1.6.iso
+```
+
+![PyPI - Version](https://img.shields.io/pypi/v/nercone-fastget)

nercone_fastget-6.0.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["uv_build>=0.9.5,<0.10.0"]
+build-backend = "uv_build"
+
+[project]
+name = "nercone-fastget"
+version = "6.0.0"
+description = "High-speed File Downloading Tool"
+readme = { file = "README.md", content-type = "text/markdown" }
+authors = [
+    { name = "Nercone", email = "nercone@diamondgotcat.net" }
+]
+license = { text = "MIT" }
+requires-python = ">=3.8"
+dependencies = [
+    "rich",
+    "httpx[http2]",
+    "uvloop; platform_system != 'Windows'"
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent"
+]
+
+[project.scripts]
+fastget = "nercone_fastget.__main__:main"

nercone_fastget-6.0.0/src/nercone_fastget/__main__.py

@@ -0,0 +1,199 @@
+# ╭──────────────────────────────────────╮
+# │ __main__.py on nercone-fastget       │
+# │ Nercone <nercone@diamondgotcat.net>  │
+# │ Made by Nercone / MIT License        │
+# │ Copyright (c) 2025 DiamondGotCat     │
+# ╰──────────────────────────────────────╯
+
+import argparse
+import asyncio
+import os
+import sys
+from urllib.parse import urlparse, unquote
+from typing import Dict, List, Optional
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.filesize import decimal
+from rich.progress import (
+    Progress,
+    BarColumn,
+    TextColumn,
+    DownloadColumn,
+    TransferSpeedColumn,
+    TimeRemainingColumn,
+)
+
+from .fastget import (
+    FastGetSession,
+    ProgressCallback,
+    FastGetError,
+    DEFAULT_THREADS,
+    VERSION,
+)
+
+class RichProgressCallback(ProgressCallback):
+    def __init__(self, console: "Console", progress: "Progress"):
+        self.console = console
+        self.progress = progress
+        self.overall_task: Optional[int] = None
+        self.worker_tasks: List[int] = []
+        self.merge_task: Optional[int] = None
+
+    async def on_start(self, total_size: int, threads: int, http_version: str, final_url: str, verify_was_enabled: bool) -> None:
+        self.console.print(Panel(
+            f"[bold]URL[/bold]: {final_url}\n"
+            f"[bold]File Size[/bold]: {decimal(total_size)}\n"
+            f"[bold]Threads[/bold]: {threads}\n"
+            f"[bold]HTTP Version[/bold]: {http_version}\n"
+            f"[bold]SSL/TLS Verify[/bold]: {'Enabled' if verify_was_enabled else '[yellow]Disabled[/yellow]'}",
+            title="Download Information",
+            border_style="green",
+            expand=False
+        ))
+        self.overall_task = self.progress.add_task("[bold green]Download", total=total_size)
+        if threads > 1:
+            part_size = total_size // threads
+            for i in range(threads):
+                task_total = total_size - (part_size * i) if i == threads - 1 else part_size
+                self.worker_tasks.append(self.progress.add_task(f"Worker {i+1}", total=task_total))
+
+    async def on_update(self, worker_id: int, loaded: int) -> None:
+        if self.overall_task is not None:
+            self.progress.update(self.overall_task, advance=loaded)
+        if self.worker_tasks and worker_id < len(self.worker_tasks):
+            self.progress.update(self.worker_tasks[worker_id], advance=loaded)
+
+    async def on_merge_start(self, total_size: int) -> None:
+        self.merge_task = self.progress.add_task("[bold cyan]Merge", total=total_size)
+
+    async def on_merge_update(self, loaded: int) -> None:
+        if self.merge_task is not None:
+            self.progress.update(self.merge_task, advance=loaded)
+
+    async def on_slowdown(self, msg: str) -> None:
+        self.console.print(f"[yellow]W[/yellow] {msg}")
+
+    async def on_error(self, msg: str) -> None:
+        if not self.progress.finished:
+            self.progress.stop()
+        self.console.print(f"[bold red]E[/bold red] {msg}")
+
+class SilentProgressCallback(ProgressCallback):
+    def __init__(self, console: "Console"):
+        self.console = console
+
+    async def on_error(self, msg: str) -> None:
+        self.console.print(f"[bold red]E[/bold red] {msg}")
+
+async def main():
+    parser = argparse.ArgumentParser(prog="fastget", description=f"High-speed File Downloading Tool", formatter_class=argparse.RawTextHelpFormatter)
+    parser.add_argument("url", help="URL to download from.")
+    parser.add_argument("-o", "--output", help="Path to save the file. If not specified, it's inferred from the URL.")
+    parser.add_argument("-t", "--threads", type=int, default=DEFAULT_THREADS, help=f"Number of parallel connections. (default: {DEFAULT_THREADS})")
+    parser.add_argument( "-X", "--request", default="GET", choices=["GET", "POST"], help="HTTP method to use. (default: GET)")
+    parser.add_argument( "-H", "--header", action="append", help="Custom header to send with the request (e.g., 'User-Agent: my-app/1.0').\nCan be specified multiple times.")
+    parser.add_argument("-d", "--data", help="Data to send in a POST request.")
+    parser.add_argument("--no-verify", action="store_false", dest="verify", help="Disable SSL/TLS certificate verification.")
+    parser.add_argument("--no-info", action="store_true", help="Silent mode. Suppress progress bar and other info.\nErrors are still printed to stderr.")
+    parser.add_argument("--no-http1", action="store_false", dest="http1", help="Disable HTTP/1.x and force HTTP/2.")
+    parser.add_argument("--no-http2", action="store_false", dest="http2", help="Disable HTTP/2 and force HTTP/1.x.")
+    parser.add_argument("-v", "--version", action="version", version=f"%(prog)s {VERSION}")
+    args = parser.parse_args()
+
+    if args.no_info:
+        console = Console(stderr=True, quiet=True)
+        callback = SilentProgressCallback(console)
+        progress = None
+    else:
+        console = Console()
+        progress = Progress(
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            DownloadColumn(),
+            TransferSpeedColumn(),
+            TextColumn("ETA:"),
+            TimeRemainingColumn(),
+            console=console,
+            transient=True
+        )
+        callback = RichProgressCallback(console, progress)
+
+    output_path = args.output
+    if not output_path:
+        try:
+            parsed_url = urlparse(args.url)
+            filename = os.path.basename(unquote(parsed_url.path))
+            if not filename:
+                console.print("[bold red]E[/bold red] Cannot determine output filename from URL. Please specify it with the -o/--output option.")
+                sys.exit(1)
+            output_path = filename
+        except Exception as e:
+            console.print(f"[bold red]E[/bold red] Invalid URL provided: {e}")
+            sys.exit(1)
+
+    headers: Dict[str, str] = {}
+    if args.header:
+        for h in args.header:
+            if ":" in h:
+                key, value = h.split(":", 1)
+                headers[key.strip()] = value.strip()
+            elif "=" in h:
+                key, value = h.split("=", 1)
+                headers[key.strip()] = value.strip()
+            else:
+                console.print(f"[yellow]W[/yellow] Ignoring malformed header: {h}")
+
+    session = FastGetSession(
+        max_threads=args.threads,
+        http1=args.http1,
+        http2=args.http2,
+        verify=args.verify,
+    )
+
+    try:
+        downloader = session.process(
+            method=args.request.upper(),
+            url=args.url,
+            output=output_path,
+            data=args.data,
+            headers=headers,
+            callback=callback,
+        )
+
+        if progress:
+            with progress:
+                result = await downloader
+        else:
+            result = await downloader
+
+        if not args.no_info:
+            console.print(f"[bold green]✔ Downloaded[/bold green] Saved to '{result}'")
+
+    except (FastGetError, Exception) as e:
+        if not isinstance(callback, RichProgressCallback) or (isinstance(callback, RichProgressCallback) and callback.progress.finished):
+            console.print(f"[bold red]E[/bold red] {e}")
+
+        if output_path:
+            if os.path.exists(output_path):
+                try: os.remove(output_path)
+                except OSError: pass
+
+            out_dir = os.path.dirname(output_path) or '.'
+            out_base = os.path.basename(output_path)
+            for i in range(args.threads):
+                part_path = os.path.join(out_dir, f"{out_base}.part{i}")
+                if os.path.exists(part_path):
+                    try: os.remove(part_path)
+                    except OSError: pass
+        sys.exit(1)
+
+def run():
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        Console().print("\n[yellow]W[/yellow] Aborted.")
+        sys.exit(130)
+
+if __name__ == "__main__":
+    run()

nercone_fastget-6.0.0/src/nercone_fastget/fastget.py

@@ -0,0 +1,259 @@
+# ╭──────────────────────────────────────╮
+# │ fastget.py on nercone-fastget        │
+# │ Nercone <nercone@diamondgotcat.net>  │
+# │ Made by Nercone / MIT License        │
+# │ Copyright (c) 2025 DiamondGotCat     │
+# ╰──────────────────────────────────────╯
+
+import os
+import asyncio
+import httpx
+from importlib.metadata import version
+from urllib.parse import urlparse, unquote
+from typing import Union, Optional, Dict, Any, TypeVar, Coroutine, Awaitable
+
+try:
+    VERSION = version("nercone-fastget")
+except Exception:
+    VERSION = "0.0.0"
+
+DEFAULT_CHUNK_SIZE = 1024 * 64
+DEFAULT_TIMEOUT = 30.0
+DEFAULT_RETRIES = 3
+DEFAULT_THREADS = 8
+
+T = TypeVar("T")
+
+class FastGetError(Exception):
+    pass
+
+class ProgressCallback:
+    async def on_start(self, total_size: int, threads: int, http_version: str, final_url: str, verify_was_enabled: bool) -> None:
+        pass
+
+    async def on_update(self, worker_id: int, loaded: int) -> None:
+        pass
+
+    async def on_complete(self) -> None:
+        pass
+
+    async def on_merge_start(self, total_size: int) -> None:
+        pass
+
+    async def on_merge_update(self, loaded: int) -> None:
+        pass
+
+    async def on_merge_complete(self) -> None:
+        pass
+
+    async def on_slowdown(self, msg: str) -> None:
+        pass
+
+    async def on_error(self, msg: str) -> None:
+        pass
+
+class FastGetResponse:
+    def __init__(self, original: httpx.Response, content: bytes):
+        self._r = original
+        self.content = content
+        self.url = str(original.url)
+        self.status_code = original.status_code
+        self.headers = original.headers
+        self.http_version = original.http_version
+
+    @property
+    def text(self) -> str:
+        return self._r.text
+
+    def json(self, **kwargs) -> Any:
+        return self._r.json(**kwargs)
+
+class FastGetSession:
+    def __init__(self, max_threads: int = DEFAULT_THREADS, http1: bool = True, http2: bool = True, verify: bool = True, follow_redirects: bool = True):
+        self.max_threads = max_threads
+        self.client_args: Dict[str, Any] = {
+            "http1": http1,
+            "http2": http2,
+            "verify": verify,
+            "follow_redirects": follow_redirects,
+            "timeout": DEFAULT_TIMEOUT
+        }
+
+    async def _get_info(self, client: httpx.AsyncClient, method: str, url: str, headers: dict[str,str]) -> tuple[int, bool, bool, Optional[httpx.Response]]:
+        headers["User-Agent"] = f'FastGet/{VERSION} (Getting Informations; https://github.com/DiamondGotCat/nercone-fastget/)'
+
+        if method.upper() != "GET":
+            return 0, False, False, None
+
+        try:
+            head_resp = await client.head(url=url, headers=headers)
+
+            if head_resp.status_code < 400:
+                resp = head_resp
+            else:
+                request = client.build_request(method=method, url=url, headers=headers)
+                resp = await client.send(request, stream=True)
+                await resp.aclose()
+
+            size = int(resp.headers.get("content-length", 0))
+            accept_ranges = resp.headers.get("accept-ranges", "").lower() == "bytes"
+            reject_fg = resp.headers.get("rejectfastget", "").lower() in ["true", "1", "yes"]
+
+            return size, accept_ranges, reject_fg, resp
+
+        except Exception:
+            return 0, False, True, None
+
+    async def _download_worker(self, client: httpx.AsyncClient, method: str, url: str, start: int, end: int, worker_id: int, total_threads: int, part_path: str, callback: ProgressCallback, headers: dict[str,str]) -> None:
+        headers["Range"] = f"bytes={start}-{end}"
+        headers["User-Agent"] = f'FastGet/{VERSION} (Downloading with {total_threads} Thread(s), Connection No. {worker_id}; +https://github.com/DiamondGotCat/nercone-fastget/)'
+
+        for attempt in range(DEFAULT_RETRIES):
+            try:
+                async with client.stream(method=method, url=url, headers=headers) as response:
+                    response.raise_for_status()
+
+                    with open(part_path, "wb") as f:
+                        async for chunk in response.aiter_bytes(chunk_size=DEFAULT_CHUNK_SIZE):
+                            if not chunk:
+                                break
+
+                            f.write(chunk)
+                            await callback.on_update(worker_id, len(chunk))
+                return
+
+            except (httpx.RequestError, httpx.HTTPStatusError) as e:
+                if attempt == DEFAULT_RETRIES - 1:
+                    await callback.on_error(f"Worker {worker_id} failed: {e}")
+                    raise
+                await asyncio.sleep(1)
+
+    async def process(self, method: str, url: str, output: Optional[str] = None, data: Any = None, json: Any = None, params: Any = None, headers: Optional[Dict[str, str]] = None, callback: Optional[ProgressCallback] = None) -> Union[str, FastGetResponse]:
+        callback = callback or ProgressCallback()
+        if headers is None:
+            headers = {}
+
+        async with httpx.AsyncClient(**self.client_args) as client:
+            file_size, is_resumable, is_rejected, info_response = await self._get_info(client, method, url, headers)
+
+            if method.upper() == "GET" and not info_response:
+                raise FastGetError(f"Failed to retrieve file information from {url}")
+
+            use_parallel = True
+            if method.upper() != "GET":
+                use_parallel = False
+                await callback.on_slowdown("Parallel download are currently only supported with the GET method. Using single-threaded download.")
+            elif not is_resumable:
+                use_parallel = False
+                await callback.on_slowdown("Server does not support download range specification. Using single-threaded download.")
+            elif is_rejected:
+                use_parallel = False
+                await callback.on_slowdown("The server rejected Parallel FastGet download. Using single-threaded download.")
+            elif not file_size > 0:
+                use_parallel = False
+                await callback.on_slowdown("The file size reported by the server is invalid. Using single-threaded download.")
+            threads = self.max_threads if use_parallel else 1
+
+            http_version = info_response.http_version if info_response else "HTTP/1.1"
+            final_url = str(info_response.url) if info_response else url
+
+            await callback.on_start(
+                total_size=file_size,
+                threads=threads,
+                http_version=http_version,
+                final_url=final_url,
+                verify_was_enabled=bool(self.client_args["verify"])
+            )
+
+            if output:
+                out_dir = os.path.dirname(output)
+                if out_dir:
+                    os.makedirs(out_dir, exist_ok=True)
+
+                if use_parallel:
+                    part_size = file_size // threads
+                    tasks = []
+                    part_files = []
+
+                    for i in range(threads):
+                        start = part_size * i
+                        end = file_size - 1 if i == threads - 1 else start + part_size - 1
+
+                        part_path = f"{output}.part{i}"
+                        part_files.append(part_path)
+
+                        tasks.append(self._download_worker(client, method, url, start, end, i, threads, part_path, callback, headers))
+
+                    await asyncio.gather(*tasks)
+
+                    await callback.on_merge_start(file_size)
+                    with open(output, "wb") as outfile:
+                        for part_file in part_files:
+                            if os.path.exists(part_file):
+                                with open(part_file, "rb") as infile:
+                                    while True:
+                                        chunk = infile.read(DEFAULT_CHUNK_SIZE)
+                                        if not chunk:
+                                            break
+                                        outfile.write(chunk)
+                                        await callback.on_merge_update(len(chunk))
+                                os.remove(part_file)
+
+                    await callback.on_merge_complete()
+
+                else:
+                    headers["User-Agent"] = f'FastGet/{VERSION} (Downloading with Single thread; +https://github.com/DiamondGotCat/nercone-fastget/)'
+                    async with client.stream(method=method, url=url, data=data, json=json, params=params, headers=headers) as response:
+                        response.raise_for_status()
+                        with open(output, "wb") as f:
+                            async for chunk in response.aiter_bytes(chunk_size=DEFAULT_CHUNK_SIZE):
+                                f.write(chunk)
+                                await callback.on_update(0, len(chunk))
+
+                await callback.on_complete()
+                return output
+
+            else:
+                content_buffer = bytearray()
+                headers["User-Agent"] = f'FastGet/{VERSION} (Downloading with Single thread; +https://github.com/DiamondGotCat/nercone-fastget/)'
+
+                async with client.stream(method=method, url=url, data=data, json=json, params=params, headers=headers) as response:
+                    response.raise_for_status()
+                    async for chunk in response.aiter_bytes(chunk_size=DEFAULT_CHUNK_SIZE):
+                        content_buffer.extend(chunk)
+                        await callback.on_update(0, len(chunk))
+
+                await callback.on_complete()
+                content = bytes(content_buffer)
+                response._content = content  # type: ignore[attr-defined]
+                return FastGetResponse(response, content)
+
+def run_sync(coro: Awaitable[T]) -> T:
+    try:
+        loop = asyncio.get_event_loop()
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+    return loop.run_until_complete(coro)
+
+def download(url: str, output: str, **kwargs) -> str | FastGetResponse:
+    session = FastGetSession(
+        max_threads=kwargs.pop("threads", DEFAULT_THREADS),
+        http1=not kwargs.pop("no_http1", False),
+        http2=not kwargs.pop("no_http2", False)
+    )
+    return run_sync(session.process("GET", url, output=output, **kwargs))
+
+def request(method: str, url: str, **kwargs) -> str | FastGetResponse:
+    session = FastGetSession(
+        max_threads=kwargs.pop("threads", DEFAULT_THREADS),
+        http1=not kwargs.pop("no_http1", False),
+        http2=not kwargs.pop("no_http2", False)
+    )
+    return run_sync(session.process(method, url, output=None, **kwargs))
+
+def get(url: str, **kwargs) -> str | FastGetResponse:
+    return request("GET", url, **kwargs)
+
+def post(url: str, **kwargs) -> str | FastGetResponse:
+    return request("POST", url, **kwargs)