async def __anext__(self):
internal_response = self.response.internal_response
try:
chunk = await internal_response.content.read(self.block_size)
if not chunk:
raise _ResponseStopIteration()
if not self._decompress:
return chunk
enc = internal_response.headers.get('Content-Encoding')
if not enc:
return chunk
enc = enc.lower()
if enc in ("gzip", "deflate"):
if not self._decompressor:
import zlib
zlib_mode = 16 + zlib.MAX_WBITS if enc == "gzip" else zlib.MAX_WBITS
self._decompressor = zlib.decompressobj(wbits=zlib_mode)
chunk = self._decompressor.decompress(chunk)
return chunk
except _ResponseStopIteration:
internal_response.close()
raise StopAsyncIteration()
except aiohttp.client_exceptions.ClientPayloadError as err:
# This is the case that server closes connection before we finish the reading. aiohttp library
# raises ClientPayloadError.
_LOGGER.warning("Incomplete download: %s", err)
internal_response.close()
raise IncompleteReadError(err, error=err)
except Exception as err:
_LOGGER.warning("Unable to stream download: %s", err)
internal_response.close()
raise
async def __anext__(self):
internal_response = self.response.internal_response
try:
try:
chunk = await trio.to_thread.run_sync(
_iterate_response_content,
self.iter_content_func,
)
except AttributeError: # trio < 0.12.1
chunk = await trio.run_sync_in_worker_thread( # pylint: disable=no-member
_iterate_response_content,
self.iter_content_func,
)
if not chunk:
raise _ResponseStopIteration()
return chunk
except _ResponseStopIteration:
internal_response.close()
raise StopAsyncIteration()
except requests.exceptions.StreamConsumedError:
raise
except requests.exceptions.ChunkedEncodingError as err:
msg = err.__str__()
if 'IncompleteRead' in msg:
_LOGGER.warning("Incomplete download: %s", err)
internal_response.close()
raise IncompleteReadError(err, error=err)
_LOGGER.warning("Unable to stream download: %s", err)
internal_response.close()
raise HttpResponseError(err, error=err)
except Exception as err:
_LOGGER.warning("Unable to stream download: %s", err)
internal_response.close()
raise
def __next__(self):
internal_response = self.response.internal_response
try:
chunk = next(self.iter_content_func)
if not chunk:
raise StopIteration()
return chunk
except StopIteration:
internal_response.close()
raise StopIteration()
except requests.exceptions.StreamConsumedError:
raise
except requests.exceptions.ContentDecodingError as err:
raise DecodeError(err, error=err)
except requests.exceptions.ChunkedEncodingError as err:
msg = err.__str__()
if 'IncompleteRead' in msg:
_LOGGER.warning("Incomplete download: %s", err)
internal_response.close()
raise IncompleteReadError(err, error=err)
_LOGGER.warning("Unable to stream download: %s", err)
internal_response.close()
raise HttpResponseError(err, error=err)
except Exception as err:
_LOGGER.warning("Unable to stream download: %s", err)
internal_response.close()
raise
async def __anext__(self):
loop = _get_running_loop()
internal_response = self.response.internal_response
try:
chunk = await loop.run_in_executor(
None,
_iterate_response_content,
self.iter_content_func,
)
if not chunk:
raise _ResponseStopIteration()
return chunk
except _ResponseStopIteration:
internal_response.close()
raise StopAsyncIteration()
except requests.exceptions.StreamConsumedError:
raise
except requests.exceptions.ChunkedEncodingError as err:
msg = err.__str__()
if 'IncompleteRead' in msg:
_LOGGER.warning("Incomplete download: %s", err)
internal_response.close()
raise IncompleteReadError(err, error=err)
_LOGGER.warning("Unable to stream download: %s", err)
internal_response.close()
raise HttpResponseError(err, error=err)
except Exception as err:
_LOGGER.warning("Unable to stream download: %s", err)
internal_response.close()
raise
async def load_body(self) -> None:
"""Load in memory the body, so it could be accessible from sync methods."""
try:
self._content = await self.internal_response.read()
except aiohttp.client_exceptions.ClientPayloadError as err:
# This is the case that server closes connection before we finish the reading. aiohttp library
# raises ClientPayloadError.
raise IncompleteReadError(err, error=err)
async def send(self, request, **kwargs: Any): # pylint:disable=invalid-overridden-method
"""Send the request using this HTTP sender.
:param request: The HttpRequest
:type request: ~azure.core.pipeline.transport.HttpRequest
:return: The AsyncHttpResponse
:rtype: ~azure.core.pipeline.transport.AsyncHttpResponse
:keyword requests.Session session: will override the driver session and use yours.
Should NOT be done unless really required. Anything else is sent straight to requests.
:keyword dict proxies: will define the proxy to use. Proxy is a dict (protocol, url)
"""
self.open()
trio_limiter = kwargs.get("trio_limiter", None)
response = None
error = None # type: Optional[AzureErrorUnion]
data_to_send = await self._retrieve_request_data(request)
try:
try:
response = await trio.to_thread.run_sync(functools.partial(
self.session.request,
request.method,
request.url,
headers=request.headers,
data=data_to_send,
files=request.files,
verify=kwargs.pop('connection_verify',
self.connection_config.verify),
timeout=kwargs.pop('connection_timeout',
self.connection_config.timeout),
cert=kwargs.pop('connection_cert',
self.connection_config.cert),
allow_redirects=False,
**kwargs),
limiter=trio_limiter)
except AttributeError: # trio < 0.12.1
response = await trio.run_sync_in_worker_thread( # pylint: disable=no-member
functools.partial(
self.session.request,
request.method,
request.url,
headers=request.headers,
data=request.data,
files=request.files,
verify=kwargs.pop('connection_verify',
self.connection_config.verify),
timeout=kwargs.pop('connection_timeout',
self.connection_config.timeout),
cert=kwargs.pop('connection_cert',
self.connection_config.cert),
allow_redirects=False,
**kwargs),
limiter=trio_limiter)
response.raw.enforce_content_length = True
except urllib3.exceptions.NewConnectionError as err:
error = ServiceRequestError(err, error=err)
except requests.exceptions.ReadTimeout as err:
error = ServiceResponseError(err, error=err)
except requests.exceptions.ConnectionError as err:
if err.args and isinstance(err.args[0],
urllib3.exceptions.ProtocolError):
error = ServiceResponseError(err, error=err)
else:
error = ServiceRequestError(err, error=err)
except requests.exceptions.ChunkedEncodingError as err:
msg = err.__str__()
if 'IncompleteRead' in msg:
_LOGGER.warning("Incomplete download: %s", err)
error = IncompleteReadError(err, error=err)
else:
_LOGGER.warning("Unable to stream download: %s", err)
error = HttpResponseError(err, error=err)
except requests.RequestException as err:
error = ServiceRequestError(err, error=err)
if error:
raise error
if _is_rest(request):
from azure.core.rest._requests_trio import RestTrioRequestsTransportResponse
retval = RestTrioRequestsTransportResponse(
request=request,
internal_response=response,
block_size=self.connection_config.data_block_size,
)
if not kwargs.get("stream"):
await _handle_no_stream_rest_response(retval)
return retval
return TrioRequestsTransportResponse(
request, response, self.connection_config.data_block_size)
def send(self, request, **kwargs): # type: ignore
"""Send request object according to configuration.
:param request: The request object to be sent.
:type request: ~azure.core.pipeline.transport.HttpRequest
:return: An HTTPResponse object.
:rtype: ~azure.core.pipeline.transport.HttpResponse
:keyword requests.Session session: will override the driver session and use yours.
Should NOT be done unless really required. Anything else is sent straight to requests.
:keyword dict proxies: will define the proxy to use. Proxy is a dict (protocol, url)
"""
self.open()
response = None
error = None # type: Optional[AzureErrorUnion]
try:
connection_timeout = kwargs.pop('connection_timeout', self.connection_config.timeout)
if isinstance(connection_timeout, tuple):
if 'read_timeout' in kwargs:
raise ValueError('Cannot set tuple connection_timeout and read_timeout together')
_LOGGER.warning("Tuple timeout setting is deprecated")
timeout = connection_timeout
else:
read_timeout = kwargs.pop('read_timeout', self.connection_config.read_timeout)
timeout = (connection_timeout, read_timeout)
response = self.session.request( # type: ignore
request.method,
request.url,
headers=request.headers,
data=request.data,
files=request.files,
verify=kwargs.pop('connection_verify', self.connection_config.verify),
timeout=timeout,
cert=kwargs.pop('connection_cert', self.connection_config.cert),
allow_redirects=False,
**kwargs)
response.raw.enforce_content_length = True
except (urllib3.exceptions.NewConnectionError, urllib3.exceptions.ConnectTimeoutError) as err:
error = ServiceRequestError(err, error=err)
except requests.exceptions.ReadTimeout as err:
error = ServiceResponseError(err, error=err)
except requests.exceptions.ConnectionError as err:
if err.args and isinstance(err.args[0], urllib3.exceptions.ProtocolError):
error = ServiceResponseError(err, error=err)
else:
error = ServiceRequestError(err, error=err)
except requests.exceptions.ChunkedEncodingError as err:
msg = err.__str__()
if 'IncompleteRead' in msg:
_LOGGER.warning("Incomplete download: %s", err)
error = IncompleteReadError(err, error=err)
else:
_LOGGER.warning("Unable to stream download: %s", err)
error = HttpResponseError(err, error=err)
except requests.RequestException as err:
error = ServiceRequestError(err, error=err)
if error:
raise error
if _is_rest(request):
from azure.core.rest._requests_basic import RestRequestsTransportResponse
retval = RestRequestsTransportResponse(
request=request,
internal_response=response,
block_size=self.connection_config.data_block_size
)
if not kwargs.get('stream'):
_handle_non_stream_rest_response(retval)
return retval
return RequestsTransportResponse(request, response, self.connection_config.data_block_size)