Requests does not terminate sending data if a response is received

**Summary**
A request.post() will continue sending the entirety of the provided data after the receiver has already attempted to terminate the request. Specifically, this problem is occurring with requests 2.23.0, and the request is being sent to a Django server running Django 3.0.5. I was unsure if this should be a bug or a feature, but since it deviates from other standard tools (e.g. curl), I figured it should be a bug.

**Expected Result**
1. I send a POST request to a Django server's endpoint containing some large (>200 mb) multi-part encoded file. 
2. The Django server quickly returns an HTTP 400 response to the sender. 
3. I expect that the sender would then stop sending data over the socket, collect Django's response, and return from the POST without sending the rest of the data, which will never be read.

This is Curl's response to handling receiving an early response.

**Actual Result**

Step 1 and 2 proceed as normal. In step 3, requests will instead continue sending all of the data to the server even though a response has already been received. 

My use case is sending files on the order of several GB (which I know is not typical), and request's behavior will kill the receiving server because Django will attempt to read all the 'leftover' data (which is a huge amount) in one run.

**Reproduction Steps**

**Request's Side**
```python
import requests
file_name = 'test.txt'
f_handle = open(file_name, 'rb')
res = requests.post('http://localhost:8000/upload', files={'file': (file_name, f_handle, 'raw')})
res.raise_for_status()
```

The error can be difficult to see here because at a certain file size there will be a memory error from requests, so it's hard to tell if it's stuck sending. Using requests-toolbelt allows arbitrarily large multipart files by streaming them, and I originally posted the error there - [Requests-Toolbelt error](https://github.com/requests/toolbelt/issues/292). If it makes the hang when requests sends the entire file easier to see, here's code using a MultipartEncoder as well, toolbelt version 0.9.1.
**Alt Request's Side**: 
```python
import requests
from requests_toolbelt.multipart.encoder import MultipartEncoder

file_name = 'test.txt'
f_handle = open(file_name, 'rb')
m = MultipartEncoder({'file': (file_name, f_handle, 'raw')})
res = requests.post('http://localhost:8000/upload', data=m, headers={'Content-Type': m.content_type})
res.raise_for_status()
```

**Django views.py**: Just kicks back an error
```python
from django.http import HttpResponse
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_POST

@csrf_exempt
@require_POST
def upload(request):
    return HttpResponse("Done!", status=400)
```

**Curl's Behavior**: Sending an ~800mb file, stops immediately (147 bytes in) and shows Django's response.
`curl -F file=test.txt -k http://localhost:8000/upload`

```
%       Total    %      Received %    Xferd    Average Speed    Time    Time     Time      Current
                                               Dload   Upload   Total   Spent    Left        Speed
100    152      100     5       100   147      333     9800      --:--:-- --:--:-- --:--:--   10133 Done!
```

**System Information**
```
{
  "chardet": {
    "version": "3.0.4"
  },
  "cryptography": {
    "version": ""
  },
  "idna": {
    "version": "2.9"
  },
  "implementation": {
    "name": "CPython",
    "version": "3.6.6"
  },
  "platform": {
    "release": "7",
    "system": "Windows"
  },
  "pyOpenSSL": {
    "openssl_version": "",
    "version": null
  },
  "requests": {
    "version": "2.23.0"
  },
  "system_ssl": {
    "version": "100020ff"
  },
  "urllib3": {
    "version": "1.25.8"
  },
  "using_pyopenssl": false
}
```

Early responses aren't supported by Python's standard `httplib`/`http.client` and so Requests and urllib3 cannot support them.

Thank you for the quick response. Do you know if httplib2 supports early responses, or is requests already based on httplib2?

I would expect a client built on something like Twisted or Tornado to be able to handle early responses. I don't expect that `httplib2` would handle that but it might.

Just for posterity's sake, in case anyone has a similar use case - I found that PycURL supports handling early responses. Thanks for the information!