Stream content timeout not working for given site

Summary.

I would expect this to timeout but it doesn't.

`r = requests.get('http://mywatchedmovies.com', stream=True, timeout=1)`

But the following does

`r = requests.head('http://mywatchedmovies.com', stream=True, timeout=1)`

Not sure why?

Stackoverflow question: https://stackoverflow.com/questions/46158883/requests-stream-timeout-not-working-for-given-website

## Reproduction Steps

```python
import requests

def fetch_url(url, timeout, max_content, headers):

    r = requests.get(url, stream=True, timeout=timeout, headers=headers)
    r.raise_for_status()

    if int(r.headers.get('Content-Length',0)) > max_content:
        raise ValueError('response too large')

    content = r.raw.read(max_content+1, decode_content=True)
    if len(content) > max_content:
        print(url)
        raise ValueError('Too large a response')
    return {'url':url,'content':content,'status_code':r.status_code}

timeout = 10
max_content = 5000000
headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36'}

fetch_url('http://mywatchedmovies.com', timeout, max_content, headers)
```

## System Information

    $ python -m requests.help

```
{
  "chardet": {
    "version": "3.0.4"
  },
  "cryptography": {
    "version": ""
  },
  "idna": {
    "version": "2.6"
  },
  "implementation": {
    "name": "CPython",
    "version": "3.5.2"
  },
  "platform": {
    "release": "4.4.0-1032-aws",
    "system": "Linux"
  },
  "pyOpenSSL": {
    "openssl_version": "",
    "version": null
  },
  "requests": {
    "version": "2.18.4"
  },
  "system_ssl": {
    "version": "1000207f"
  },
  "urllib3": {
    "version": "1.22"
  },
  "using_pyopenssl": false
}
```

Uh...this is a weird one.

Requests timeouts operate on a per-socket-event basis: that is, a timeout of `1` will fire if it takes more than one second for a server to send us some data: any at all. In this case, the server is sending us *plenty* of data.

The server is returning a 302 redirect to `login.php`. We would like to re-use that TCP connection for the next request, so we attempt to drain the response body. However, the response body is chunk-transfer-encoded, and seems to be completely endless: after an initial 746-byte chunk that contains some actual content the server just repeatedly sends the exact same 307-byte chunk endlessly forever. Because the server is active the whole time we never time out: we just get stuck in a loop trying to drain this socket, and fail.

What the hell is going on with this broken-ass server?

Lukas: Thanks for getting back to me, I don't really need the data coming back I basically just don't want it to break my script. If I use `requests.head()` I get the timeout, which is good. Basically I am trying to weed out junk sites. I could add in `requests.head()` but then am I not hitting the server twice? I have to do many millions of domains as efficiently as possible. Do you have any suggestions?

In this case it's hard to do: due to a patch added a while back you can't prevent Requests trying to follow a redirect. ☹️

In this case, you can try doing `head()`. You will hit the server twice, but only one TCP connection will be used. 

This is probably a noob question but is it a correct reading of http://docs.python-requests.org/en/master/user/advanced/?highlight=tcp#session-objects

That each method `get()` and `head()` is initializing a new session and a new TCP connections? So if I wanted to use the same connection I should use something like this:
```
s = requests.Session()
s.head(url)
s.get(url)
```

Rather than:
```
requests.head(url)
requests.get(url)
```

Or is that implicitly "kept alive" somehow?

To me this:

https://stackoverflow.com/questions/24873927/python-requests-module-and-connection-reuse

Is saying that the following is sufficient.

```
requests.head(url)
requests.get(url)
```

As:

> The requests module is not stateless; it just lets you ignore the state and effectively use a global singleton state if you choose to do so.*
> 
> And it (or, rather, one of the underlying libraries, urllib3) maintains a connection pool keyed by (hostname, port) pair, so it will usually just magically reuse a connection if it can.

Although.

> Note that connections are only released back to the pool for reuse once all body data has been read; be sure to either set stream to False or read the content property of the Response object.

So does that mean.

```
s = requests.Session()
s.head(url,stream=True)
s.get(url,stream=True)
```

Is needed if `stream=True`. 

I guess you probably don't need `stream=True` for `head()`

If you want to connection pool you must use a `Session`.

Thank you sir. If you want to close this issue feel free. I have pulled down hundreds of millions of domains with requests and there has only been a few edge cases. Not sure if this one is worth your time. Appreciate what you do.