Using session context manager and stream=True at the same time

Question

I was wondering if this code is safe:

import requests
with requests.Session() as s:
    response = s.get("http://google.com", stream=True)
content = response.content

For example simple like this, this does not fail (note I don't write "it works" :p), since the pool does not close instantly the connection anyway (that's a point of a session/pool right?).

Using stream=True, the response object is supposed to have its raw attribute that contains the connection, but I'm unsure if the connection is owned by the session or not, and then if at some point if I don't read the content right now but later, it might have been closed.

My current 2 cents is that it's unsafe, but I'm not 100% sure.

Thanks!

[Edit after reading requests code]

After reading the requests code in more details, it seems that it's what requests.get is doing itself:

https://github.com/requests/requests/blob/master/requests/api.py

def request(method, url, **kwargs):
    with sessions.Session() as session:
        return session.request(method=method, url=url, **kwargs)

Being that kwargs might contain stream.

So I guess the answer is "it's safe".

Answer 1

Ok, I got my answer by digging in requests and urllib3

The Response object own the connection until the close() method is explicitly called:

https://github.com/requests/requests/blob/24092b11d74af0a766d9cc616622f38adb0044b9/requests/models.py#L937-L948

def close(self):
    """Releases the connection back to the pool. Once this method has been
    called the underlying ``raw`` object must not be accessed again.
    *Note: Should not normally need to be called explicitly.*
    """
    if not self._content_consumed:
        self.raw.close()

    release_conn = getattr(self.raw, 'release_conn', None)
    if release_conn is not None:
        release_conn()

release_conn() is a urllib3 method, this releases the connection and put it back in the pool

def release_conn(self):
    if not self._pool or not self._connection:
        return

    self._pool._put_conn(self._connection)
    self._connection = None

If the Session was destroyed (like using the with), the pool was destroyed, the connection cannot be put back and it's just closed.

TL;DR; This is safe.

Note that this also means that in stream mode, the connection is not available for the pool until the response is closed explicitly or the content read entirely.