async def handle_async_request(
self,
method: bytes,
url: typing.Tuple[bytes, bytes, typing.Optional[int], bytes],
headers: typing.List[typing.Tuple[bytes, bytes]],
stream: AsyncByteStream,
extensions: dict,
) -> typing.Tuple[int, typing.List[typing.Tuple[bytes, bytes]],
AsyncByteStream, dict]:
with map_httpcore_exceptions():
(
status_code,
headers,
byte_stream,
extensions,
) = await self._pool.handle_async_request(
method=method,
url=url,
headers=headers,
stream=httpcore.AsyncIteratorByteStream(stream.__aiter__()),
extensions=extensions,
)
stream = AsyncResponseStream(byte_stream)
return status_code, headers, stream, extensions
async def handle_async_request(
self,
method: bytes,
url: typing.Tuple[bytes, bytes, typing.Optional[int], bytes],
headers: typing.List[typing.Tuple[bytes, bytes]],
stream: typing.AsyncIterable[bytes],
extensions: dict,
) -> typing.Tuple[int, typing.List[typing.Tuple[bytes, bytes]],
typing.AsyncIterable[bytes], dict]:
with map_httpcore_exceptions():
status_code, headers, byte_stream, extensions = await self._pool.arequest(
method=method,
url=url,
headers=headers,
stream=httpcore.AsyncIteratorByteStream(stream.__aiter__()),
ext=extensions,
)
async def response_stream() -> typing.AsyncIterator[bytes]:
with map_httpcore_exceptions():
async for part in byte_stream:
yield part
async def aclose() -> None:
with map_httpcore_exceptions():
await byte_stream.aclose()
ensure_http_version_reason_phrase_as_bytes(extensions)
extensions["aclose"] = aclose
return status_code, headers, response_stream(), extensions
async def arequest(
self,
method: bytes,
url: Tuple[bytes, bytes, Optional[int], bytes],
headers: Headers = None,
stream: httpcore.AsyncByteStream = None,
ext: dict = None,
) -> Tuple[int, Headers, httpcore.AsyncByteStream, dict]:
stream_id = self._quic.get_next_available_stream_id()
self._read_queue[stream_id] = deque()
self._read_ready[stream_id] = asyncio.Event()
# prepare request
self._http.send_headers(
stream_id=stream_id,
headers=[
(b":method", method),
(b":scheme", url[0]),
(b":authority", url[1]),
(b":path", url[3]),
] + [(k.lower(), v) for (k, v) in headers
if k.lower() not in (b"connection", b"host")],
)
async for data in stream:
self._http.send_data(stream_id=stream_id,
data=data,
end_stream=False)
self._http.send_data(stream_id=stream_id, data=b"", end_stream=True)
# transmit request
self.transmit()
# process response
status_code, headers, stream_ended = await self._receive_response(
stream_id)
response_stream = httpcore.AsyncIteratorByteStream(
aiterator=self._receive_response_data(stream_id, stream_ended))
return (
status_code,
headers,
response_stream,
{
"http_version": "HTTP/3",
},
)
async def test(respx_mock):
assert respx.calls.call_count == 0
async def raw_stream():
yield b"foo"
yield b"bar"
stream = httpcore.AsyncIteratorByteStream(raw_stream())
request = respx_mock.get("https://foo.bar/").mock(
return_value=httpx.Response(202, stream=stream))
response = await client.get("https://foo.bar/")
assert request.called is True
assert response.status_code == 202
assert response.content == b"foobar"
assert respx.calls.call_count == 0
assert respx_mock.calls.call_count == 1
with pytest.raises(AssertionError, match="not mocked"):
httpx.post("https://foo.bar/")
async def arequest(
self,
method: bytes,
url: URL,
headers: Headers = None,
stream: httpcore.AsyncByteStream = None,
ext: dict = None,
) -> Tuple[int, Headers, httpcore.AsyncByteStream, dict]:
self.state = ConnectionState.ACTIVE
self.stream_count += 1
async def on_close():
self.stream_count -= 1
if self.stream_count == 0:
self.state = ConnectionState.IDLE
async def aiterator() -> AsyncIterator[bytes]:
yield b""
stream = httpcore.AsyncIteratorByteStream(aiterator=aiterator(),
aclose_func=on_close)
return 200, [], stream, {}
