nercone-fastget 5.3.4__tar.gz

nercone_fastget-5.3.4/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.3
+Name: nercone-fastget
+Version: 5.3.4
+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: nercone-modern
+Requires-Dist: curl-cffi
+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/)
+- `rich` [PyPI↗︎](https://pypi.org/project/rich/)
+- `requests` [PyPI↗︎](https://pypi.org/project/requests/)
+
+## Installation
+
+### using uv (recommended)
+```
+uv tool install nercone-fastget
+```
+
+### using pip3
+
+**System Python:**
+```
+pip3 install nercone-fastget --break-system-packages
+```
+
+**Venv Python:**
+```
+pip3 install nercone-fastget
+```
+
+## Update
+
+### using uv (recommended)
+```
+uv tool install nercone-fastget --upgrade
+```
+
+### using 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 ~> fastget -h
+usage: FastGet [-h] [-o OUTPUT] [-t THREADS] url
+
+High-speed File Downloading Tool
+
+positional arguments:
+  url
+
+options:
+  -h, --help            show this help message and exit
+  -o OUTPUT, --output OUTPUT
+  -t THREADS, --threads THREADS
+```
+
+### Download with default number of threads
+```
+fastget <url>
+```
+
+```
+nercone@demo ~> fastget https://download.fedoraproject.org/pub/fedora/linux/releases/43/Workstation/x86_64/iso/Fedora-Workstation-Live-43-1.6.x86_64.iso
+Total file size: 2.74GB (2,742,190,080 B)
+(---------------------) DL All -  7% ( 1552/20922) | No Message
+(---------------------) DL #1 -  7% (  348/5231) | No Message
+(---------------------) DL #2 - 12% (  637/5231) | No Message
+(---------------------) DL #3 -  6% (  315/5231) | No Message
+(---------------------) DL #4 -  5% (  252/5231) | No Message
+```
+
+### Download with custom number of threads
+```
+fastget <url> [-t <number of threads>]
+```
+
+```
+nercone@demo ~> fastget https://download.fedoraproject.org/pub/fedora/linux/releases/43/Workstation/x86_64/iso/Fedora-Workstation-Live-43-1.6.x86_64.iso -t 8
+Total file size: 2.74GB (2,742,190,080 B)
+(---------------------) DL All -  15% ( 3142/20922) | No Message
+(---------------------) DL #1 -  19% ( 496/2616) | No Message
+(---------------------) DL #2 -  12% ( 306/2616) | No Message
+(---------------------) DL #3 -  21% ( 562/2616) | No Message
+(---------------------) DL #4 -  14% ( 361/2616) | No Message
+(---------------------) DL #5 -  20% ( 533/2616) | No Message
+(---------------------) DL #6 -   9% ( 225/2616) | No Message
+(---------------------) DL #7 -  14% ( 368/2616) | No Message
+(---------------------) DL #8 -  11% ( 292/2616) | No Message
+```
+
+---
+
+![PyPI - Version](https://img.shields.io/pypi/v/nercone-fastget)

nercone_fastget-5.3.4/README.md

@@ -0,0 +1,115 @@
+
+<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/)
+- `rich` [PyPI↗︎](https://pypi.org/project/rich/)
+- `requests` [PyPI↗︎](https://pypi.org/project/requests/)
+
+## Installation
+
+### using uv (recommended)
+```
+uv tool install nercone-fastget
+```
+
+### using pip3
+
+**System Python:**
+```
+pip3 install nercone-fastget --break-system-packages
+```
+
+**Venv Python:**
+```
+pip3 install nercone-fastget
+```
+
+## Update
+
+### using uv (recommended)
+```
+uv tool install nercone-fastget --upgrade
+```
+
+### using 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 ~> fastget -h
+usage: FastGet [-h] [-o OUTPUT] [-t THREADS] url
+
+High-speed File Downloading Tool
+
+positional arguments:
+  url
+
+options:
+  -h, --help            show this help message and exit
+  -o OUTPUT, --output OUTPUT
+  -t THREADS, --threads THREADS
+```
+
+### Download with default number of threads
+```
+fastget <url>
+```
+
+```
+nercone@demo ~> fastget https://download.fedoraproject.org/pub/fedora/linux/releases/43/Workstation/x86_64/iso/Fedora-Workstation-Live-43-1.6.x86_64.iso
+Total file size: 2.74GB (2,742,190,080 B)
+(---------------------) DL All -  7% ( 1552/20922) | No Message
+(---------------------) DL #1 -  7% (  348/5231) | No Message
+(---------------------) DL #2 - 12% (  637/5231) | No Message
+(---------------------) DL #3 -  6% (  315/5231) | No Message
+(---------------------) DL #4 -  5% (  252/5231) | No Message
+```
+
+### Download with custom number of threads
+```
+fastget <url> [-t <number of threads>]
+```
+
+```
+nercone@demo ~> fastget https://download.fedoraproject.org/pub/fedora/linux/releases/43/Workstation/x86_64/iso/Fedora-Workstation-Live-43-1.6.x86_64.iso -t 8
+Total file size: 2.74GB (2,742,190,080 B)
+(---------------------) DL All -  15% ( 3142/20922) | No Message
+(---------------------) DL #1 -  19% ( 496/2616) | No Message
+(---------------------) DL #2 -  12% ( 306/2616) | No Message
+(---------------------) DL #3 -  21% ( 562/2616) | No Message
+(---------------------) DL #4 -  14% ( 361/2616) | No Message
+(---------------------) DL #5 -  20% ( 533/2616) | No Message
+(---------------------) DL #6 -   9% ( 225/2616) | No Message
+(---------------------) DL #7 -  14% ( 368/2616) | No Message
+(---------------------) DL #8 -  11% ( 292/2616) | No Message
+```
+
+---
+
+![PyPI - Version](https://img.shields.io/pypi/v/nercone-fastget)

nercone_fastget-5.3.4/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 = "5.3.4"
+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 = [
+    "nercone-modern",
+    "curl_cffi",
+    "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-5.3.4/src/nercone_fastget/__main__.py

@@ -0,0 +1,189 @@
+import os
+import math
+import argparse
+import asyncio
+import sys
+from . import fastget
+from urllib.parse import urlparse, unquote
+from nercone_modern.logging import ModernLogging
+from nercone_modern.progressbar import ModernProgressBar
+
+class CLIProgress(fastget.ProgressCallback):
+    def __init__(self, logger: ModernLogging):
+        self.logger = logger
+        self.all_bar = None
+        self.thread_bars = []
+        self.chunk_size_display = 1024 * 128
+        self.merge_accumulated = 0
+        self.merge_bar = None
+
+    async def on_start(self, total_size: int, threads: int, http_version: str, final_url: str, verify_was_enabled: bool) -> None:
+        self.logger.log(f"File size: {total_size:,} bytes")
+        parsed_url = urlparse(final_url)
+        protocol = "HTTPS" if parsed_url.scheme.lower() == 'https' else "HTTP"
+        details = [http_version.upper()]
+        if protocol == "HTTPS":
+            details.append("TLS")
+            details.append("Verified" if verify_was_enabled else "Unverified")
+        connection_type = f"{protocol} ({', '.join(details)})"
+        self.logger.log(f"Connection Type: {connection_type}")
+        self.logger.log(f"Threads: {threads}")
+        if total_size > 0:
+            total_steps = max(1, math.ceil(total_size / self.chunk_size_display))
+            self.all_bar = ModernProgressBar(total=total_steps, process_name="Total", spinner_mode=False)
+            self.all_bar.start()
+            if threads > 1:
+                part_size = total_size // threads
+                for i in range(threads):
+                    p_steps = max(1, math.ceil(part_size / self.chunk_size_display))
+                    bar = ModernProgressBar(total=p_steps, process_name=f"DL #{i+1}", spinner_mode=False)
+                    bar.start()
+                    self.thread_bars.append(bar)
+
+    async def on_update(self, worker_id: int, loaded: int) -> None:
+        if self.thread_bars and worker_id < len(self.thread_bars):
+            self.thread_bars[worker_id].update()
+
+        if self.all_bar:
+            self.all_bar.update()
+
+    async def on_complete(self) -> None:
+        if self.all_bar:
+            self.all_bar.finish()
+
+        for b in self.thread_bars:
+            b.finish()
+
+    async def on_merge_start(self, total_size: int) -> None:
+        self.merge_accumulated = 0
+        if total_size > 0:
+            total_steps = max(1, math.ceil(total_size / self.chunk_size_display))
+            self.merge_bar = ModernProgressBar(total=total_steps, process_name="Merge", spinner_mode=False)
+            self.merge_bar.start()
+
+    async def on_merge_update(self, loaded: int) -> None:
+        if self.merge_bar:
+            self.merge_accumulated += loaded
+            while self.merge_accumulated >= self.chunk_size_display:
+                self.merge_bar.update()
+                self.merge_accumulated -= self.chunk_size_display
+
+    async def on_merge_complete(self) -> None:
+        if self.merge_bar:
+            self.merge_bar.finish()
+
+    async def on_error(self, msg: str) -> None:
+        if self.logger:
+            self.logger.log(msg, "ERROR")
+
+async def async_main() -> None:
+    parser = argparse.ArgumentParser(prog='fastget', description='Modern High-Performance Downloader')
+    parser.add_argument('url', help="Target URL")
+
+    parser.add_argument('-o', '--output', help="File destination")
+    parser.add_argument('-X', '--method', default='GET', help="HTTP method (GET/POST)")
+    parser.add_argument('-d', '--data', help="Data for POST method")
+    parser.add_argument('-H', '--header', action='append', help="Custom Headers")
+    parser.add_argument('-t', '--threads', type=int, default=fastget.DEFAULT_THREADS, help="Number of threads to use for downloading")
+    parser.add_argument('-p', '--print', action='store_true', help="Output data directly to stdout without saving to a file")
+
+    strategy_group = parser.add_mutually_exclusive_group()
+    strategy_group.add_argument('-s', '--storage', '--low-memory', action='store_const', const='storage', dest='strategy', help="Avoid using memory as much as possible, and perform tasks such as saving destinations and merging on received data only on the storage device as much as possible. (default)")
+    strategy_group.add_argument('-m', '--memory', '--low-storage', action='store_const', const='memory', dest='strategy', help="Utilize memory efficiently to reduce maximum concurrent storage usage.")
+    parser.set_defaults(strategy='storage')
+
+    parser.add_argument('--no-verify', action='store_true', help="In the case of HTTPS, if a secure connection cannot be established, the system will continue to operate normally.")
+    parser.add_argument('--no-info', action='store_true', help="Suppresses all displays such as progress bars. If --print is used, only data is output to stdout.")
+
+    parser.add_argument('--no-http1', action='store_true', help="Do not use HTTP/1 or HTTP/1.1")
+    parser.add_argument('--no-http2', action='store_true', help="Do not use HTTP/2")
+    parser.add_argument('--no-http3', action='store_true', help="Do not use HTTP/3")
+
+    args = parser.parse_args()
+
+    if args.print and args.output:
+        parser.error("If -p/--print is specified, -o/--output cannot be specified.")
+
+    if args.no_info:
+        logger = None
+        callback = fastget.ProgressCallback()
+    else:
+        logger = ModernLogging("FastGet")
+        callback = CLIProgress(logger)
+
+    headers = {}
+    if args.header:
+        for h in args.header:
+            if ':' in h:
+                k, v = h.split(':', 1)
+                headers[k.strip()] = v.strip()
+
+    method = args.method.upper()
+    if args.data:
+        method = 'POST'
+
+    session = fastget.FastGetSession(
+        max_threads=args.threads,
+        http1=not args.no_http1,
+        http2=not args.no_http2,
+        http3=not args.no_http3,
+        verify=not args.no_verify
+    )
+
+    start_time = 0
+    if logger:
+        start_time = asyncio.get_running_loop().time()
+
+    try:
+        if args.print:
+            result = await session.process(
+                method=method, 
+                url=args.url, 
+                data=args.data, 
+                headers=headers, 
+                callback=callback
+            )
+            sys.stdout.buffer.write(result.content)
+        else:
+            output = args.output
+            if not output:
+                parsed = urlparse(args.url)
+                output = unquote(os.path.basename(parsed.path)) or "downloaded_file"
+
+            path = await session.process(
+                method=method, 
+                url=args.url, 
+                output=output, 
+                data=args.data, 
+                headers=headers, 
+                callback=callback,
+                strategy=args.strategy
+            )
+            if logger:
+                end_time = asyncio.get_running_loop().time()
+                duration_ms = (end_time - start_time) * 1000
+                logger.log(f"Completed in {duration_ms:.2f}ms")
+                logger.log(f"Saved to: {path}")
+
+    except fastget.FastGetError as e:
+        if logger:
+            logger.log(str(e), "CRITICAL")
+        else:
+            print(f"Error: {e}", file=sys.stderr, flush=True)
+    except Exception as e:
+        if logger:
+            logger.log(f"Unexpected error: {e}", "CRITICAL")
+        else:
+            print(f"Unexpected error: {e}", file=sys.stderr, flush=True)
+
+def main() -> None:
+    try:
+        import uvloop
+        uvloop.install()
+    except ImportError:
+        pass
+    
+    asyncio.run(async_main())
+
+if __name__ == "__main__":
+    main()

nercone_fastget-5.3.4/src/nercone_fastget/fastget.py

@@ -0,0 +1,267 @@
+import os
+import asyncio
+from curl_cffi import aio
+from curl_cffi.errors import CurlError
+from curl_cffi.const import HTTPVersion
+from importlib.metadata import version
+from typing import Union, Optional, Dict, Any, TypeVar, Awaitable, List
+
+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_error(self, msg: str) -> None: pass
+
+class FastGetResponse:
+    def __init__(self, original: aio.AsyncClient.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.content.decode(self._r.encoding or 'utf-8', errors='replace')
+
+    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, http3: bool = True, verify: bool = True, follow_redirects: bool = True):
+        self.max_threads = max_threads
+
+        self.http_versions_to_try = []
+        if http3:
+            self.http_versions_to_try.append(HTTPVersion.V3)
+        if http2:
+            self.http_versions_to_try.append(HTTPVersion.V2)
+        if http1:
+            self.http_versions_to_try.append(HTTPVersion.V1_1)
+
+        if not self.http_versions_to_try:
+            raise ValueError("At least one of HTTP/1, HTTP/2, or HTTP/3 must be enabled.")
+
+        self.client_args = {
+            "verify": verify,
+            "follow_redirects": follow_redirects,
+            "timeout": DEFAULT_TIMEOUT,
+        }
+
+    async def _get_info(self, client: aio.AsyncClient, method: str, url: str, **kwargs) -> tuple[int, bool, bool, Optional[aio.AsyncClient.Response]]:
+        headers = kwargs.get("headers", {}).copy()
+        headers["User-Agent"] = f'FastGet/{VERSION} (Info)'
+        if method.upper() != "GET":
+            return 0, False, False, None
+
+        try:
+            head_resp = await client.head(url, headers=headers)
+            head_resp.raise_for_status()
+            size = int(head_resp.headers.get("content-length", 0))
+            accept_ranges = head_resp.headers.get("accept-ranges", "").lower() == "bytes"
+            reject_fg = head_resp.headers.get("rejectfastget", "").lower() in ["true", "1", "yes"]
+            return size, accept_ranges, reject_fg, head_resp
+
+        except CurlError:
+            try:
+                get_headers = headers.copy()
+                get_headers["Range"] = "bytes=0-0"
+                get_resp = await client.get(url, headers=get_headers)
+                get_resp.raise_for_status()
+                size_str = "0"
+                if get_resp.status_code == 206 and "content-range" in get_resp.headers:
+                    content_range = get_resp.headers["content-range"]
+                    if '/' in content_range:
+                        size_str = content_range.split('/')[-1]
+                else:
+                    size_str = get_resp.headers.get("content-length", "0")
+                
+                size = int(size_str) if size_str.isdigit() else 0
+                accept_ranges = get_resp.headers.get("accept-ranges", "").lower() == "bytes" or get_resp.status_code == 206
+                reject_fg = get_resp.headers.get("rejectfastget", "").lower() in ["true", "1", "yes"]
+                return size, accept_ranges, reject_fg, get_resp
+            except CurlError:
+                raise
+
+    async def _download_worker_to_storage(self, client: aio.AsyncClient, method: str, url: str, start: int, end: int, worker_id: int, total_threads: int, part_path: str, callback: ProgressCallback, **kwargs) -> None:
+        headers = kwargs.get("headers", {}).copy()
+        headers["Range"] = f"bytes={start}-{end}"
+        headers["User-Agent"] = f'FastGet/{VERSION} (Worker {worker_id+1}/{total_threads})'
+        kwargs["headers"] = headers
+        for attempt in range(DEFAULT_RETRIES):
+            try:
+                response = await client.request(method, url, **kwargs)
+                response.raise_for_status()
+                with open(part_path, "wb") as f:
+                    async for chunk in response.aiter_content(chunk_size=DEFAULT_CHUNK_SIZE):
+                        f.write(chunk)
+                        await callback.on_update(worker_id, len(chunk))
+                return
+            except CurlError as e:
+                if attempt == DEFAULT_RETRIES - 1:
+                    await callback.on_error(f"Worker {worker_id+1} failed: {e}")
+                    raise
+                await asyncio.sleep(1)
+
+    async def _download_worker_to_memory(self, client: aio.AsyncClient, method: str, url: str, start: int, end: int, worker_id: int, total_threads: int, callback: ProgressCallback, **kwargs) -> bytes:
+        headers = kwargs.get("headers", {}).copy()
+        headers["Range"] = f"bytes={start}-{end}"
+        headers["User-Agent"] = f'FastGet/{VERSION} (Worker {worker_id+1}/{total_threads})'
+        kwargs["headers"] = headers
+        part_buffer = bytearray()
+        for attempt in range(DEFAULT_RETRIES):
+            try:
+                response = await client.request(method, url, **kwargs)
+                response.raise_for_status()
+                async for chunk in response.aiter_content(chunk_size=DEFAULT_CHUNK_SIZE):
+                    part_buffer.extend(chunk)
+                    await callback.on_update(worker_id, len(chunk))
+                return bytes(part_buffer)
+            except CurlError as e:
+                if attempt == DEFAULT_RETRIES - 1:
+                    await callback.on_error(f"Worker {worker_id+1} failed: {e}")
+                    raise
+                part_buffer.clear()
+                await asyncio.sleep(1)
+        return b""
+
+    async def process(self, method: str, url: str, output: Optional[str] = None, data: Any = None, json: Any = None, params: Any = None, headers: Dict = None, callback: Optional[ProgressCallback] = None, strategy: str = 'storage') -> Union[str, FastGetResponse]:
+        callback = callback or ProgressCallback()
+        headers = headers or {}
+        req_kwargs = {"data": data, "json": json, "params": params, "headers": headers}
+
+        client = None
+        last_error = None
+        info_result = None
+
+        for version in self.http_versions_to_try:
+            client_args = self.client_args.copy()
+            client_args["http_version"] = version
+            temp_client = aio.AsyncClient(**client_args)
+            try:
+                info_result = await self._get_info(temp_client, method, url, **req_kwargs)
+                client = temp_client
+                break
+            except CurlError as e:
+                last_error = e
+                await temp_client.close()
+                is_last_attempt = (version == self.http_versions_to_try[-1])
+                if not is_last_attempt:
+                    await callback.on_error(f"Request with {version.name} failed. Trying fallback...")
+
+        if not client:
+            await callback.on_error(f"All HTTP versions failed. Last error: {last_error}")
+            raise FastGetError(f"Failed to connect to {url} with all tried HTTP versions.") from last_error
+
+        try:
+            file_size, is_resumable, is_rejected, info_response = info_result
+
+            if method.upper() == "GET" and not info_response:
+                raise FastGetError(f"Failed to retrieve file information from {url}")
+
+            use_parallel = (method.upper() == "GET" and is_resumable and not is_rejected and file_size > 0 and output is not None and self.max_threads > 1)
+            threads = self.max_threads if use_parallel else 1
+            http_version = info_response.http_version if info_response else "UNKNOWN"
+            final_url = str(info_response.url) if info_response else url
+            verify_was_enabled = self.client_args.get("verify", True)
+
+            await callback.on_start(file_size, threads, http_version, final_url, verify_was_enabled)
+            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 = []
+                    if strategy == 'memory':
+                        for i in range(threads):
+                            start = i * part_size
+                            end = file_size - 1 if i == threads - 1 else start + part_size - 1
+                            tasks.append(self._download_worker_to_memory(client, method, url, start, end, i, threads, callback, **req_kwargs))
+                        parts_in_memory: List[bytes] = await asyncio.gather(*tasks)
+                        await callback.on_merge_start(file_size)
+                        with open(output, "wb") as outfile:
+                            for part_data in parts_in_memory:
+                                outfile.write(part_data)
+                                await callback.on_merge_update(len(part_data))
+                        await callback.on_merge_complete()
+                    else:
+                        part_files = []
+                        for i in range(threads):
+                            start = i * part_size
+                            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_to_storage(client, method, url, start, end, i, threads, part_path, callback, **req_kwargs))
+                        await asyncio.gather(*tasks)
+                        await callback.on_merge_start(file_size)
+                        with open(output, "wb") as outfile:
+                            for part_file in part_files:
+                                try:
+                                    with open(part_file, "rb") as infile:
+                                        while chunk := infile.read(DEFAULT_CHUNK_SIZE):
+                                            outfile.write(chunk)
+                                            await callback.on_merge_update(len(chunk))
+                                    os.remove(part_file)
+                                except FileNotFoundError:
+                                    await callback.on_error(f"Part file {part_file} not found during merge.")
+                        await callback.on_merge_complete()
+                else:
+                    headers["User-Agent"] = f'FastGet/{VERSION} (Single-Thread)'
+                    response = await client.request(method, url, **req_kwargs)
+                    response.raise_for_status()
+                    with open(output, "wb") as f:
+                        async for chunk in response.aiter_content(chunk_size=DEFAULT_CHUNK_SIZE):
+                            f.write(chunk)
+                            await callback.on_update(0, len(chunk))
+                await callback.on_complete()
+                return output
+            else:
+                headers["User-Agent"] = f'FastGet/{VERSION} (Single-Thread/Memory)'
+                response = await client.request(method, url, **req_kwargs)
+                response.raise_for_status()
+                await callback.on_update(0, len(response.content))
+                await callback.on_complete()
+                return FastGetResponse(response, response.content)
+        finally:
+            if client:
+                await client.close()
+
+def run_sync(coro: Awaitable[T]) -> T:
+    try: loop = asyncio.get_running_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:
+    session = FastGetSession(max_threads=kwargs.pop("threads", DEFAULT_THREADS), http1=not kwargs.pop("no_http1", False), http2=not kwargs.pop("no_http2", False), http3=not kwargs.pop("no_http3", False))
+    return run_sync(session.process("GET", url, output=output, **kwargs))
+
+def request(method: str, url: str, **kwargs) -> FastGetResponse:
+    session = FastGetSession(max_threads=kwargs.pop("threads", DEFAULT_THREADS), http1=not kwargs.pop("no_http1", False), http2=not kwargs.pop("no_http2", False), http3=not kwargs.pop("no_http3", False))
+    return run_sync(session.process(method, url, output=None, **kwargs))
+
+def get(url: str, **kwargs) -> FastGetResponse:
+    return request("GET", url, **kwargs)
+
+def post(url: str, **kwargs) -> FastGetResponse:
+    return request("POST", url, **kwargs)