async def test_async_transport_sleep():
async with AsyncioRequestsTransport() as transport:
await transport.sleep(1)
async with AioHttpTransport() as transport:
await transport.sleep(1)
async def test_aiohttp_auto_headers():
request = HttpRequest("POST", "https://www.bing.com/")
async with AioHttpTransport() as sender:
response = await sender.send(request)
auto_headers = response.internal_response.request_info.headers
assert 'Content-Type' not in auto_headers
async def test_get_form_recognizer_client(self,
formrecognizer_test_endpoint,
formrecognizer_test_api_key,
**kwargs):
# this can be reverted to set_bodiless_matcher() after tests are re-recorded and don't contain these headers
set_custom_default_matcher(
compare_bodies=False,
excluded_headers=
"Authorization,Content-Length,x-ms-client-request-id,x-ms-request-id"
)
transport = AioHttpTransport()
ftc = FormTrainingClient(
endpoint=formrecognizer_test_endpoint,
credential=AzureKeyCredential(formrecognizer_test_api_key),
transport=transport,
api_version="2.1")
async with ftc:
await ftc.get_account_properties()
assert transport.session is not None
async with ftc.get_form_recognizer_client() as frc:
assert transport.session is not None
await (await frc.begin_recognize_receipts_from_url(
self.receipt_url_jpg)).wait()
await ftc.get_account_properties()
assert transport.session is not None
async def test_smoke(port, http_request):
request = http_request(method="GET", url="http://localhost:{}/basic/string".format(port))
async with AioHttpTransport() as sender:
response = await sender.send(request)
response.raise_for_status()
await response.load_body()
assert response.text() == "Hello, world!"
async def test_get_document_analysis_client(self,
formrecognizer_test_endpoint,
formrecognizer_test_api_key,
**kwargs):
# this can be reverted to set_bodiless_matcher() after tests are re-recorded and don't contain these headers
set_custom_default_matcher(
compare_bodies=False,
excluded_headers=
"Authorization,Content-Length,x-ms-client-request-id,x-ms-request-id"
)
transport = AioHttpTransport()
dtc = DocumentModelAdministrationClient(
endpoint=formrecognizer_test_endpoint,
credential=AzureKeyCredential(formrecognizer_test_api_key),
transport=transport)
async with dtc:
await dtc.get_account_info()
assert transport.session is not None
async with dtc.get_document_analysis_client() as dac:
assert transport.session is not None
await (await dac.begin_analyze_document_from_url(
"prebuilt-receipt", self.receipt_url_jpg)).wait()
assert dac._api_version == DocumentAnalysisApiVersion.V2022_01_30_PREVIEW
await dtc.get_account_info()
assert transport.session is not None
def _create_pipeline(self, credential, **kwargs):
credential_policy = None
if credential is None:
raise ValueError("Parameter 'credential' must not be None.")
if hasattr(credential, "get_token"):
credential_policy = AsyncBearerTokenCredentialPolicy(
credential, "https://cognitiveservices.azure.com/.default")
elif isinstance(credential, six.string_types):
credential_policy = CognitiveServicesCredentialPolicy(credential)
elif credential is not None:
raise TypeError("Unsupported credential: {}".format(credential))
config = self._create_configuration(**kwargs)
config.transport = kwargs.get("transport") # type: ignore
if not config.transport:
try:
from azure.core.pipeline.transport import AioHttpTransport
except ImportError:
raise ImportError(
"Unable to create async transport. Please check aiohttp is installed."
)
config.transport = AioHttpTransport(**kwargs)
policies = [
config.headers_policy, config.user_agent_policy,
RequestIdPolicy(**kwargs), config.proxy_policy,
AsyncRedirectPolicy(**kwargs),
AsyncRetryPolicy(**kwargs), credential_policy,
config.logging_policy,
AsyncTextAnalyticsResponseHook(**kwargs),
DistributedTracingPolicy(**kwargs),
HttpLoggingPolicy(**kwargs)
]
return AsyncPipeline(config.transport, policies=policies)
def _build_pipeline(self, **kwargs): # pylint: disable=no-self-use
transport = kwargs.get('transport')
policies = kwargs.get('policies')
credential_policy = \
AsyncServiceBusSharedKeyCredentialPolicy(self._endpoint, self._credential, "Authorization") \
if isinstance(self._credential, ServiceBusSharedKeyCredential) \
else AsyncBearerTokenCredentialPolicy(self._credential, JWT_TOKEN_SCOPE)
if policies is None: # [] is a valid policy list
policies = [
RequestIdPolicy(**kwargs),
self._config.headers_policy,
self._config.user_agent_policy,
self._config.proxy_policy,
ContentDecodePolicy(**kwargs),
ServiceBusXMLWorkaroundPolicy(),
self._config.redirect_policy,
self._config.retry_policy,
credential_policy,
self._config.logging_policy,
DistributedTracingPolicy(**kwargs),
HttpLoggingPolicy(**kwargs),
]
if not transport:
transport = AioHttpTransport(**kwargs)
return AsyncPipeline(transport, policies)
def _configure_policies(self, **kwargs):
# type: (**Any) -> None
try:
from azure.core.pipeline.transport import AioHttpTransport
if not kwargs.get("transport"):
kwargs.setdefault("transport", AioHttpTransport(**kwargs))
except ImportError:
raise ImportError(
"Unable to create async transport. Please check aiohttp is installed."
)
kwargs.setdefault("connection_timeout", CONNECTION_TIMEOUT)
kwargs.setdefault("read_timeout", READ_TIMEOUT)
self._policies = [
StorageHeadersPolicy(**kwargs),
ProxyPolicy(**kwargs),
UserAgentPolicy(sdk_moniker=SDK_MONIKER, **kwargs),
StorageContentValidation(),
StorageRequestHook(**kwargs),
self._credential_policy,
ContentDecodePolicy(response_encoding="utf-8"),
AsyncRedirectPolicy(**kwargs),
StorageHosts(hosts=self._hosts, **kwargs),
AsyncTablesRetryPolicy(**kwargs),
StorageLoggingPolicy(**kwargs),
AsyncStorageResponseHook(**kwargs),
DistributedTracingPolicy(**kwargs),
HttpLoggingPolicy(**kwargs),
]
async def test_basic_options_aiohttp():
request = HttpRequest("OPTIONS", "https://httpbin.org")
async with AsyncPipeline(AioHttpTransport(), policies=[]) as pipeline:
response = await pipeline.run(request)
assert pipeline._transport.session is None
assert isinstance(response.http_response.status_code, int)
async def test_basic_options_aiohttp(port):
request = HttpRequest("OPTIONS", "http://localhost:{}/basic/string".format(port))
async with AsyncPipeline(AioHttpTransport(), policies=[]) as pipeline:
response = await pipeline.run(request)
assert pipeline._transport.session is None
assert isinstance(response.http_response.status_code, int)
async def test_aiohttp_auto_headers(port, http_request):
request = http_request("POST",
"http://localhost:{}/basic/string".format(port))
async with AioHttpTransport() as sender:
response = await sender.send(request)
auto_headers = response.internal_response.request_info.headers
assert 'Content-Type' not in auto_headers
async def test_basic_aiohttp():
request = HttpRequest("GET", "https://www.bing.com/")
async with AioHttpTransport() as sender:
response = await sender.send(request)
assert response.body() is not None
assert sender.session is None
assert isinstance(response.status_code, int)
async def test_response_streaming_error_behavior():
# Test to reproduce https://github.com/Azure/azure-sdk-for-python/issues/16723
block_size = 103
total_response_size = 500
req_response = requests.Response()
req_request = requests.Request()
class FakeStreamWithConnectionError:
# fake object for urllib3.response.HTTPResponse
def __init__(self):
self.total_response_size = 500
def stream(self, chunk_size, decode_content=False):
assert chunk_size == block_size
left = total_response_size
while left > 0:
if left <= block_size:
raise requests.exceptions.ConnectionError()
data = b"X" * min(chunk_size, left)
left -= len(data)
yield data
def read(self, chunk_size, decode_content=False):
assert chunk_size == block_size
if self.total_response_size > 0:
if self.total_response_size <= block_size:
raise requests.exceptions.ConnectionError()
data = b"X" * min(chunk_size, self.total_response_size)
self.total_response_size -= len(data)
return data
def close(self):
pass
req_response.raw = FakeStreamWithConnectionError()
response = AsyncioRequestsTransportResponse(
req_request,
req_response,
block_size,
)
async def mock_run(self, *args, **kwargs):
return PipelineResponse(
None,
requests.Response(),
None,
)
transport = AioHttpTransport()
pipeline = AsyncPipeline(transport)
pipeline.run = mock_run
downloader = response.stream_download(pipeline)
with pytest.raises(requests.exceptions.ConnectionError):
while True:
await downloader.__anext__()
def _build_pipeline(config: "Configuration",
transport: "AsyncHttpTransport" = None,
**kwargs: "Any") -> AsyncPipeline:
policies = _get_policies(config, **kwargs)
if transport is None:
from azure.core.pipeline.transport import AioHttpTransport
transport = AioHttpTransport(**kwargs)
return AsyncPipeline(transport, policies=policies)
async def test_basic_aiohttp():
conf = Configuration()
request = HttpRequest("GET", "https://www.bing.com/")
async with AioHttpTransport(conf) as sender:
response = await sender.send(request)
assert response.body() is not None
assert sender.session is None
assert response.status_code == 200
async def test_basic_aiohttp(port, http_request):
request = http_request("GET",
"http://localhost:{}/basic/string".format(port))
async with AioHttpTransport() as sender:
response = await sender.send(request)
assert response.body() is not None
assert sender.session is None
assert isinstance(response.status_code, int)
async def test_basic_aiohttp():
request = HttpRequest("GET", "https://bing.com")
policies = [UserAgentPolicy("myusergant"), AsyncRedirectPolicy()]
async with AsyncPipeline(AioHttpTransport(),
policies=policies) as pipeline:
response = await pipeline.run(request)
assert pipeline._transport.session is None
assert response.http_response.status_code == 200
async def test_transport_closed_only_once_async(self, resource_group, location, storage_account, storage_account_key):
transport = AioHttpTransport()
prefix = TEST_QUEUE_PREFIX
queue_name = self.get_resource_name(prefix)
async with QueueServiceClient(self.account_url(storage_account.name, "queue"), credential=storage_account_key, transport=transport) as qsc:
await qsc.get_service_properties()
assert transport.session is not None
async with qsc.get_queue_client(queue_name) as qc:
assert transport.session is not None
await qsc.get_service_properties()
assert transport.session is not None
async def test_basic_aiohttp():
request = HttpRequest("GET", "https://bing.com")
policies = [UserAgentPolicy("myusergant"), AsyncRedirectPolicy()]
async with AsyncPipeline(AioHttpTransport(),
policies=policies) as pipeline:
response = await pipeline.run(request)
assert pipeline._transport.session is None
# all we need to check is if we are able to make the call
assert isinstance(response.http_response.status_code, int)
async def test_get_form_recognizer_client(self, resource_group, location, form_recognizer_account, form_recognizer_account_key):
transport = AioHttpTransport()
ftc = FormTrainingClient(endpoint=form_recognizer_account, credential=AzureKeyCredential(form_recognizer_account_key), transport=transport)
async with ftc:
await ftc.get_account_properties()
assert transport.session is not None
async with ftc.get_form_recognizer_client() as frc:
assert transport.session is not None
await frc.recognize_receipts_from_url(self.receipt_url_jpg)
await ftc.get_account_properties()
assert transport.session is not None
async def test_example_aiohttp():
request = HttpRequest("GET", "https://bing.com")
policies = [UserAgentPolicy("myuseragent"), AsyncRedirectPolicy()]
# [START aiohttp]
from azure.core.pipeline.transport import AioHttpTransport
async with AsyncPipeline(AioHttpTransport(),
policies=policies) as pipeline:
response = await pipeline.run(request)
# [END aiohttp]
assert pipeline._transport.session is None
assert response.http_response.status_code == 200
def _build_pipeline(self,
config: Configuration,
policies: "Optional[List[Policy]]" = None,
transport: "Optional[AsyncHttpTransport]" = None,
**kwargs: "Any") -> AsyncPipeline:
if policies is None: # [] is a valid policy list
policies = _get_policies(config, **kwargs)
if not transport:
from azure.core.pipeline.transport import AioHttpTransport
transport = AioHttpTransport(**kwargs)
return AsyncPipeline(transport=transport, policies=policies)
async def test_basic_aiohttp_separate_session():
session = aiohttp.ClientSession()
request = HttpRequest("GET", "https://bing.com")
policies = [UserAgentPolicy("myusergant"), AsyncRedirectPolicy()]
transport = AioHttpTransport(session=session, session_owner=False)
async with AsyncPipeline(transport, policies=policies) as pipeline:
response = await pipeline.run(request)
assert transport.session
assert isinstance(response.http_response.status_code, int)
await transport.close()
assert transport.session
await transport.session.close()
def __init__(self, vault_url: str, credential: "AsyncTokenCredential",
**kwargs: "Any") -> None:
if not credential:
raise ValueError(
"credential should be an object supporting the AsyncTokenCredential protocol, "
"such as a credential from azure-identity")
if not vault_url:
raise ValueError("vault_url must be the URL of an Azure Key Vault")
try:
self.api_version = kwargs.pop("api_version", DEFAULT_VERSION)
self._vault_url = vault_url.strip(" /")
client = kwargs.get("generated_client")
if client:
# caller provided a configured client -> only models left to initialize
self._client = client
models = kwargs.get("generated_models")
self._models = models or _KeyVaultClient.models(
api_version=self.api_version)
return
pipeline = kwargs.pop("pipeline", None)
transport = kwargs.pop("transport", None)
http_logging_policy = HttpLoggingPolicy(**kwargs)
http_logging_policy.allowed_header_names.update({
"x-ms-keyvault-network-info", "x-ms-keyvault-region",
"x-ms-keyvault-service-version"
})
if not transport and not pipeline:
from azure.core.pipeline.transport import AioHttpTransport
transport = AioHttpTransport(**kwargs)
self._client = _KeyVaultClient(
api_version=self.api_version,
pipeline=pipeline,
transport=transport,
authentication_policy=AsyncChallengeAuthPolicy(credential),
sdk_moniker=SDK_MONIKER,
http_logging_policy=http_logging_policy,
**kwargs)
self._models = _KeyVaultClient.models(api_version=self.api_version)
except ValueError:
raise NotImplementedError(
"This package doesn't support API version '{}'. ".format(
self.api_version) +
"Supported versions: {}".format(", ".join(
v.value for v in ApiVersion)))
def build_async_pipeline(transport=None, policies=None, **kwargs):
from azure.core.pipeline import AsyncPipeline
if not policies:
from azure.core.pipeline.policies import AsyncRetryPolicy
config = _get_config(**kwargs)
config.retry_policy = AsyncRetryPolicy(**kwargs)
policies = _get_policies(config, **kwargs)
if not transport:
from azure.core.pipeline.transport import AioHttpTransport
transport = AioHttpTransport(**kwargs)
return AsyncPipeline(transport, policies=policies)
async def test_transport_closed_only_once(self, containerregistry_endpoint):
transport = AioHttpTransport()
client = self.create_registry_client(containerregistry_endpoint, transport=transport)
async with client:
async for r in client.list_repository_names():
pass
assert transport.session is not None
repo_client = client.get_repository(HELLO_WORLD)
async with repo_client:
assert transport.session is not None
async for r in client.list_repository_names():
pass
assert transport.session is not None
def __init__(self, credential, **kwargs): # pylint:disable=super-init-not-called
self._set_universal(**kwargs)
# async-specific azure pipeline policies
if isinstance(credential, str):
self.headers_policy.add_header("Ocp-Apim-Subscription-Key",
credential)
else:
scopes = kwargs.pop("scopes", [])
self.authentication_policy = AsyncBearerTokenCredentialPolicy(
credential, *scopes, **kwargs)
self.retry_policy = kwargs.get("retry_policy",
AsyncRetryPolicy(**kwargs))
self.redirect_policy = kwargs.get("redirect_policy",
AsyncRedirectPolicy(**kwargs))
self.transport = kwargs.get("transport", AioHttpTransport())
async def test_transport_closed_only_once(self, containerregistry_baseurl):
transport = AioHttpTransport()
client = self.create_registry_client(containerregistry_baseurl,
transport=transport)
async with client:
async for r in client.list_repositories():
pass
assert transport.session is not None
repo_client = client.get_repository_client("hello-world")
async with repo_client:
assert transport.session is not None
async for r in client.list_repositories():
pass
assert transport.session is not None
def __init__(self,
config: "Optional[Configuration]" = None,
policies: "Optional[Iterable[AsyncHTTPPolicy]]" = None,
transport: "Optional[AsyncHttpTransport]" = None,
**kwargs: "Any") -> None:
config = config or self._create_config(**kwargs)
policies = policies or [
config.retry_policy, config.logging_policy,
DistributedTracingPolicy()
]
self._transport = transport or AioHttpTransport(configuration=config)
atexit.register(
self._close_transport_session) # prevent aiohttp warnings
self._pipeline = AsyncPipeline(transport=self._transport,
policies=policies)
async def test_example_async_pipeline():
# [START build_async_pipeline]
from azure.core.pipeline import AsyncPipeline
from azure.core.pipeline.policies import AsyncRedirectPolicy, UserAgentPolicy
from azure.core.pipeline.transport import AioHttpTransport, HttpRequest
# example: create request and policies
request = HttpRequest("GET", "https://bing.com")
policies = [UserAgentPolicy("myuseragent"), AsyncRedirectPolicy()]
# run the pipeline
async with AsyncPipeline(transport=AioHttpTransport(),
policies=policies) as pipeline:
response = await pipeline.run(request)
# [END build_async_pipeline]
assert pipeline._transport.session is None
assert response.http_response.status_code == 200
