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