python-httpfile 0.0.5.4__py3-none-any.whl → 0.0.6.1__py3-none-any.whl

httpfile/__init__.py

@@ -4,156 +4,113 @@
 from __future__ import annotations
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 0, 5)
-__all__ = ["HTTPFileReader", "AsyncHTTPFileReader"]
+__version__ = (0, 0, 6)
+__all__ = ["HTTPFileReader", "AsyncHTTPFileReader", "MultipartHTTPFileReader", "AsyncMultipartHTTPFileReader"]
 
-import errno
-
-from collections.abc import Awaitable, Callable, Mapping
-from functools import cached_property, partial
-from importlib.util import find_spec
+from collections.abc import AsyncIterator, Awaitable, Buffer, Callable, Iterable, Iterator
+from functools import cached_property
 from inspect import isawaitable
 from io import (
-    BufferedReader, RawIOBase, TextIOWrapper, UnsupportedOperation, DEFAULT_BUFFER_SIZE, 
+    BufferedReader, BytesIO, RawIOBase, TextIOWrapper, UnsupportedOperation, 
+    DEFAULT_BUFFER_SIZE, 
 )
-from os import fstat, stat, PathLike
-from shutil import COPY_BUFSIZE # type: ignore
+try:
+    from shutil import COPY_BUFSIZE # type: ignore
+except ImportError:
+    COPY_BUFSIZE = 1 << 16
 from typing import cast, overload, Any, BinaryIO, Literal, Self
-from types import MappingProxyType
 from warnings import warn
 
+from argtools import argcount
 from asynctools import ensure_async, run_async
-from filewrap import AsyncBufferedReader, AsyncTextIOWrapper
-from http_response import get_filename, get_length, get_range, get_total_length, is_chunked, is_range_request
-from property import funcproperty
-
-
-def get_filesize(
-    file, 
-    /, 
-    dont_read: bool = True, 
-) -> int:
-    if isinstance(file, (bytes, str, PathLike)):
-        return stat(file).st_size
-    curpos = 0
-    try:
-        curpos = file.seek(0, 1)
-        seekable = True
-    except Exception:
-        seekable = False
-    if not seekable:
-        try:
-            curpos = file.tell()
-        except Exception:
-            pass
-    try:
-        return len(file) - curpos
-    except TypeError:
-        pass
-    if hasattr(file, "fileno"):
-        try:
-            return fstat(file.fileno()).st_size - curpos
-        except Exception:
-            pass
-    if hasattr(file, "headers"):
-        l = get_length(file)
-        if l is not None:
-            return l - curpos
-    if seekable:
-        try:
-            return file.seek(0, 2) - curpos
-        finally:
-            file.seek(curpos)
-    if dont_read:
-        return -1
-    total = 0
-    if hasattr(file, "readinto"):
-        readinto = file.readinto
-        buf = bytearray(COPY_BUFSIZE)
-        while (size := readinto(buf)):
-            total += size
-    elif hasattr(file, "read"):
-        read = file.read
-        while (chunk := read(COPY_BUFSIZE)):
-            total += len(chunk)
-    else:
-        return -1
-    return total
-
-
-class HTTPFileReader(RawIOBase, BinaryIO):
-    url: str | Callable[[], str]
-    response: Any
-    length: int
-    chunked: bool
-    start: int
-    urlopen: Callable
-    headers: Mapping
-    seek_threshold: int
-    _seekable: bool
+from errno2 import errno
+from filewrap import (
+    buffer_length, bytes_iter_to_reader, bytes_iter_to_async_reader, 
+    to_bytes_view, AsyncBufferedReader, AsyncTextIOWrapper, 
+)
+from http_request import SupportsGeturl
+from http_response import (
+    get_filename, get_range, get_status_code, get_total_length, is_range_request, 
+)
+from yarl import URL
+
+
+def coalesce(*vals, base=None):
+    for v in vals:
+        if v is not base:
+            return v
+    return base
+
+
+def geturl(url, /) -> str:
+    if callable(url):
+        url = url()
+    if isinstance(url, SupportsGeturl):
+        return url.geturl()
+    return str(url)
+
+
+async def ageturl(url, /) -> str:
+    if callable(url):
+        url = url()
+        if isawaitable(url):
+            url = await url
+    if isinstance(url, SupportsGeturl):
+        url = url.geturl()
+        if isawaitable(url):
+            url = await url
+        return url
+    return str(url)
+
+
+class HTTPFileReader[Response](RawIOBase, BinaryIO):
 
     def __init__(
         self, 
         /, 
-        url: str | Callable[[], str], 
-        headers: None | Mapping = None, 
+        url: (
+            str | SupportsGeturl | URL | 
+            Callable[[], str] | Callable[[], SupportsGeturl] | Callable[[], URL]
+        ), 
         start: int = 0, 
-        # NOTE: If the offset of the forward seek is not higher than this value, 
-        #       it will be directly read and discarded, default to 1 MB
         seek_threshold: int = 1 << 20, 
-        urlopen = None, 
+        request: None | Callable[..., Response] = None, 
+        get_file: None | str | Callable[[Response], Any] = None, 
+        **request_kwargs, 
     ):
-        if headers:
-            headers = {**headers, "accept-encoding": "identity"}
-        else:
-            headers = {"accept-encoding": "identity"}
-        if start > 0:
-            headers["range"] = f"bytes={start}-"
-        elif start < 0:
-            headers["range"] = f"bytes={start}"
-        if urlopen is None:
-            from http_request.extension.request import urlopen
-        if callable(url):
-            geturl = url
-            def url():
-                url = geturl()
-                headers_extra = getattr(url, "headers")
-                if headers_extra:
-                    headers.update(headers_extra)
-                return url
-        elif hasattr(url, "headers"):
-            headers_extra = getattr(url, "headers")
-            if headers_extra:
-                headers.update(headers_extra)
-        response = urlopen(url() if callable(url) else url, headers=headers)
-        if start:
-            rng = get_range(response)
-            if not rng:
-                raise OSError(errno.ESPIPE, "non-seekable")
-            start = rng[0]
-        self.__dict__.update(
-            url = url, 
-            response = response, 
-            length = get_total_length(response) or 0, 
-            chunked = is_chunked(response), 
-            start = start, 
-            closed = False, 
-            urlopen = urlopen, 
-            headers = MappingProxyType(headers), 
-            seek_threshold = max(seek_threshold, 0), 
-            _seekable = is_range_request(response), 
-        )
+        if start < 0:
+            raise ValueError("`start` cannot be < 0")
+        self._closed = False
+        self._pos = start
+        self._url = url
+        self.seek_threshold = max(seek_threshold, 0)
+        if request is None:
+            from urllib3_future_request import request_sync as request # type: ignore
+        self.request = cast(Callable[..., Response], request)
+        if isinstance(get_file, str):
+            if get_file:
+                is_method = get_file.endswith("()")
+                attrs = get_file.removesuffix("()").split(".")
+                def get_file(file, /):
+                    for attr in attrs:
+                        file = getattr(file, attr)
+                    if is_method:
+                        file = file()
+                    return file
+            else:
+                get_file = lambda file, /: file
+        self.get_file = get_file
+        self.request_kwargs = request_kwargs
+        headers = request_kwargs["headers"] = dict(request_kwargs.get("headers") or ())
+        headers["accept-encoding"] = "identity"
 
     def __del__(self, /):
-        try:
-            self.close()
-        except:
-            pass
+        self.close()
 
-    def __enter__(self, /):
+    def __enter__(self, /) -> Self:
         return self
 
-    def __exit__(self, /, *exc_info):
+    def __exit__(self, /, *_) -> None:
         self.close()
 
     def __iter__(self, /) -> Self:
@@ -163,215 +120,378 @@ class HTTPFileReader(RawIOBase, BinaryIO):
         return self.length
 
     def __next__(self, /) -> bytes:
-        line = self.readline()
-        if line:
+        if line := self.readline():
             return line
-        else:
-            raise StopIteration
+        raise StopIteration
 
     def __repr__(self, /) -> str:
         cls = type(self)
-        module = cls.__module__
-        name = cls.__qualname__
-        if module != "__main__":
-            name = module + "." + name
-        return f"{name}(url={self.url!r}, headers={self.headers!r}, start={self.tell()}, seek_threshold={self.seek_threshold}, urlopen={self.urlopen!r})"
+        kwargs = {
+            "url": self._url, 
+            "start": self._pos, 
+            "seek_threshold": self.seek_threshold, 
+            "request": self.request, 
+            "get_file": self.get_file, 
+            **self.request_kwargs, 
+        }
+        return f"{cls.__module__}.{cls.__qualname__}({', '.join(map('%s=%r'.__mod__, kwargs.items()))})"
 
-    def __setattr__(self, attr, val, /):
-        raise TypeError("can't set attribute")
+    @property
+    def closed(self, /) -> bool:
+        return self._closed
 
-    def _add_start(self, delta: int, /):
-        if not self.file_can_tell:
-            self.__dict__["start"] += delta
+    @property
+    def response_closed(self, /) -> bool:
+        file = self.__dict__.get("response")
+        while file:
+            if hasattr(file, "closed"):
+                return file.closed
+            elif hasattr(file, "is_closed"):
+                closed = file.is_closed
+                if callable(closed):
+                    closed = closed()
+                return closed
+            file = getattr(file, "raw", None)
+        return self.closed
+
+    def _init_info(self, /, key: str = "length"):
+        response = self.__dict__.get("response")
+        if response is None:
+            from urllib3_future_request import request_sync as request
+            request_kwargs = dict(self.request_kwargs, parse=...)
+            headers = request_kwargs["headers"] = dict(request_kwargs.get("headers") or ())
+            headers["range"] = "bytes=0-0"
+            response = request(self._geturl(), **request_kwargs)
+        self._seekable = not is_range_request(response)
+        self.length = coalesce(get_total_length(response), -1)
+        match key:
+            case "length":
+                return self.length
+            case "seekable":
+                return self._seekable
 
     @cached_property
-    def file_can_tell(self, /) -> bool:
-        try:
-            self.file.tell()
-            return True
-        except (AttributeError, TypeError, OSError):
-            return False
+    def _seekable(self, /) -> bool:
+        return self._init_info("seekable")
 
-    @funcproperty
-    def file_closed(self, /) -> bool:
-        return self.file.closed
+    @cached_property
+    def length(self, /) -> int:
+        return self._init_info("length")
+
+    @cached_property
+    def response(self, /):
+        self.reconnect()
+        return self.__dict__.get("response")
 
     @property
-    def closed(self, /) -> bool:
-        return self.__dict__["closed"]
+    def mode(self, /) -> str:
+        return "rb"
+
+    @property
+    def name(self, /) -> str:
+        return get_filename(self.response)
+
+    def _get_file(self, /):
+        response = self.__dict__.get("response")
+        if not response:
+            self.reconnect()
+            response = self.__dict__.get("response")
+            if not response:
+                return None
+        if get_file := self.get_file or (getattr(response, "get_file", None)):
+            file = get_file(response)
+            if hasattr(file, "read"):
+                return file
+            elif isinstance(file, Iterator):
+                return bytes_iter_to_reader(file)
+        else:
+            if file := getattr(response, "file", None):
+                return file
+            if hasattr(response, "read"):
+                read = response.read
+                if argcount(read):
+                    return response
+            for attr in (
+                "iter_bytes", "iter_chunks", "iter_chunked", "iter_stream", 
+                "iter_body", "iter_raw", "iter_content", 
+            ):
+                method = getattr(response, attr, None)
+                if method is not None:
+                    file = method()
+                    if isinstance(file, Iterator):
+                        return bytes_iter_to_reader(file)
+            for attr in ("stream", "body", "raw", "content"):
+                file = getattr(response, attr, None)
+                if file is not None:
+                    if hasattr(file, "read") and argcount(getattr(file, "read")):
+                        return file
+                    if callable(file):
+                        file = file()
+                    if isinstance(file, Buffer):
+                        return BytesIO(file)
+                    elif isinstance(file, Iterator):
+                        return bytes_iter_to_reader(file)
+        raise TypeError("can't determine how to `read`")
+
+    def _geturl(self, /) -> str:
+        return geturl(self._url)
 
     def close(self, /):
         if not self.closed:
-            self.response.close()
-            self.__dict__["closed"] = True
-
-    @funcproperty
-    def file(self, /) -> BinaryIO:
-        return self.response
+            if response := self.__dict__.get("response"):
+                try:
+                    response.close()
+                except (AttributeError, TypeError):
+                    pass
+            self._closed = True
 
     def fileno(self, /) -> int:
-        return self.file.fileno()
+        file = self.__dict__.get("response")
+        while file:
+            if hasattr(file, "fileno"):
+                return file.fileno()
+            file = getattr(file, "raw", None)
+        return 0
 
     def flush(self, /):
-        if self.closed:
-            raise ValueError("I/O operation on closed file.")
-        return self.file.flush()
+        if not self.closed:
+            file = self.__dict__.get("response")
+            while file:
+                if hasattr(file, "flush"):
+                    return file.flush()
+                file = getattr(file, "raw", None)
 
     def isatty(self, /) -> bool:
         return False
 
-    @cached_property
-    def mode(self, /) -> str:
-        return "rb"
-
-    @cached_property
-    def name(self, /) -> str:
-        return get_filename(self.response)
+    def _readinto(self, buffer: Buffer, /) -> int:
+        read = self.file.read
+        m = to_bytes_view(buffer)
+        size = len(m)
+        start = 0
+        last_intv = size - size % COPY_BUFSIZE
+        while start < size:
+            if start >= last_intv:
+                delta = size - start
+            else:
+                delta = COPY_BUFSIZE
+            data = read(delta)
+            data_len = len(data)
+            m[:data_len] = data
+            start += data_len
+            if data_len < delta:
+                break
+        return start
 
-    def read(self, size: int = -1, /) -> bytes:
-        if self.closed:
-            raise ValueError("I/O operation on closed file.")
-        if size == 0 or not self.chunked and self.tell() >= self.length:
-            return b""
-        if self.file_closed:
-            self.reconnect()
+    def _readline(self, size: None | int = -1, /) -> bytes:
+        read = self.file.read
+        buf = bytearray()
         if size is None or size < 0:
-            data = self.file.read()
+            while b := read(1):
+                buf += b
+                if b == b"\n":
+                    break
+        else:
+            while size and (b := read(1)):
+                buf += b
+                if b == b"\n":
+                    break
+                size -= 1
+        return bytes(buf)
+
+    def _readlines(self, hint: int = -1, /) -> list[bytes]:
+        try:
+            readline = self.file.readline
+        except AttributeError:
+            readline = self._readline
+        ls: list[bytes]
+        add = ls.append
+        if hint <= 0:
+            while l := readline():
+                add(l)
         else:
-            data = self.file.read(size)
-        if data:
-            self._add_start(len(data))
-        return data
+            while hint >= 0 and (l := readline()):
+                add(l)
+                hint -= len(l)
+        return ls
 
     def readable(self, /) -> bool:
         return True
 
-    def readinto(self, buffer, /) -> int:
-        if self.closed:
-            raise ValueError("I/O operation on closed file.")
-        if not buffer or not self.chunked and self.tell() >= self.length:
-            return 0
-        if self.file_closed:
-            self.reconnect()
-        try:
-            readinto = self.file.readinto
-        except AttributeError:
-            read = self.file.read
-            def readinto(buffer, /):
-                data = read(len(buffer))
-                size = len(data)
-                buffer[:size] = data
+    def read(self, size: int = -1, /) -> bytes:
+        pos = self._pos
+        if size == 0:
+            return b""
+        length = self.__dict__.get("length")
+        if length is not None:
+            if length == 0 or length > 0 and pos >= length:
+                return b""
+        if "response" not in self.__dict__ or self.closed or self.response_closed:
+            self.reconnect(pos)
+        if file := self.file:
+            try:
+                if size is None or size < 0:
+                    data = file.read()
+                else:
+                    data = file.read(size)
+                if data:
+                    self._pos = pos + len(data)
                 return data
-        size = readinto(buffer)
-        if size:
-            self._add_start(size)
-        return size
+            except:
+                self._pos = pos
+                self.close()
+                raise
+        return b""
+
+    def readinto(self, buffer: Buffer, /) -> int:
+        pos = self._pos
+        if not buffer_length(buffer):
+            return 0
+        length = self.__dict__.get("length")
+        if length is not None:
+            if length == 0 or length > 0 and pos >= length:
+                return 0
+        if "response" not in self.__dict__ or self.closed or self.response_closed:
+            self.reconnect(pos)
+        if file := self.file:
+            try:
+                readinto = file.readinto
+            except AttributeError:
+                readinto = self._readinto
+            try:
+                size = readinto(buffer)
+                if size:
+                    self._pos = pos + size
+                return size
+            except:
+                self._pos = pos
+                self.close()
+                raise
+        return 0
 
     def readline(self, size: None | int = -1, /) -> bytes:
-        if self.closed:
-            raise ValueError("I/O operation on closed file.")
-        if size == 0 or not self.chunked and self.tell() >= self.length:
+        pos = self._pos
+        if size == 0:
             return b""
-        if self.file_closed:
-            self.reconnect()
-        # TODO: if no readline method, give a default impl
-        if size is None or size < 0:
-            data = self.file.readline()
-        else:
-            data = self.file.readline(size)
-        if data:
-            self._add_start(len(data))
-        return data
+        length = self.__dict__.get("length")
+        if length is not None:
+            if length == 0 or length > 0 and pos >= length:
+                return b""
+        if "response" not in self.__dict__ or self.closed or self.response_closed:
+            self.reconnect(pos)
+        if file := self.file:
+            try:
+                readline = file.readline
+            except AttributeError:
+                readline = self._readline
+            try:
+                if size is None or size < 0:
+                    data = readline()
+                else:
+                    data = readline(size)
+                if data:
+                    self._pos = pos + len(data)
+                return data
+            except:
+                self._pos = pos
+                self.close()
+                raise
+        return b""
 
     def readlines(self, hint: int = -1, /) -> list[bytes]:
-        if self.closed:
-            raise ValueError("I/O operation on closed file.")
-        if not self.chunked and self.tell() >= self.length:
-            return []
-        if self.file_closed:
-            self.reconnect()
-        # TODO: if no readlines method, give a default impl
-        ls = self.file.readlines(hint)
-        if ls:
-            self._add_start(sum(map(len, ls)))
-        return ls
+        pos = self._pos
+        length = self.__dict__.get("length")
+        if length is not None:
+            if length == 0 or length > 0 and pos >= length:
+                return []
+        if "response" not in self.__dict__ or self.closed or self.response_closed:
+            self.reconnect(pos)
+        if file := self.file:
+            try:
+                readlines = file.readlines
+            except AttributeError:
+                readlines = self._readlines
+            try:
+                ls = readlines(hint)
+                if ls:
+                    self._pos = pos + sum(map(len, ls))
+                return ls
+            except:
+                self._pos = pos
+                self.close()
+                raise
+        return []
 
     def reconnect(self, /, start: None | int = None) -> int:
-        if not self._seekable:
-            if start is None and self.tell() or start:
-                raise OSError(errno.EOPNOTSUPP, "Unsupport for reconnection of non-seekable streams.")
-            start = 0
         if start is None:
-            start = self.tell()
+            start = self._pos
+        if start and not self.seekable():
+            raise OSError(errno.EOPNOTSUPP, "unsupport for reconnection of non-seekable streams")
+        request_kwargs = self.request_kwargs
+        headers = request_kwargs["headers"] = request_kwargs["headers"]
+        if start >= 0:
+            headers["range"] = f"bytes={start}-"
         elif start < 0:
-            start = self.length + start
-            if start < 0:
-                start = 0
-        if start >= self.length:
-            self.__dict__.update(start=start)
-            return start
-        self.response.close()
-        url = self.url
-        response = self.urlopen(
-            url() if callable(url) else url, 
-            headers={**self.headers, "range": f"bytes={start}-"}
-        )
-        length_new = get_total_length(response)
-        if self.length != length_new:
-            raise OSError(errno.EIO, f"file size changed: {self.length} -> {length_new}")
-        self.__dict__.update(
-            response=response, 
-            start=start, 
-            closed=False, 
-        )
+            headers["range"] = f"bytes={start}"
+        self.close()
+        response = self.request(self._geturl(), **request_kwargs)
+        status_code = get_status_code(response)
+        if not 200 <= status_code < 300:
+            raise OSError(
+                errno.EIO, 
+                {
+                    "code": status_code, 
+                    "response": response, 
+                    "reason": "status code must be in the `range(200, 300)`", 
+                }, 
+            )
+        if start:
+            rng = get_range(response)
+            if not rng:
+                raise OSError(errno.ESPIPE, "non-seekable")
+            start = self._pos = rng[0]
+        self.response = response
+        self.file = self._get_file()
+        self._closed = False
         return start
 
     def seek(self, pos: int, whence: int = 0, /) -> int:
-        if self.closed:
-            raise ValueError("I/O operation on closed file.")
-        if not self._seekable:
+        if not self.seekable():
             raise OSError(errno.EINVAL, "not a seekable stream")
-        if whence == 0:
-            if pos < 0:
-                raise OSError(errno.EINVAL, f"negative seek start: {pos!r}")
-            old_pos = self.tell()
-            if old_pos == pos:
-                return pos
-            if pos > old_pos and (size := pos - old_pos) <= self.seek_threshold:
-                if size <= COPY_BUFSIZE:
-                    self.read(size)
-                else:
-                    buf = bytearray(COPY_BUFSIZE)
-                    readinto = self.readinto
-                    while size > COPY_BUFSIZE:
-                        readinto(buf)
-                        size -= COPY_BUFSIZE
-                    self.read(size)
-            else:
-                self.reconnect(pos)
+        old_pos = self._pos
+        match whence:
+            case 1:
+                pos = old_pos + pos
+            case 2:
+                length = self.__dict__.get("length")
+                if length is None:
+                    length = self._init_info()
+                pos += length
+        if pos < 0:
+            pos = 0
+        if pos == old_pos:
             return pos
-        elif whence == 1:
-            if pos == 0:
-                return self.tell()
-            return self.seek(self.tell() + pos)
-        elif whence == 2:
-            return self.seek(self.length + pos)
-        else:
-            raise OSError(errno.EINVAL, f"whence value unsupported: {whence!r}")
+        if (self.__dict__.get("response") and 
+            self.file and 
+            not self.closed and 
+            not self.response_closed and 
+            pos > old_pos and 
+            (size := pos - old_pos) <= self.seek_threshold
+        ):
+            read = self.read
+            while size > COPY_BUFSIZE:
+                read(COPY_BUFSIZE)
+                size -= COPY_BUFSIZE
+            read(size)
+        return self.reconnect(pos)
 
     def seekable(self, /) -> bool:
         return self._seekable
 
     def tell(self, /) -> int:
-        if self.file_can_tell:
-            start = self.start
-            if start >= self.length:
-                return start
-            return start + self.file.tell()
-        else:
-            return self.start
+        return self._pos
 
-    def truncate(self, size: None | int = None, /):
+    def truncate(self, size: None | int = None, /) -> int:
         raise UnsupportedOperation(errno.ENOTSUP, "truncate")
 
     def writable(self, /) -> bool:
@@ -388,17 +508,21 @@ class HTTPFileReader(RawIOBase, BinaryIO):
     def open(
         cls, 
         /, 
-        url: str | Callable[[], str], 
+        url: (
+            str | SupportsGeturl | URL | 
+            Callable[[], str] | Callable[[], SupportsGeturl] | Callable[[], URL]
+        ), 
         mode: Literal["br", "rb"], 
         *, 
         buffering: None | int = None, 
         encoding: None | str = None, 
         errors: None | str = None, 
         newline: None | str = None, 
-        headers: None | Mapping = None, 
         start: int = 0, 
         seek_threshold: int = 1 << 20, 
-        urlopen = None, 
+        request: None | Callable[..., Response] = None, 
+        get_file: None | str | Callable[[Response], Any] = None, 
+        **request_kwargs, 
     ) -> Self | BufferedReader:
         ...
     @overload
@@ -406,46 +530,55 @@ class HTTPFileReader(RawIOBase, BinaryIO):
     def open(
         cls, 
         /, 
-        url: str | Callable[[], str], 
+        url: (
+            str | SupportsGeturl | URL | 
+            Callable[[], str] | Callable[[], SupportsGeturl] | Callable[[], URL]
+        ), 
         mode: Literal["r", "rt", "tr"] = "r", 
         *, 
         buffering: None | int = None, 
         encoding: None | str = None, 
         errors: None | str = None, 
         newline: None | str = None, 
-        headers: None | Mapping = None, 
         start: int = 0, 
         seek_threshold: int = 1 << 20, 
-        urlopen = None, 
+        request: None | Callable[..., Response] = None, 
+        get_file: None | str | Callable[[Response], Any] = None, 
+        **request_kwargs, 
     ) -> TextIOWrapper:
         ...
     @classmethod
     def open(
         cls, 
         /, 
-        url: str | Callable[[], str], 
+        url: (
+            str | SupportsGeturl | URL | 
+            Callable[[], str] | Callable[[], SupportsGeturl] | Callable[[], URL]
+        ), 
         mode: Literal["r", "rt", "tr", "br", "rb"] = "r", 
         *, 
         buffering: None | int = None, 
         encoding: None | str = None, 
         errors: None | str = None, 
         newline: None | str = None, 
-        headers: None | Mapping = None, 
         start: int = 0, 
         seek_threshold: int = 1 << 20, 
-        urlopen = None, 
+        request: None | Callable[..., Response] = None, 
+        get_file: None | str | Callable[[Response], Any] = None, 
+        **request_kwargs, 
     ) -> Self | BufferedReader | TextIOWrapper:
         file = cls(
             url=url, 
-            headers=headers, 
             start=start, 
             seek_threshold=seek_threshold, 
-            urlopen=urlopen, 
+            request=request, 
+            get_file=get_file, 
+            **request_kwargs, 
         )
         if mode not in ("r", "rt", "tr", "rb", "br"):
             raise OSError(errno.EINVAL, f"invalid (or unsupported) mode: {mode!r}")
         return file.wrap(
-            text_mode="b" not in mode, # type: ignore
+            text_mode="b" not in cast(str, mode), # type: ignore
             buffering=buffering, 
             encoding=encoding, 
             errors=errors, 
@@ -507,6 +640,8 @@ class HTTPFileReader(RawIOBase, BinaryIO):
             line_buffering = True
         else:
             buffer_size = buffering
+        if "response" not in self.__dict__ or self.closed or self.response_closed:
+            self.reconnect()
         raw = self
         buffer: BufferedReader = BufferedReader(raw, buffer_size)
         if text_mode:
@@ -521,34 +656,81 @@ class HTTPFileReader(RawIOBase, BinaryIO):
             return buffer
 
 
-class AsyncHTTPFileReader(HTTPFileReader):
-    url: str | Callable[[], Awaitable[str]] # type: ignore
+class AsyncHTTPFileReader[Response](RawIOBase, BinaryIO):
 
     def __init__(
         self, 
         /, 
-        url: str | Callable[[], str] | Callable[[], Awaitable[str]], 
-        headers: None | Mapping = None, 
+        url: (
+            str | SupportsGeturl | URL | 
+            Callable[[], str] | Callable[[], SupportsGeturl] | Callable[[], URL] | 
+            Callable[[], Awaitable[str]] | Callable[[], Awaitable[SupportsGeturl]] | Callable[[], Awaitable[URL]]
+        ), 
         start: int = 0, 
         seek_threshold: int = 1 << 20, 
-        urlopen = None, 
+        request: None | Callable[..., Awaitable[Response]] = None, 
+        get_file: None | str | Callable[[Response], Any] = None, 
+        **request_kwargs, 
     ):
-        self.__dict__.update(closed=False, start=0, _seekable=True)
-        self.__dict__["_initing"] = run_async(self.__ainit__(
-            url=url, 
-            headers=headers, 
+        if start < 0:
+            raise ValueError("`start` cannot be < 0")
+        self._closed = False
+        self._pos = start
+        self._url = url
+        self.seek_threshold = max(seek_threshold, 0)
+        if request is None:
+            from urllib3_future_request import request_async as request # type: ignore
+        self.request = cast(Callable[..., Awaitable[Response]], request)
+        if isinstance(get_file, str):
+            if get_file:
+                is_method = get_file.endswith("()")
+                attrs = get_file.removesuffix("()").split(".")
+                def get_file(file, /):
+                    for attr in attrs:
+                        file = getattr(file, attr)
+                    if is_method:
+                        file = file()
+                    return file
+            else:
+                get_file = lambda file, /: file
+        self.get_file = get_file
+        self.request_kwargs = request_kwargs
+        headers = request_kwargs["headers"] = dict(request_kwargs.get("headers") or ())
+        headers["accept-encoding"] = "identity"
+
+    @classmethod
+    async def new(
+        cls, 
+        /, 
+        url: (
+            str | SupportsGeturl | URL | 
+            Callable[[], str] | Callable[[], SupportsGeturl] | Callable[[], URL] | 
+            Callable[[], Awaitable[str]] | Callable[[], Awaitable[SupportsGeturl]] | Callable[[], Awaitable[URL]]
+        ), 
+        start: int = 0, 
+        seek_threshold: int = 1 << 20, 
+        request: None | Callable[..., Awaitable[Response]] = None, 
+        get_file: None | str | Callable[[Response], Any] = None, 
+        **request_kwargs, 
+    ) -> Self:
+        self = cls(
+            url, 
             start=start, 
             seek_threshold=seek_threshold, 
-            urlopen=urlopen, 
-        ))
+            request=request, 
+            get_file=get_file, 
+            **request_kwargs, 
+        )
+        await self.reconnect()
+        return self
+
+    def __del__(self, /):
+        self.close()
 
     async def __aenter__(self, /) -> Self:
-        if _initing := self.__dict__.get("_initing"):
-            await _initing
-            self.__dict__.pop("_initing", None)
         return self
 
-    async def __aexit__(self, /, *exc_info):
+    async def __aexit__(self, /, *_):
         await self.aclose()
 
     def __aiter__(self, /) -> Self:
@@ -557,282 +739,456 @@ class AsyncHTTPFileReader(HTTPFileReader):
     async def __anext__(self, /) -> bytes:
         if line := await self.readline():
             return line
-        else:
-            raise StopAsyncIteration
+        raise StopAsyncIteration
 
-    async def __ainit__(
-        self, 
-        /, 
-        url: str | Callable[[], str] | Callable[[], Awaitable[str]], 
-        headers: None | Mapping = None, 
-        start: int = 0, 
-        seek_threshold: int = 1 << 20, 
-        urlopen = None, 
-    ):
-        if headers:
-            headers = {**headers, "accept-encoding": "identity"}
-        else:
-            headers = {"accept-encoding": "identity"}
-        if start > 0:
-            headers["range"] = f"bytes={start}-"
-        elif start < 0:
-            headers["range"] = f"bytes={start}"
-        if urlopen is None:
-            from http_request.extension.request import urlopen
-        if callable(url):
-            geturl = url
-            async def url() -> str:
-                url = geturl()
-                if isawaitable(url):
-                    url = await url
-                headers_extra = getattr(url, "headers")
-                if headers_extra:
-                    headers.update(headers_extra)
-                return cast(str, url)
-        elif hasattr(url, "headers"):
-            headers_extra = getattr(url, "headers")
-            if headers_extra:
-                headers.update(headers_extra)
-        urlopen = ensure_async(urlopen, threaded=True)
-        response = await urlopen((await url()) if callable(url) else url, headers=headers)
-        if start:
-            rng = get_range(response)
-            if not rng:
-                raise OSError(errno.ESPIPE, "non-seekable")
-            start = rng[0]
-        self.__dict__.update(
-            url = url, 
-            response = response, 
-            length = get_total_length(response) or 0, 
-            chunked = is_chunked(response), 
-            start = start, 
-            urlopen = urlopen, 
-            headers = MappingProxyType(headers), 
-            seek_threshold = max(seek_threshold, 0), 
-            _seekable = is_range_request(response), 
-        )
-        self.__dict__.pop("_initing", None)
+    def __len__(self, /) -> int:
+        return self.length
 
-    async def aclose(self, /):
-        if not self.closed:
-            self.__dict__["closed"] = True
-            await self.close_response()
+    def __repr__(self, /) -> str:
+        cls = type(self)
+        kwargs = {
+            "url": self._url, 
+            "start": self._pos, 
+            "seek_threshold": self.seek_threshold, 
+            "request": self.request, 
+            "get_file": self.get_file, 
+            **self.request_kwargs, 
+        }
+        return f"{cls.__module__}.{cls.__qualname__}({', '.join(map('%s=%r'.__mod__, kwargs.items()))})"
 
-    def close(self, /):
-        if not self.closed:
-            self.__dict__["closed"] = True
+    @property
+    def closed(self, /) -> bool:
+        return self._closed
+
+    @property
+    def response_closed(self, /) -> bool:
+        file = self.__dict__.get("response")
+        while file:
+            if hasattr(file, "closed"):
+                return file.closed
+            elif hasattr(file, "is_closed"):
+                closed = file.is_closed
+                if callable(closed):
+                    closed = closed()
+                return closed
+            file = getattr(file, "raw", None)
+        return self.closed
+
+    async def _init_info(self, /, key: str = "length"):
+        response = self.__dict__.get("response")
+        if response is None:
+            from urllib3_future_request import request_async as request
+            request_kwargs = dict(self.request_kwargs, parse=...)
+            headers = request_kwargs["headers"] = dict(request_kwargs.get("headers") or ())
+            headers["range"] = "bytes=0-0"
+            response = await request(await self._geturl(), **request_kwargs)
+        self._seekable = not is_range_request(response)
+        self.length = coalesce(get_total_length(response), -1)
+        match key:
+            case "length":
+                return self.length
+            case "seekable":
+                return self._seekable
+
+    @cached_property
+    def _seekable(self, /) -> bool:
+        return run_async(self._init_info("seekable"))
+
+    @cached_property
+    def length(self, /) -> int:
+        return run_async(self._init_info("length"))
+
+    @cached_property
+    def response(self, /):
+        run_async(self.reconnect())
+        return self.__dict__.get("response")
+
+    @property
+    def mode(self, /) -> str:
+        return "rb"
+
+    @property
+    def name(self, /) -> str:
+        return get_filename(self.response)
+
+    async def _get_file(self, /):
+        response = self.__dict__.get("response")
+        if not response:
+            await self.reconnect()
+            response = self.__dict__.get("response")
+            if not response:
+                return None
+        if get_file := self.get_file or (getattr(response, "get_file", None)):
+            file = get_file(response)
+            if isawaitable(file):
+                file = await file
+            if hasattr(file, "aread") or hasattr(file, "read"):
+                return file
+            elif isinstance(file, (Iterator, AsyncIterator)):
+                return bytes_iter_to_async_reader(file, threaded=True)
+        else:
+            if file := getattr(response, "file", None):
+                return file
+            for attr in ("aread", "read"):
+                method = getattr(response, attr, None)
+                if method is not None and argcount(method):
+                    return response
+            for attr in (
+                "aiter_bytes", "aiter_chunks", "aiter_chunked", "aiter_stream", 
+                "aiter_body", "aiter_raw", "aiter_content", 
+                "iter_bytes", "iter_chunks", "iter_chunked", "iter_stream", 
+                "iter_body", "iter_raw", "iter_content", 
+            ):
+                method = getattr(response, attr, None)
+                if method is not None:
+                    file = method()
+                    if isinstance(file, (Iterator, AsyncIterator)):
+                        return bytes_iter_to_async_reader(file, threaded=True)
+            for attr in (
+                "astream", "abody", "araw", "acontent", 
+                "stream", "body", "raw", "content", 
+            ):
+                file = getattr(response, attr, None)
+                if file is not None:
+                    if isawaitable(file):
+                        file = await file
+                    for attr in ("aread", "read"):
+                        method = getattr(file, attr, None)
+                        if method is not None and argcount(method):
+                            return file
+                    if callable(file):
+                        file = file()
+                        if isawaitable(file):
+                            file = await file
+                    if isinstance(file, Buffer):
+                        return BytesIO(file)
+                    elif isinstance(file, (Iterator, AsyncIterator)):
+                        return bytes_iter_to_async_reader(file, threaded=True)
+        raise TypeError("can't determine how to `read`")
+
+    async def _geturl(self, /) -> str:
+        return await ageturl(self._url)
+
+    async def close_response(self, /):
+        if response := self.__dict__.get("response"):
             try:
-                ret = self.response.aclose()
+                ret = response.aclose()
             except (AttributeError, TypeError):
                 try:
-                    ret = self.response.close()
+                    ret = response.close()
                 except (AttributeError, TypeError):
                     return
             if isawaitable(ret):
-                run_async(ret)
+                await ret
 
-    async def close_response(self, /):
+    async def aclose(self, /):
+        if not self.closed:
+            await self.close_response()
+            self._closed = True
+
+    def close(self, /):
+        from asynctools import run_async
+        run_async(self.aclose())
+
+    def fileno(self, /) -> int:
+        file = self.__dict__.get("response")
+        while file:
+            if hasattr(file, "fileno"):
+                return file.fileno()
+            file = getattr(file, "raw", None)
+        return 0
+
+    async def flush(self, /):
+        if not self.closed:
+            file = self.__dict__.get("response")
+            while file:
+                if hasattr(file, "flush"):
+                    ret = file.flush()
+                    if isawaitable(ret):
+                        ret = await ret
+                    return ret
+                file = getattr(file, "raw", None)
+
+    def isatty(self, /) -> bool:
+        return False
+
+    def _get_read(self, /):
+        try:
+            return self.file.aread
+        except AttributeError:
+            return ensure_async(self.file.read, threaded=True)
+
+    async def _readinto(self, buffer: Buffer, /) -> int:
+        read = self._get_read()
+        m = to_bytes_view(buffer)
+        size = len(m)
+        start = 0
+        last_intv = size - size % COPY_BUFSIZE
+        while start < size:
+            if start >= last_intv:
+                delta = size - start
+            else:
+                delta = COPY_BUFSIZE
+            data = await read(delta)
+            data_len = len(data)
+            m[:data_len] = data
+            start += data_len
+            if data_len < delta:
+                break
+        return start
+
+    async def _readline(self, size: None | int = -1, /) -> bytes:
+        read = self._get_read()
+        buf = bytearray()
+        if size is None or size < 0:
+            while b := await read(1):
+                buf += b
+                if b == b"\n":
+                    break
+        else:
+            while size and (b := await read(1)):
+                buf += b
+                if b == b"\n":
+                    break
+                size -= 1
+        return bytes(buf)
+
+    async def _readlines(self, hint: int = -1, /) -> list[bytes]:
         try:
-            ret = self.response.aclose()
-        except (AttributeError, TypeError):
+            readline = self.file.areadline
+        except AttributeError:
             try:
-                ret = self.response.close()
-            except (AttributeError, TypeError):
-                return
-        if isawaitable(ret):
-            await ret
+                readline = ensure_async(self.file.readline, threaded=True)
+            except AttributeError:
+                readline = self._readline
+        ls: list[bytes]
+        add = ls.append
+        if hint <= 0:
+            while l := await readline():
+                add(l)
+        else:
+            while hint >= 0 and (l := await readline()):
+                add(l)
+                hint -= len(l)
+        return ls
 
-    async def flush(self, /):
-        if self.closed:
-            raise ValueError("I/O operation on closed file.")
-        if _initing := self.__dict__.get("_initing"):
-            await _initing
-            self.__dict__.pop("_initing", None)
-        return await ensure_async(self.file.flush, threaded=True)()
+    def readable(self, /) -> bool:
+        return True
 
     async def read(self, size: int = -1, /) -> bytes: # type: ignore
-        if self.closed:
-            raise ValueError("I/O operation on closed file.")
-        if _initing := self.__dict__.get("_initing"):
-            await _initing
-            self.__dict__.pop("_initing", None)
-        if size == 0 or not self.chunked and self.tell() >= self.length:
+        pos = self._pos
+        if size == 0:
             return b""
-        if self.file_closed:
-            await self.reconnect()
-        read = ensure_async(self.file.read, threaded=True)
-        if size is None or size < 0:
-            data = await read(-1)
-        else:
-            data = await read(size)
-        if data:
-            self._add_start(len(data))
-        return data
+        length = self.__dict__.get("length")
+        if length is not None:
+            if length == 0 or length > 0 and pos >= length:
+                return b""
+        if "response" not in self.__dict__ or self.closed or self.response_closed:
+            await self.reconnect(pos)
+        if self.file:
+            read = self._get_read()
+            try:
+                if size is None or size < 0:
+                    data = await read()
+                else:
+                    data = await read(size)
+                if data:
+                    self._pos = pos + len(data)
+                return data
+            except:
+                self._pos = pos
+                await self.aclose()
+                raise
+        return b""
 
     async def readinto(self, buffer, /) -> int: # type: ignore
-        if self.closed:
-            raise ValueError("I/O operation on closed file.")
-        if _initing := self.__dict__.get("_initing"):
-            await _initing
-            self.__dict__.pop("_initing", None)
-        if not buffer or not self.chunked and self.tell() >= self.length:
+        pos = self._pos
+        if not buffer_length(buffer):
             return 0
-        if self.file_closed:
-            await self.reconnect()
-        try:
-            readinto = ensure_async(self.file.readinto, threaded=True)
-        except AttributeError:
-            read = ensure_async(self.file.read, threaded=True)
-            async def readinto(buffer, /):
-                data = await read(len(buffer))
-                size = len(data)
-                buffer[:size] = data
+        length = self.__dict__.get("length")
+        if length is not None:
+            if length == 0 or length > 0 and pos >= length:
+                return 0
+        if "response" not in self.__dict__ or self.closed or self.response_closed:
+            await self.reconnect(pos)
+        if file := self.file:
+            try:
+                readinto = file.areadinto
+            except AttributeError:
+                try:
+                    readinto = ensure_async(file.readinto, threaded=True)
+                except AttributeError:
+                    readinto = self._readinto
+            try:
+                size = await readinto(buffer)
+                if size:
+                    self._pos = pos + size
                 return size
-        size = await readinto(buffer)
-        if size:
-            self._add_start(size)
-        return size
+            except:
+                self._pos = pos
+                await self.aclose()
+                raise
+        return 0
 
     async def readline(self, size: None | int = -1, /) -> bytes: # type: ignore
-        if self.closed:
-            raise ValueError("I/O operation on closed file.")
-        if _initing := self.__dict__.get("_initing"):
-            await _initing
-            self.__dict__.pop("_initing", None)
-        if size == 0 or not self.chunked and self.tell() >= self.length:
+        pos = self._pos
+        if size == 0:
             return b""
-        if self.file_closed:
-            await self.reconnect()
-        # TODO: if no readline method, give a default impl
-        if size is None or size < 0:
-            data = await ensure_async(self.file.readline, threaded=True)()
-        else:
-            data = await ensure_async(self.file.readline, threaded=True)(size)
-        if data:
-            self._add_start(len(data))
-        return data
+        length = self.__dict__.get("length")
+        if length is not None:
+            if length == 0 or length > 0 and pos >= length:
+                return b""
+        if "response" not in self.__dict__ or self.closed or self.response_closed:
+            await self.reconnect(pos)
+        if file := self.file:
+            try:
+                readline = file.areadline
+            except AttributeError:
+                try:
+                    readline = ensure_async(file.readline, threaded=True)
+                except AttributeError:
+                    readline = self._readline
+            try:
+                if size is None or size < 0:
+                    data = await readline()
+                else:
+                    data = await readline(size)
+                if data:
+                    self._pos = pos + len(data)
+                return data
+            except:
+                self._pos = pos
+                await self.aclose()
+                raise
+        return b""
 
     async def readlines(self, hint: int = -1, /) -> list[bytes]: # type: ignore
-        if self.closed:
-            raise ValueError("I/O operation on closed file.")
-        if _initing := self.__dict__.get("_initing"):
-            await _initing
-            self.__dict__.pop("_initing", None)
-        if not self.chunked and self.tell() >= self.length:
-            return []
-        if self.file_closed:
-            await self.reconnect()
-        # TODO: if no readlines method, give a default impl
-        ls = await ensure_async(self.file.readlines, threaded=True)(hint)
-        if ls:
-            self._add_start(sum(map(len, ls)))
-        return ls
-
-    async def reconnect(self, /, start: None | int = None) -> int: # type: ignore
-        if _initing := self.__dict__.get("_initing"):
-            await _initing
-            self.__dict__.pop("_initing", None)
-        if not self._seekable:
-            if start is None and self.tell() or start:
-                raise OSError(errno.EOPNOTSUPP, "Unsupport for reconnection of non-seekable streams.")
-            start = 0
+        pos = self._pos
+        length = self.__dict__.get("length")
+        if length is not None:
+            if length == 0 or length > 0 and pos >= length:
+                return []
+        if "response" not in self.__dict__ or self.closed or self.response_closed:
+            await self.reconnect(pos)
+        if file := self.file:
+            try:
+                readlines = file.areadlines
+            except AttributeError:
+                try:
+                    readlines = ensure_async(file.readlines, threaded=True)
+                except AttributeError:
+                    readlines = self._readlines
+            try:
+                ls = await readlines(hint)
+                if ls:
+                    self._pos = pos + sum(map(len, ls))
+                return ls
+            except:
+                self._pos = pos
+                await self.aclose()
+                raise
+        return []
+
+    async def reconnect(self, /, start: None | int = None) -> int:
         if start is None:
-            start = self.tell()
+            start = self._pos
+        if start and not self.seekable():
+            raise OSError(errno.EOPNOTSUPP, "unsupport for reconnection of non-seekable streams")
+        request_kwargs = self.request_kwargs
+        headers = request_kwargs["headers"] = request_kwargs["headers"]
+        if start >= 0:
+            headers["range"] = f"bytes={start}-"
         elif start < 0:
-            start = self.length + start
-            if start < 0:
-                start = 0
-        if start >= self.length:
-            self.__dict__.update(start=start)
-            return start
-        await self.close_response()
-        url = self.url
-        response = await self.urlopen(
-            (await url()) if callable(url) else url, 
-            headers={**self.headers, "range": f"bytes={start}-"}
-        )
-        length_new = get_total_length(response)
-        if self.length != length_new:
-            raise OSError(errno.EIO, f"file size changed: {self.length} -> {length_new}")
-        self.__dict__.update(
-            response=response, 
-            start=start, 
-            closed=False, 
-        )
+            headers["range"] = f"bytes={start}"
+        await self.aclose()
+        response = await self.request(await self._geturl(), **request_kwargs)
+        status_code = get_status_code(response)
+        if not 200 <= status_code < 300:
+            raise OSError(
+                errno.EIO, 
+                {
+                    "code": status_code, 
+                    "response": response, 
+                    "reason": "status code must be in the `range(200, 300)`", 
+                }, 
+            )
+        if start:
+            rng = get_range(response)
+            if not rng:
+                raise OSError(errno.ESPIPE, "non-seekable")
+            start = self._pos = rng[0]
+        self.response = response
+        self.file = await self._get_file()
+        self._closed = False
         return start
 
     async def seek(self, pos: int, whence: int = 0, /) -> int: # type: ignore
-        if self.closed:
-            raise ValueError("I/O operation on closed file.")
-        if _initing := self.__dict__.get("_initing"):
-            await _initing
-            self.__dict__.pop("_initing", None)
-        if not self._seekable:
+        if not self.seekable():
             raise OSError(errno.EINVAL, "not a seekable stream")
-        if whence == 0:
-            if pos < 0:
-                raise OSError(errno.EINVAL, f"negative seek start: {pos!r}")
-            old_pos = self.tell()
-            if old_pos == pos:
-                return pos
-            if pos > old_pos and (size := pos - old_pos) <= self.seek_threshold:
-                if size <= COPY_BUFSIZE:
-                    await self.read(size)
-                else:
-                    buf = bytearray(COPY_BUFSIZE)
-                    readinto = self.readinto
-                    while size > COPY_BUFSIZE:
-                        await readinto(buf)
-                        size -= COPY_BUFSIZE
-                    await self.read(size)
-            else:
-                await self.reconnect(pos)
-            return pos
-        elif whence == 1:
-            if pos == 0:
-                return self.tell()
-            return await self.seek(self.tell() + pos)
-        elif whence == 2:
-            return await self.seek(self.length + pos)
-        else:
-            raise OSError(errno.EINVAL, f"whence value unsupported: {whence!r}")
+        old_pos = self._pos
+        match whence:
+            case 1:
+                pos = old_pos + pos
+            case 2:
+                length = self.__dict__.get("length")
+                if length is None:
+                    length = await self._init_info()
+                pos += length
+        if pos < 0:
+            pos = 0
+        if (self.__dict__.get("response") and 
+            self.file and 
+            not self.closed and 
+            not self.response_closed and 
+            pos > old_pos and 
+            (size := pos - old_pos) <= self.seek_threshold
+        ):
+            read = self._get_read()
+            while size > COPY_BUFSIZE:
+                await read(COPY_BUFSIZE)
+                size -= COPY_BUFSIZE
+            await read(size)
+        return await self.reconnect(pos)
 
-    @classmethod
-    async def new(
-        cls, 
-        /, 
-        url: str | Callable[[], str], 
-        headers: None | Mapping = None, 
-        start: int = 0, 
-        seek_threshold: int = 1 << 20, 
-        urlopen = None, 
-    ) -> Self: # type: ignore
-        self = cls.__new__(cls)
-        await self.__ainit__(
-            url=url, 
-            headers=headers, 
-            start=start, 
-            seek_threshold=seek_threshold, 
-            urlopen=urlopen, 
-        )
-        return self
+    def seekable(self, /) -> bool:
+        return self._seekable
+
+    def tell(self, /) -> int:
+        return self._pos
 
-    @overload # type: ignore
+    async def truncate(self, size: None | int = None, /) -> int: # type: ignore
+        raise UnsupportedOperation(errno.ENOTSUP, "truncate")
+
+    async def writable(self, /) -> bool: # type: ignore
+        return False
+
+    async def write(self, b, /) -> int: # type: ignore
+        raise UnsupportedOperation(errno.ENOTSUP, "write")
+
+    async def writelines(self, lines, /): # type: ignore
+        raise UnsupportedOperation(errno.ENOTSUP, "writelines")
+
+    @overload
     @classmethod
     async def open(
         cls, 
         /, 
-        url: str | Callable[[], str], 
+        url: (
+            str | SupportsGeturl | URL | 
+            Callable[[], str] | Callable[[], SupportsGeturl] | Callable[[], URL] | 
+            Callable[[], Awaitable[str]] | Callable[[], Awaitable[SupportsGeturl]] | Callable[[], Awaitable[URL]]
+        ), 
         mode: Literal["br", "rb"], 
         *, 
         buffering: None | int = None, 
         encoding: None | str = None, 
         errors: None | str = None, 
         newline: None | str = None, 
-        headers: None | Mapping = None, 
         start: int = 0, 
         seek_threshold: int = 1 << 20, 
-        urlopen = None, 
+        request: None | Callable[..., Awaitable[Response]] = None, 
+        get_file: None | str | Callable[[Response], Any] = None, 
+        **request_kwargs, 
     ) -> Self | AsyncBufferedReader:
         ...
     @overload
@@ -840,45 +1196,57 @@ class AsyncHTTPFileReader(HTTPFileReader):
     async def open(
         cls, 
         /, 
-        url: str | Callable[[], str], 
+        url: (
+            str | SupportsGeturl | URL | 
+            Callable[[], str] | Callable[[], SupportsGeturl] | Callable[[], URL] | 
+            Callable[[], Awaitable[str]] | Callable[[], Awaitable[SupportsGeturl]] | Callable[[], Awaitable[URL]]
+        ), 
         mode: Literal["r", "rt", "tr"] = "r", 
         *, 
         buffering: None | int = None, 
         encoding: None | str = None, 
         errors: None | str = None, 
         newline: None | str = None, 
-        headers: None | Mapping = None, 
         start: int = 0, 
         seek_threshold: int = 1 << 20, 
-        urlopen = None, 
+        request: None | Callable[..., Awaitable[Response]] = None, 
+        get_file: None | str | Callable[[Response], Any] = None, 
+        **request_kwargs, 
     ) -> AsyncTextIOWrapper:
         ...
     @classmethod
     async def open(
         cls, 
         /, 
-        url: str | Callable[[], str], 
+        url: (
+            str | SupportsGeturl | URL | 
+            Callable[[], str] | Callable[[], SupportsGeturl] | Callable[[], URL] | 
+            Callable[[], Awaitable[str]] | Callable[[], Awaitable[SupportsGeturl]] | Callable[[], Awaitable[URL]]
+        ), 
         mode: Literal["r", "rt", "tr", "br", "rb"] = "r", 
+        *, 
         buffering: None | int = None, 
         encoding: None | str = None, 
         errors: None | str = None, 
         newline: None | str = None, 
-        headers: None | Mapping = None, 
         start: int = 0, 
         seek_threshold: int = 1 << 20, 
-        urlopen = None, 
+        request: None | Callable[..., Awaitable[Response]] = None, 
+        get_file: None | str | Callable[[Response], Any] = None, 
+        **request_kwargs, 
     ) -> Self | AsyncBufferedReader | AsyncTextIOWrapper:
-        file = await cls.new(
-            url=url, 
-            headers=headers, 
+        file = cls(
+            url, 
             start=start, 
             seek_threshold=seek_threshold, 
-            urlopen=urlopen, 
+            request=request, 
+            get_file=get_file, 
+            **request_kwargs, 
         )
         if mode not in ("r", "rt", "tr", "rb", "br"):
             raise OSError(errno.EINVAL, f"invalid (or unsupported) mode: {mode!r}")
         return file.wrap(
-            text_mode="b" not in mode, # type: ignore
+            text_mode="b" not in cast(str, mode), # type: ignore
             buffering=buffering, 
             encoding=encoding, 
             errors=errors, 
@@ -886,7 +1254,7 @@ class AsyncHTTPFileReader(HTTPFileReader):
         )
 
     @overload
-    def wrap(
+    async def wrap(
         self, 
         /, 
         text_mode: Literal[False] = False, 
@@ -898,7 +1266,7 @@ class AsyncHTTPFileReader(HTTPFileReader):
     ) -> Self | AsyncBufferedReader:
         ...
     @overload
-    def wrap(
+    async def wrap(
         self, 
         /, 
         text_mode: Literal[True], 
@@ -909,7 +1277,7 @@ class AsyncHTTPFileReader(HTTPFileReader):
         newline: None | str = None, 
     ) -> AsyncTextIOWrapper:
         ...
-    def wrap(
+    async def wrap(
         self, 
         /, 
         text_mode: bool = False, 
@@ -940,6 +1308,8 @@ class AsyncHTTPFileReader(HTTPFileReader):
             line_buffering = True
         else:
             buffer_size = buffering
+        if "response" not in self.__dict__ or self.closed or self.response_closed:
+            await self.reconnect()
         raw = self
         buffer = AsyncBufferedReader(raw, buffer_size)
         if text_mode:
@@ -954,278 +1324,623 @@ class AsyncHTTPFileReader(HTTPFileReader):
             return buffer
 
 
-if find_spec("urllib3"):
-    from urllib.error import HTTPError
+class MultipartHTTPFileReader[Response](HTTPFileReader[Response]):
 
-    _urllib3_urlopen = None
+    def __init__(
+        self, 
+        /, 
+        urls: (
+            str | SupportsGeturl | URL | 
+            Callable[[], str] | Callable[[], SupportsGeturl] | Callable[[], URL] | 
+            tuple[int, str] | tuple[int, SupportsGeturl] | tuple[int, URL] | 
+            tuple[int, Callable[[], str]] | tuple[int, Callable[[], SupportsGeturl]] | tuple[int, Callable[[], URL]] |
+            Iterable[
+                str | SupportsGeturl | URL | 
+                Callable[[], str] | Callable[[], SupportsGeturl] | Callable[[], URL] | 
+                tuple[int, str] | tuple[int, SupportsGeturl] | tuple[int, URL] | 
+                tuple[int, Callable[[], str]] | tuple[int, Callable[[], SupportsGeturl]] | tuple[int, Callable[[], URL]]
+            ]
+        ), 
+        start: int = 0, 
+        seek_threshold: int = 1 << 20, 
+        request: None | Callable[..., Response] = None, 
+        get_file: None | str | Callable[[Response], Any] = None, 
+        **request_kwargs, 
+    ):
+        self.seek_threshold = seek_threshold
+        if request is None:
+            from urllib3_future_request import request_sync as request # type: ignore
+        self.request = cast(Callable[..., Response], request)
+        self.get_file = get_file # type: ignore
+        self.request_kwargs = request_kwargs
+        if (isinstance(urls, (str, SupportsGeturl, URL)) or 
+            callable(urls) or 
+            isinstance(urls, tuple) and urls and isinstance(urls[0], int)
+        ):
+            urls = [urls]
+        else:
+            urls = list(urls) # type: ignore
 
-    class Urllib3FileReader(HTTPFileReader):
+        from urllib3_future_request import request_sync
 
-        def __init__(
-            self, 
-            /, 
-            url: str | Callable[[], str], 
-            headers: None | Mapping = None, 
-            start: int = 0, 
-            seek_threshold: int = 1 << 20, 
-            urlopen = None, 
-        ):
-            global _urllib3_urlopen
-            from urllib3 import request
-            from urllib3.poolmanager import PoolManager
-
-            if isinstance(urlopen, PoolManager):
-                urlopen = partial(urlopen.request, "GET", preload_content=False)
-            elif urlopen is None:
-                if _urllib3_urlopen is None:
-                    urlopen = _urllib3_urlopen = partial(cast(Callable, request), "GET", preload_content=False)
-                else:
-                    urlopen = _urllib3_urlopen
+        self._parts: list[dict] = []
+        add_part = self._parts.append
+        seekable = True
+        length = 0
+        request_kwargs = dict(request_kwargs, parse=...)
+        headers = request_kwargs["headers"] = dict(request_kwargs.get("headers") or ())
+        headers["range"] = "bytes=0-0"
+        for url in urls:
+            if isinstance(url, tuple):
+                size, url = url
             else:
-                urlopen = partial(urlopen, preload_content=False)
-
-            def urlopen_wrapper(url: str, headers: None | Mapping = headers):
-                resp = urlopen(url, headers=headers)
-                if resp.status >= 400:
-                    raise HTTPError(resp.url, resp.status, resp.reason, resp.headers, resp)
-                return resp
-
-            super().__init__(
-                url, 
-                headers=headers, 
-                start=start, 
-                seek_threshold=seek_threshold, 
-                urlopen=urlopen_wrapper, 
-            )
+                url_ = url
+                if callable(url_):
+                    url_ = url_()
+                if isinstance(url_, SupportsGeturl):
+                    url_ = url_.geturl()
+                else:
+                    url_ = str(url_)
+                resp = request_sync(url_, **request_kwargs)
+                if not is_range_request(resp):
+                    seekable = False
+                size = get_total_length(resp) or 0
+            if size:
+                start = length
+                length += size
+                stop = length
+                add_part({
+                    "url": url, 
+                    "length": size, 
+                    "start": start, 
+                    "stop": stop, 
+                })
+        self.length = length
+        if start < 0:
+            start += length
+            if start < 0:
+                start = 0
+        self._pos = start
+        self._seekable = seekable
+        self._closed = False
 
-    __all__.append("Urllib3FileReader")
+    def __repr__(self):
+        cls = type(self)
+        kwargs = {
+            "urls": [(d["length"], d["url"]) for d in self._parts], 
+            "start": self._pos, 
+            "seek_threshold": self.seek_threshold, 
+            "request": self.request, 
+            "get_file": self.get_file, 
+            **self.request_kwargs, 
+        }
+        return f"{cls.__module__}.{cls.__qualname__}({', '.join(map('%s=%r'.__mod__, kwargs.items()))})"
 
+    @cached_property
+    def response(self, /):
+        return self.file.response
 
-if find_spec("requests"):
-    _requests_urlopen = None
+    def close(self, /):
+        self.file.close()
+        self._closed = True
 
-    class RequestsFileReader(HTTPFileReader):
+    def read(self, size: None | int = -1, /) -> bytes:
+        if size is None or size < 0:
+            size = self.length - self._pos
+        else:
+            size = min(self.length - self._pos, size)
+        if size <= 0:
+            return b""
+        buf = bytearray(size)
+        self.readinto(buf)
+        return bytes(buf)
+
+    def readinto(self, buffer: Buffer, /) -> int:
+        pos = self._pos
+        remaining = min(self.length - pos, buffer_length(buffer))
+        if remaining <= 0:
+            return 0
+        if "file" not in self.__dict__ or self.closed or self.response_closed:
+            self.reconnect(pos)
+        try:
+            readinto = self.file.readinto
+            view = to_bytes_view(buffer)[:remaining]
+            size = 0
+            while size < remaining:
+                start_pos = pos + size
+                self.seek(start_pos)
+                size += readinto(view[size:])
+            return size
+        except:
+            self._pos = pos
+            self.close()
+            raise
 
-        def __init__(
-            self, 
-            /, 
-            url: str | Callable[[], str], 
-            headers: None | Mapping = None, 
-            start: int = 0, 
-            seek_threshold: int = 1 << 20, 
-            urlopen = None, 
-        ):
-            global _requests_urlopen
-            from requests import request, Session
-            if isinstance(urlopen, Session):
-                urlopen = partial(urlopen.request, "GET", stream=True)
-            elif urlopen is None:
-                if _requests_urlopen is None:
-                    if "__del__" not in Session.__dict__:
-                        setattr(Session, "__del__", lambda self, /: self.close())
-                    urlopen = _requests_urlopen = partial(request, "GET", stream=True)
+    def readline(self, size: None | int = -1, /) -> bytes:
+        pos = self._pos
+        if size is None or size < 0:
+            size = self.length - pos
+        else:
+            size = min(self.length - pos, size)
+        if size <= 0:
+            return b""
+        if "file" not in self.__dict__ or self.closed or self.response_closed:
+            self.reconnect(pos)
+        try:
+            readline = self.file.readline
+            buf = bytearray()
+            while size > 0:
+                if line := readline(size):
+                    buf += line
+                    if buf.endswith(b"\n"):
+                        break
                 else:
-                    urlopen = _requests_urlopen
+                    self.seek(pos + len(buf))
+                size -= len(line)
+            return bytes(buf)
+        except:
+            self._pos = pos
+            self.close()
+            raise
+
+    def readlines(self, hint: int = -1, /) -> list[bytes]:
+        pos = self._pos
+        readline = self.readline
+        ls: list[bytes]
+        add = ls.append
+        try:
+            if hint <= 0:
+                while l := readline():
+                    add(l)
             else:
-                urlopen = partial(urlopen, stream=True)
-            def urlopen_wrapper(url: str, headers: None | Mapping = headers):
-                resp = urlopen(url, headers=headers)
-                resp.raise_for_status()
-                return resp
-            super().__init__(
-                url, 
-                headers=headers, 
-                start=start, 
-                seek_threshold=seek_threshold, 
-                urlopen=urlopen_wrapper, 
-            )
+                while hint >=0. and (l := readline()):
+                    add(l)
+                    hint -= len(l)
+            return ls
+        except:
+            self._pos = pos
+            self.close()
+            raise
+
+    def read_range(self, size: None | int = -1, /, offset: int = 0) -> bytes:
+        if offset < 0:
+            offset += self.length
+            if offset < 0:
+                offset = 0
+        if size is None or size < 0:
+            size = self.length - offset
+        else:
+            size = min(self.length - offset, size)
+        if size <= 0:
+            return b""
+        buf = bytearray(size)
+        self.readinto_range(buf, offset)
+        return bytes(buf)
+
+    def readinto_range(self, buffer: Buffer, /, offset: int = 0):
+        from urllib3_future_request import request_sync as request
+
+        if offset < 0:
+            offset += self.length
+            if offset < 0:
+                offset = 0
+        remaining = min(self.length - offset, buffer_length(buffer))
+        if remaining <= 0:
+            return 0
+        request_kwargs = dict(self.request_kwargs)
+        headers = request_kwargs["headers"] = dict(request_kwargs.get("headers") or ())
+        headers["accept-encoding"] = "identity"
+        view = to_bytes_view(buffer)[:remaining]
+        size = 0
+        while size < remaining:
+            for vol in self._parts:
+                if vol["start"] <= offset < vol["stop"]:
+                    vol_offset = offset + size - vol["start"]
+                    headers["range"] = f"bytes={vol_offset}-"
+                    resp = request(vol["url"], **request_kwargs)
+                    try:
+                        if vol_offset and resp.headers.get("accept-ranges") != "bytes":
+                            raise OSError(29, "non-seekable stream")
+                        size += resp.readinto(view[size:])
+                    finally:
+                        resp.close()
+        return size
 
-        @funcproperty
-        def file(self, /) -> BinaryIO:
-            return self.response.raw
+    def reconnect(self, /, start: None | int = None) -> int:
+        if start is None:
+            start = self._pos
+        elif start < 0:
+            start += self.length
+            if start < 0:
+                start = 0
+        if start >= self.length:
+            return start
+        for vol in self._parts:
+            if vol["start"] <= start < vol["stop"]:
+                self.close()
+                file = self.file = HTTPFileReader(
+                    vol["url"], 
+                    start=vol["start"] - start, 
+                    seek_threshold=self.seek_threshold, 
+                    request=self.request, 
+                    get_file=self.get_file, 
+                    **self.request_kwargs, 
+                )
+                self.response = file.response
+                self._pos = start
+                self._closed = False
+                return start
+        return start
 
-    __all__.append("RequestsFileReader")
+    def seek(self, pos: int, whence: int = 0, /) -> int:
+        old_pos = self._pos
+        match whence:
+            case 1:
+                pos = old_pos + pos
+            case 2:
+                pos += self.length
+        if pos < 0:
+            pos = 0
+        if pos == old_pos:
+            return pos
+        elif pos >= self.length:
+            self.close()
+            self._pos = pos
+            return pos
+        if hasattr(self, "file"):
+            file = self.file
+            start = old_pos - file._pos
+            stop = start + file.length
+            if start <= pos < stop:
+                file.seek(pos-start)
+                self._pos = pos
+                return pos
+        return self.reconnect(pos)
 
 
-if find_spec("aiohttp"):
-    _aiohttp_urlopen = None
+class AsyncMultipartHTTPFileReader[Response](AsyncHTTPFileReader[Response]):
 
-    class AiohttpFileReader(AsyncHTTPFileReader):
+    def __init__(
+        self, 
+        /, 
+        urls: (
+            str | SupportsGeturl | URL | 
+            Callable[[], str] | Callable[[], SupportsGeturl] | Callable[[], URL] | 
+            Callable[[], Awaitable[str]] | Callable[[], Awaitable[SupportsGeturl]] | Callable[[], Awaitable[URL]] | 
+            tuple[int, str] | tuple[int, SupportsGeturl] | tuple[int, URL] | 
+            tuple[int, Callable[[], str]] | tuple[int, Callable[[], SupportsGeturl]] | tuple[int, Callable[[], URL]] | 
+            tuple[int, Callable[[], Awaitable[str]]] | tuple[int, Callable[[], Awaitable[SupportsGeturl]]] | tuple[int, Callable[[], Awaitable[URL]]] | 
+            Iterable[
+                str | SupportsGeturl | URL | 
+                Callable[[], str] | Callable[[], SupportsGeturl] | Callable[[], URL] | 
+                Callable[[], Awaitable[str]] | Callable[[], Awaitable[SupportsGeturl]] | Callable[[], Awaitable[URL]] | 
+                tuple[int, str] | tuple[int, SupportsGeturl] | tuple[int, URL] | 
+                tuple[int, Callable[[], str]] | tuple[int, Callable[[], SupportsGeturl]] | tuple[int, Callable[[], URL]] | 
+                tuple[int, Callable[[], Awaitable[str]]] | tuple[int, Callable[[], Awaitable[SupportsGeturl]]] | tuple[int, Callable[[], Awaitable[URL]]]
+            ]
+        ), 
+        start: int = 0, 
+        seek_threshold: int = 1 << 20, 
+        request: None | Callable[..., Awaitable[Response]] = None, 
+        get_file: None | str | Callable[[Response], Any] = None, 
+        **request_kwargs, 
+    ):
+        run_async(self.__ainit__(
+            urls, 
+            start=start, 
+            seek_threshold=seek_threshold, 
+            request=request, 
+            get_file=get_file, 
+            **request_kwargs, 
+        ))
 
-        async def __ainit__(
-            self, 
-            /, 
-            url: str | Callable[[], str] | Callable[[], Awaitable[str]], 
-            headers: None | Mapping = None, 
-            start: int = 0, 
-            seek_threshold: int = 1 << 20, 
-            urlopen = None, 
+    async def __ainit__(
+        self, 
+        /, 
+        urls: (
+            str | SupportsGeturl | URL | 
+            Callable[[], str] | Callable[[], SupportsGeturl] | Callable[[], URL] | 
+            Callable[[], Awaitable[str]] | Callable[[], Awaitable[SupportsGeturl]] | Callable[[], Awaitable[URL]] | 
+            tuple[int, str] | tuple[int, SupportsGeturl] | tuple[int, URL] | 
+            tuple[int, Callable[[], str]] | tuple[int, Callable[[], SupportsGeturl]] | tuple[int, Callable[[], URL]] | 
+            tuple[int, Callable[[], Awaitable[str]]] | tuple[int, Callable[[], Awaitable[SupportsGeturl]]] | tuple[int, Callable[[], Awaitable[URL]]] | 
+            Iterable[
+                str | SupportsGeturl | URL | 
+                Callable[[], str] | Callable[[], SupportsGeturl] | Callable[[], URL] | 
+                Callable[[], Awaitable[str]] | Callable[[], Awaitable[SupportsGeturl]] | Callable[[], Awaitable[URL]] | 
+                tuple[int, str] | tuple[int, SupportsGeturl] | tuple[int, URL] | 
+                tuple[int, Callable[[], str]] | tuple[int, Callable[[], SupportsGeturl]] | tuple[int, Callable[[], URL]] | 
+                tuple[int, Callable[[], Awaitable[str]]] | tuple[int, Callable[[], Awaitable[SupportsGeturl]]] | tuple[int, Callable[[], Awaitable[URL]]]
+            ]
+        ), 
+        start: int = 0, 
+        seek_threshold: int = 1 << 20, 
+        request: None | Callable[..., Awaitable[Response]] = None, 
+        get_file: None | str | Callable[[Response], Any] = None, 
+        **request_kwargs, 
+    ):
+        self.seek_threshold = seek_threshold
+        if request is None:
+            from urllib3_future_request import request_async as request # type: ignore
+        self.request = cast(Callable[..., Awaitable[Response]], request)
+        self.get_file = get_file # type: ignore
+        self.request_kwargs = request_kwargs
+        if (isinstance(urls, (str, SupportsGeturl, URL)) or 
+            callable(urls) or 
+            isinstance(urls, tuple) and urls and isinstance(urls[0], int)
         ):
-            global _aiohttp_urlopen
-            from aiohttp import request, ClientSession
-
-            if isinstance(urlopen, ClientSession):
-                urlopen = urlopen.get
-            elif urlopen is None:
-                if _aiohttp_urlopen is None:
-                    urlopen = _aiohttp_urlopen = partial(request, "GET")
-                else:
-                    urlopen = _aiohttp_urlopen
-            async def urlopen_wrapper(url: str, headers: None | Mapping = headers):
-                ctx = urlopen(url, headers=headers)
-                resp = await ctx.__aenter__()
-                resp.aclose = lambda: ctx.__aexit__(None, None, None)
-                resp.raise_for_status()
-                return resp
-            await super().__ainit__(
-                url=url, 
-                headers=headers, 
-                start=start, 
-                seek_threshold=seek_threshold, 
-                urlopen=urlopen_wrapper, 
-            )
+            urls = [urls]
+        else:
+            urls = list(urls) # type: ignore
 
-        @funcproperty
-        def file(self, /) -> BinaryIO:
-            return self.response.content
+        from urllib3_future_request import request_async
 
-        @funcproperty
-        def file_closed(self, /) -> bool:
-            return self.response.closed
+        self._parts: list[dict] = []
+        add_part = self._parts.append
+        seekable = True
+        length = 0
+        request_kwargs = dict(request_kwargs, parse=...)
+        headers = request_kwargs["headers"] = dict(request_kwargs.get("headers") or ())
+        headers["range"] = "bytes=0-0"
+        for url in urls:
+            if isinstance(url, tuple):
+                size, url = url
+            else:
+                resp = await request_async(await ageturl(url), **request_kwargs)
+                if not is_range_request(resp):
+                    seekable = False
+                size = get_total_length(resp) or 0
+            if size:
+                start = length
+                length += size
+                stop = length
+                add_part({
+                    "url": url, 
+                    "length": size, 
+                    "start": start, 
+                    "stop": stop, 
+                })
+        self.length = length
+        if start < 0:
+            start += length
+            if start < 0:
+                start = 0
+        self._pos = start
+        self._seekable = seekable
+        self._closed = False
 
-    __all__.append("AiohttpFileReader")
+    @classmethod
+    async def new( # type: ignore
+        cls, 
+        /, 
+        urls: (
+            str | SupportsGeturl | URL | 
+            Callable[[], str] | Callable[[], SupportsGeturl] | Callable[[], URL] | 
+            Callable[[], Awaitable[str]] | Callable[[], Awaitable[SupportsGeturl]] | Callable[[], Awaitable[URL]] | 
+            tuple[int, str] | tuple[int, SupportsGeturl] | tuple[int, URL] | 
+            tuple[int, Callable[[], str]] | tuple[int, Callable[[], SupportsGeturl]] | tuple[int, Callable[[], URL]] | 
+            tuple[int, Callable[[], Awaitable[str]]] | tuple[int, Callable[[], Awaitable[SupportsGeturl]]] | tuple[int, Callable[[], Awaitable[URL]]] | 
+            Iterable[
+                str | SupportsGeturl | URL | 
+                Callable[[], str] | Callable[[], SupportsGeturl] | Callable[[], URL] | 
+                Callable[[], Awaitable[str]] | Callable[[], Awaitable[SupportsGeturl]] | Callable[[], Awaitable[URL]] | 
+                tuple[int, str] | tuple[int, SupportsGeturl] | tuple[int, URL] | 
+                tuple[int, Callable[[], str]] | tuple[int, Callable[[], SupportsGeturl]] | tuple[int, Callable[[], URL]] | 
+                tuple[int, Callable[[], Awaitable[str]]] | tuple[int, Callable[[], Awaitable[SupportsGeturl]]] | tuple[int, Callable[[], Awaitable[URL]]]
+            ]
+        ), 
+        start: int = 0, 
+        seek_threshold: int = 1 << 20, 
+        request: None | Callable[..., Awaitable[Response]] = None, 
+        get_file: None | str | Callable[[Response], Any] = None, 
+        **request_kwargs, 
+    ) -> Self:
+        self = cls.__new__(cls)
+        await self.__ainit__(
+            urls, 
+            start=start, 
+            seek_threshold=seek_threshold, 
+            request=request, 
+            get_file=get_file, 
+            **request_kwargs, 
+        )
+        return self
 
+    def __repr__(self):
+        cls = type(self)
+        kwargs = {
+            "urls": [(d["length"], d["url"]) for d in self._parts], 
+            "start": self._pos, 
+            "seek_threshold": self.seek_threshold, 
+            "request": self.request, 
+            "get_file": self.get_file, 
+            **self.request_kwargs, 
+        }
+        return f"{cls.__module__}.{cls.__qualname__}({', '.join(map('%s=%r'.__mod__, kwargs.items()))})"
 
-if find_spec("httpx"):
-    from filewrap import bytes_iter_to_reader, bytes_iter_to_async_reader
+    @cached_property
+    def response(self, /):
+        return self.file.response
 
-    def httpx_request(
-        url, 
-        method: str = "GET", 
-        auth = None, 
-        follow_redirects: bool = True, 
-        stream: bool = True, 
-        session = None, 
-        **request_kwargs, 
-    ):
-        if session is None:
-            from httpx import Client
-            if "__del__" not in Client.__dict__:
-                setattr(Client, "__del__", lambda self: self.close())
-            session = Client()
-        resp = session.send(
-            request=session.build_request(
-                method=method, 
-                url=url, 
-                **request_kwargs, 
-            ), 
-            auth=auth, 
-            follow_redirects=follow_redirects, 
-            stream=stream, 
-        )
-        setattr(resp, "session", session)
-        return resp
-
-    async def httpx_request_async(
-        url, 
-        method: str = "GET", 
-        auth = None, 
-        follow_redirects: bool = True, 
-        stream: bool = True, 
-        session = None, 
-        **request_kwargs, 
-    ):
-        if session is None:
-            from httpx import AsyncClient
-            if "__del__" not in AsyncClient.__dict__:
-                setattr(AsyncClient, "__del__", lambda self: run_async(self.aclose()))
-            session = AsyncClient()
-        resp = await session.send(
-            request=session.build_request(
-                method=method, 
-                url=url, 
-                **request_kwargs, 
-            ), 
-            auth=auth, 
-            follow_redirects=follow_redirects, 
-            stream=stream, 
-        )
-        setattr(resp, "session", session)
-        return resp
-
-    class HttpxFileReader(HTTPFileReader):
-
-        def __init__(
-            self, 
-            /, 
-            url: str | Callable[[], str], 
-            headers: None | Mapping = None, 
-            start: int = 0, 
-            seek_threshold: int = 1 << 20, 
-            urlopen = None, 
-        ):
-            from httpx import Client
-
-            if urlopen is None or isinstance(urlopen, Client):
-                urlopen = partial(httpx_request, session=urlopen)
-
-            def urlopen_wrapper(url: str, headers: None | Mapping = headers):
-                resp = urlopen(url, headers=headers)
-                resp.raise_for_status()
-                file = bytes_iter_to_reader(resp.iter_raw())
-                self.__dict__["file"] = file
-                return resp
-
-            super().__init__(
-                url, 
-                headers=headers, 
-                start=start, 
-                seek_threshold=seek_threshold, 
-                urlopen=urlopen_wrapper, 
-            )
+    async def aclose(self, /):
+        await self.file.aclose()
+        self._closed = True
 
-        @funcproperty
-        def file_closed(self, /) -> bool:
-            return self.response.is_closed
+    def close(self, /):
+        self.file.close()
+        self._closed = True
 
-    class AsyncHttpxFileReader(AsyncHTTPFileReader):
+    async def read(self, size: None | int = -1, /) -> bytes: # type: ignore
+        if size is None or size < 0:
+            size = self.length - self._pos
+        else:
+            size = min(self.length - self._pos, size)
+        if size <= 0:
+            return b""
+        buf = bytearray(size)
+        await self.readinto(buf)
+        return bytes(buf)
+
+    async def readinto(self, buffer: Buffer, /) -> int: # type: ignore
+        pos = self._pos
+        remaining = min(self.length - pos, buffer_length(buffer))
+        if remaining <= 0:
+            return 0
+        if "file" not in self.__dict__ or self.closed or self.response_closed:
+            await self.reconnect(pos)
+        try:
+            readinto = self.file.readinto
+            view = to_bytes_view(buffer)[:remaining]
+            size = 0
+            while size < remaining:
+                start_pos = pos + size
+                await self.seek(start_pos)
+                size += await readinto(view[size:])
+            return size
+        except:
+            self._pos = pos
+            await self.aclose()
+            raise
 
-        async def __ainit__(
-            self, 
-            /, 
-            url: str | Callable[[], str] | Callable[[], Awaitable[str]], 
-            headers: None | Mapping = None, 
-            start: int = 0, 
-            seek_threshold: int = 1 << 20, 
-            urlopen = None, 
-        ):
-            from httpx import AsyncClient
-
-            if urlopen is None or isinstance(urlopen, AsyncClient):
-                urlopen = partial(httpx_request_async, session=urlopen)
-
-            async def urlopen_wrapper(url: str, headers: None | Mapping = headers):
-                resp = await urlopen(url, headers=headers)
-                resp.raise_for_status()
-                file = bytes_iter_to_async_reader(resp.aiter_raw())
-                self.__dict__["file"] = file
-                return resp
-
-            await super().__ainit__(
-                url=url, 
-                headers=headers, 
-                start=start, 
-                seek_threshold=seek_threshold, 
-                urlopen=urlopen_wrapper, 
-            )
+    async def readline(self, size: None | int = -1, /) -> bytes: # type: ignore
+        pos = self._pos
+        if size is None or size < 0:
+            size = self.length - pos
+        else:
+            size = min(self.length - pos, size)
+        if size <= 0:
+            return b""
+        if "file" not in self.__dict__ or self.closed or self.response_closed:
+            await self.reconnect(pos)
+        try:
+            readline = self.file.readline
+            buf = bytearray()
+            while size > 0:
+                if line := await readline(size):
+                    buf += line
+                    if buf.endswith(b"\n"):
+                        break
+                else:
+                    await self.seek(pos + len(buf))
+                size -= len(line)
+            return bytes(buf)
+        except:
+            self._pos = pos
+            await self.aclose()
+            raise
 
-        @funcproperty
-        def file_closed(self, /) -> bool:
-            return self.response.is_closed
+    async def readlines(self, hint: int = -1, /) -> list[bytes]: # type: ignore
+        pos = self._pos
+        readline = self.readline
+        ls: list[bytes]
+        add = ls.append
+        try:
+            if hint <= 0:
+                while l := await readline():
+                    add(l)
+            else:
+                while hint >=0. and (l := await readline()):
+                    add(l)
+                    hint -= len(l)
+            return ls
+        except:
+            self._pos = pos
+            await self.aclose()
+            raise
+
+    async def read_range(self, size: None | int = -1, /, offset: int = 0) -> bytes:
+        if offset < 0:
+            offset += self.length
+            if offset < 0:
+                offset = 0
+        if size is None or size < 0:
+            size = self.length - offset
+        else:
+            size = min(self.length - offset, size)
+        if size <= 0:
+            return b""
+        buf = bytearray(size)
+        await self.readinto_range(buf, offset)
+        return bytes(buf)
+
+    async def readinto_range(self, buffer: Buffer, /, offset: int = 0):
+        from urllib3_future_request import request_async
+
+        if offset < 0:
+            offset += self.length
+            if offset < 0:
+                offset = 0
+        remaining = min(self.length - offset, buffer_length(buffer))
+        if remaining <= 0:
+            return 0
+        request_kwargs = dict(self.request_kwargs)
+        headers = request_kwargs["headers"] = dict(request_kwargs.get("headers") or ())
+        headers["accept-encoding"] = "identity"
+        view = to_bytes_view(buffer)[:remaining]
+        size = 0
+        while size < remaining:
+            for vol in self._parts:
+                if vol["start"] <= offset < vol["stop"]:
+                    vol_offset = offset + size - vol["start"]
+                    headers["range"] = f"bytes={vol_offset}-"
+                    resp = await request_async(vol["url"], **request_kwargs)
+                    try:
+                        if vol_offset and resp.headers.get("accept-ranges") != "bytes":
+                            raise OSError(29, "non-seekable stream")
+                        size += await resp.readinto(view[size:])
+                    finally:
+                        await resp.close()
+        return size
 
-    __all__.append("HttpxFileReader")
-    __all__.append("AsyncHttpxFileReader")
+    async def reconnect(self, /, start: None | int = None) -> int:
+        if start is None:
+            start = self._pos
+        elif start < 0:
+            start += self.length
+            if start < 0:
+                start = 0
+        if start >= self.length:
+            return start
+        for vol in self._parts:
+            if vol["start"] <= start < vol["stop"]:
+                await self.aclose()
+                file = self.file = await AsyncHTTPFileReader.new(
+                    vol["url"], 
+                    start=vol["start"] - start, 
+                    seek_threshold=self.seek_threshold, 
+                    request=self.request, 
+                    get_file=self.get_file, 
+                    **self.request_kwargs, 
+                )
+                self.response = file.response
+                self._pos = start
+                self._closed = False
+                return start
+        return start
+
+    async def seek(self, pos: int, whence: int = 0, /) -> int: # type: ignore
+        old_pos = self._pos
+        match whence:
+            case 1:
+                pos = old_pos + pos
+            case 2:
+                pos += self.length
+        if pos < 0:
+            pos = 0
+        if pos == old_pos:
+            return pos
+        elif pos >= self.length:
+            await self.aclose()
+            self._pos = pos
+            return pos
+        if hasattr(self, "file"):
+            file = self.file
+            start = old_pos - file._pos
+            stop = start + file.length
+            if start <= pos < stop:
+                await file.seek(pos-start)
+                self._pos = pos
+                return pos
+        return await self.reconnect(pos)
 
-# TODO: 实现任意请求模块的 HTTPFileReader，只要它支持流式读取即可（分成 2 种类型：要么支持 read，要么支持迭代器）
 # TODO: 设计实现一个 HTTPFileWriter，用于实现上传，关闭后视为上传完成
-# TODO: httpx 重新实现 stream 和 async_stream 方法，确保不需要用上下文管理器，如此才能真的简化