Inconsistency while reading chunked output

I have an API which returns Chunked response. As per the requests documentation I'm reading using `iter_content` with `chunk_size` as `None`. 
Documentation Referenced: http://docs.python-requests.org/en/master/user/advanced/#chunk-encoded-requests

Sample Code:

```
import time
import requests


def get_chunked_response():
    session = requests.Session()
    chunked_response = session.post(
        URL,
        json={},
        stream=True,
        timeout=(60, 60))

    assert chunked_response.headers['Transfer-Encoding'] == 'chunked'

    return chunked_response


def stich_dashboards(chunked_response):
    chunks_read = 0
    output = ''
    for chunk in chunked_response.iter_content(chunk_size=None,
                                               decode_unicode=False):
        chunks_read += 1
        output += chunk
        time.sleep(0.001)

    print "Total Chunks read {0}, Output size {1}".format(
        chunks_read, len(output))


chunks = get_chunked_response()
stich_dashboards(chunks)
```

Output
```
 jlahori@jlahori-ld2 ~  while [ 1 ]; do python test_requests.py; done
Total Chunks read 109771, Output size 444895380
Total Chunks read 117570, Output size 476956539
Total Chunks read 97814, Output size 395584817
Total Chunks read 116737, Output size 472958565
```

Why should I get different output sizes each time ? 

However when I remove the `time.sleep(0.001)` from the code, I see  the output size is consistent however, number of chunks read still differ. 

Output with this change:

```
 jlahori@jlahori-ld2 ~  while [ 1 ]; do python test_requests.py; done
Total Chunks read 176138, Output size 715589558
Total Chunks read 176012, Output size 715589558
Total Chunks read 176225, Output size 715589558
Total Chunks read 176161, Output size 715589558
```

```
jlahori@jlahori-ld2 ~  pip freeze | grep requests
requests==2.18.4
```

`curl` to the server always returns the same received size.
```
 jlahori@jlahori-ld2 ~  while [ 1 ]; do curl -i -X POST <URL> -d '{}' --raw > ~/out; done
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  628M    0  628M    0     2   142M      0 --:--:--  0:00:04 --:--:--  145M
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  628M    0  628M    0     2   140M      0 --:--:--  0:00:04 --:--:--  143M
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  628M    0  628M    0     2   137M      0 --:--:--  0:00:04 --:--:--  137M
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  628M    0  628M    0     2   145M      0 --:--:--  0:00:04 --:--:--  146M
```


Any helps on this issue would be much appreciated. Thanks !

Hi there! Thanks for opening this issue. Unfortunately, it seems this is a request for help instead of a report of a defect in the project. Please use [StackOverflow](https://stackoverflow.com) for general usage questions instead and only report defects here.

It looks to be an issue with the requests library here. I opened it up to know is this the expected behavior, Why is behavior of requests changing ?

That documentation does not say you're going to get the chunks back unaltered. We retain the right to not return the actual chunks. If you want those, you need to use a lower level library like urllib3.

Sure, requests retain the right to alter chunks but at the end size of contents of all the chunks should be constant. Right ?

@jayesh92 The final combined contents of all chunks should be constant. The size of any individual chunk is not guaranteed as specified in the [docstring of the method](https://github.com/requests/requests/blob/07372dc058b2948f8657b827977d333f9faf7746/requests/models.py#L728-L729). As @sigmavirus24 has stated, this is intended functionality and not a defect in Requests. Please direct any further questions towards [StackOverflow](https://stackoverflow.com). Thanks!

@nateprewitt Please look at my code and output, It clearly demonstrates that combined contents of all chunks is **NOT constant**.

@jayesh92, if you point your original script at a stable endpoint like https://httpbin.org/stream/20, you'll see the behaviour of your script is static, regardless of sleep. The only occurrence I'm able to reproduce your issue is point at Google which will return dynamic minified js or css, slightly altering the page size. It appears you're not receiving a full response on any of your requests, which leads me to believe your sleep may be causing the server to terminate the connection prematurely due to timeout constraints.

As we've asked before, please move further discussion to StackOverflow. Thank you.