support chunked upload in async file-like interfaces

Author: tsimoshka

httpx/_content.py

@@ -17,6 +17,7 @@
 from ._multipart import MultipartStream
 from ._types import (
     AsyncByteStream,
+    AsyncFile,
     RequestContent,
     RequestData,
     RequestFiles,
@@ -83,6 +84,11 @@ async def __aiter__(self) -> AsyncIterator[bytes]:
             while chunk:
                 yield chunk
                 chunk = await self._stream.aread(self.CHUNK_SIZE)
+        elif isinstance(self._stream, AsyncFile):
+            chunk = await self._stream.read(self.CHUNK_SIZE)
+            while chunk:
+                yield chunk
+                chunk = await self._stream.read(self.CHUNK_SIZE)
         else:
             # Otherwise iterate.
             async for part in self._stream:
@@ -127,7 +133,12 @@ def encode_content(
         return headers, IteratorByteStream(content)  # type: ignore
 
     elif isinstance(content, AsyncIterable):
-        headers = {"Transfer-Encoding": "chunked"}
+        if isinstance(content, AsyncFile):
+            content_length_or_none = peek_filelike_length(content)
+        if content_length_or_none is None:
+            headers = {"Transfer-Encoding": "chunked"}
+        else:
+            headers = {"Content-Length": str(content_length_or_none)}
         return headers, AsyncIteratorByteStream(content)
 
     raise TypeError(f"Unexpected type for 'content', {type(content)!r}")

httpx/_types.py

@@ -7,6 +7,7 @@
     IO,
     TYPE_CHECKING,
     Any,
+    AnyStr,
     AsyncIterable,
     AsyncIterator,
     Callable,
@@ -16,9 +17,11 @@
     List,
     Mapping,
     Optional,
+    Protocol,
     Sequence,
     Tuple,
     Union,
+    runtime_checkable,
 )
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -112,3 +115,10 @@ async def __aiter__(self) -> AsyncIterator[bytes]:
 
     async def aclose(self) -> None:
         pass
+
+
+@runtime_checkable
+class AsyncFile(Protocol):
+    async def read(self, size: int = -1) -> AnyStr: ...
+
+    def fileno(self) -> int: ...

requirements.txt

@@ -27,3 +27,5 @@ trio==0.31.0
 trio-typing==0.10.0
 trustme==1.2.1
 uvicorn==0.35.0
+aiofiles==25.1.0
+types-aiofiles==25.1.0.20251011

tests/test_content.py

@@ -1,9 +1,14 @@
 import io
 import typing
 
+import aiofiles
+import anyio
 import pytest
+import trio
 
 import httpx
+from httpx._content import AsyncIteratorByteStream
+from httpx._types import AsyncFile
 
 method = "POST"
 url = "https://www.example.com"
@@ -516,3 +521,66 @@ def test_allow_nan_false():
         ValueError, match="Out of range float values are not JSON compliant"
     ):
         httpx.Response(200, json=data_with_inf)
+
+
+@pytest.mark.parametrize("client_method", ["put", "post"])
+@pytest.mark.anyio
+async def test_chunked_async_file_content(
+    tmp_path, anyio_backend, monkeypatch, client_method
+):
+    total_chunks = 3
+
+    def echo_request_content(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(200, content=request.content)
+
+    content_bytes = b"".join([b"a" * AsyncIteratorByteStream.CHUNK_SIZE] * total_chunks)
+    to_upload = tmp_path / "upload.txt"
+    to_upload.write_bytes(content_bytes)
+
+    async def checks(client: httpx.AsyncClient, async_file: AsyncFile) -> None:
+        read_called = 0
+        fileno_called = 0
+        original_read = async_file.read
+        original_fileno = async_file.fileno
+
+        async def mock_read(*args, **kwargs):
+            nonlocal read_called
+            read_called += 1
+            return await original_read(*args, **kwargs)
+
+        def mock_fileno(*args):
+            nonlocal fileno_called
+            fileno_called += 1
+            return original_fileno(*args)
+
+        monkeypatch.setattr(async_file, "read", mock_read)
+        monkeypatch.setattr(async_file, "fileno", mock_fileno)
+        response = await getattr(client, client_method)(
+            url="http://127.0.0.1:8000/", content=async_file
+        )
+        assert response.status_code == 200
+        assert response.content == content_bytes
+        assert response.request.headers["Content-Length"] == str(len(content_bytes))
+        assert read_called == total_chunks + 1
+        assert fileno_called == 1
+
+    async with (
+        await anyio.open_file(to_upload, mode="rb")
+        if anyio_backend != "trio"
+        else await trio.open_file(to_upload, mode="rb") as async_file,
+        httpx.AsyncClient(
+            transport=httpx.MockTransport(echo_request_content)
+        ) as client,
+    ):
+        assert isinstance(async_file, AsyncFile)
+        await checks(client, async_file)
+
+    if anyio_backend != "trio":  # aiofiles doesn't work with trio
+        async with (
+            aiofiles.open(to_upload, mode="rb") as aio_file,
+            httpx.AsyncClient(
+                transport=httpx.MockTransport(echo_request_content)
+            ) as client,
+        ):
+            assert isinstance(aio_file, AsyncFile)
+            await checks(client, aio_file)