This PR fixes a performance issue that occurred with AWS responses that have streaming bodies. The change exposes the underlying iterator of Response directly through the _ResponseStream wrapper, so invocations of the form for item in stream no longer go through the pointless read_into abstraction.

Detailed explanation

This issues surfaced with the new S3 provider, where get_object download would take exponentially longer the larger the body. When bodies are streamed, we wrap the response in a _ResponseStream object that exposes the response as a readable IO object

The issue is that the _ResponseStream is invoked in the form for item in stream. Through the RawIOBase abstraction, this creates an iterator by looping over calls to read_into with a byte buffer of size 1.
The culprit is this line in particular:

After the fix, read_into might actually be dead code now, since the underlying webserver always consumes the response stream using the for data in stream pattern. However, read_into is still necessary for the RawIOBase implementation, so I added tests to cover it.

Reproduce

Here's a simple benchmark. On my machine this takes

• 1.3 seconds without the fix
• 0.00016 seconds with the fix

import timeit

from werkzeug.wrappers.response import _iter_encoded, Response

from localstack.aws.client import _ResponseStream

n_bytes = 200000


def process_stream():
    b = b'0' * n_bytes
    stream = _ResponseStream(Response(b))

    for line in _iter_encoded(stream, 'utf-8'):
        assert line


def main():
    print(timeit.timeit(stmt=process_stream, number=1))


if __name__ == '__main__':
    main()