Connections apparently not reused when using stream()

[neoq]

In this example:

import httpcore
import anyio

http_pool = httpcore.AsyncConnectionPool(
    max_connections=2,
    max_keepalive_connections=2,
    keepalive_expiry=60,
    http2=False,
    http1=True,
)

async def main():
    async with http_pool.stream(
        method="GET",
        url=f"http://github.com/",
    ) as response:
        print(response)
        print(http_pool.connections)
    print(http_pool.connections)

    async with http_pool.stream(
        method="GET",
        url=f"http://github.com/",
    ) as response:
        print(response)
        print(http_pool.connections)
    print(http_pool.connections)

anyio.run(main)

I would expect the output to show one AsyncHTTPConnection with Request Count: 2 being used. However, I see the following:

<Response [301]>
[<AsyncHTTPConnection ['http://github.com:80', HTTP/1.1, ACTIVE, Request Count: 1]>]
[]
<Response [301]>
[<AsyncHTTPConnection ['http://github.com:80', HTTP/1.1, ACTIVE, Request Count: 1]>]
[]

indicating the context manager closes the connection in between.

With http2=True, http1=False I get the expected connection reuse:

<Response [301]>
[<AsyncHTTPConnection ['http://github.com:80', HTTP/2, ACTIVE, Request Count: 1]>]
[<AsyncHTTPConnection ['http://github.com:80', HTTP/2, IDLE, Request Count: 1]>]
<Response [301]>
[<AsyncHTTPConnection ['http://github.com:80', HTTP/2, ACTIVE, Request Count: 2]>]
[<AsyncHTTPConnection ['http://github.com:80', HTTP/2, IDLE, Request Count: 2]>]

With regular request(), not stream():

import httpcore
import anyio

http_pool = httpcore.AsyncConnectionPool(
	max_connections=2,
	max_keepalive_connections=2,
	keepalive_expiry=60,
	http2=False,
	http1=True,
)

async def main():
    response = await http_pool.request(method="GET", url=f"http://github.com/")
    print(response)
    print(http_pool.connections)

    response = await http_pool.request(method="GET", url=f"http://github.com/")
    print(response)
    print(http_pool.connections)

anyio.run(main)

I get the connection reuse I expect, but I would like to stream both request and response body.

<Response [301]>
[<AsyncHTTPConnection ['http://github.com:80', HTTP/1.1, IDLE, Request Count: 1]>]
<Response [301]>
[<AsyncHTTPConnection ['http://github.com:80', HTTP/1.1, IDLE, Request Count: 2]>]

Maybe I simply misunderstand the purpose of the context manager of stream
Thanks

[TayfurYldz]

The context manager itself isn't what prevents HTTP/1.1 reuse. The important distinction is whether the response body has been consumed before the context exits.

stream() deliberately does not read the body for you. On exit it calls response.aclose(). For HTTP/1.1, httpcore can put the connection back into IDLE only after the h11 state machine has reached DONE for both sides. If you leave the context without consuming the response stream, that state hasn't been reached, so closing the response also closes that HTTP/1.1 connection.

That explains the difference from request(): current request() does:

response = await self.handle_async_request(request)
try:
    await response.aread()
finally:
    await response.aclose()

whereas stream() yields the unread response directly.

Consume the stream inside the context:

async with http_pool.stream(
    method="GET",
    url="http://github.com/",
) as response:
    async for chunk in response.aiter_stream():
        # process chunk
        ...

If the entire body is consumed normally, the HTTP/1.1 response reaches its completed state and the pool can reuse the connection. If you intentionally stop reading early, closing the connection is expected for a response whose remaining HTTP/1.1 body can't safely be left on the socket for the next request.

I checked the current implementation: stream() closes the response in its finally, and HTTP11Connection._response_closed() only transitions back to IDLE when both h11 sides are DONE; otherwise it closes the connection. So the behavior in the example is consistent with exiting with an unread 301 response body, rather than stream() being inherently non-reusable.