def _create_pipeline(self, credential, **kwargs):
     # type: (Any, **Any) -> Tuple[Configuration, Pipeline]
     self._credential_policy = None
     if hasattr(credential, 'get_token'):
         self._credential_policy = AsyncBearerTokenCredentialPolicy(credential, STORAGE_OAUTH_SCOPE)
     elif isinstance(credential, SharedKeyCredentialPolicy):
         self._credential_policy = credential
     elif isinstance(credential, AzureSasCredential):
         self._credential_policy = AzureSasCredentialPolicy(credential)
     elif credential is not None:
         raise TypeError("Unsupported credential: {}".format(credential))
     config = kwargs.get('_configuration') or create_configuration(**kwargs)
     if kwargs.get('_pipeline'):
         return config, kwargs['_pipeline']
     config.transport = kwargs.get('transport')  # type: ignore
     kwargs.setdefault("connection_timeout", CONNECTION_TIMEOUT)
     kwargs.setdefault("read_timeout", READ_TIMEOUT)
     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 = [
         QueueMessagePolicy(),
         config.headers_policy,
         config.proxy_policy,
         config.user_agent_policy,
         StorageContentValidation(),
         StorageRequestHook(**kwargs),
         self._credential_policy,
         ContentDecodePolicy(response_encoding="utf-8"),
         AsyncRedirectPolicy(**kwargs),
         StorageHosts(hosts=self._hosts, **kwargs), # type: ignore
         config.retry_policy,
         config.logging_policy,
         AsyncStorageResponseHook(**kwargs),
         DistributedTracingPolicy(**kwargs),
         HttpLoggingPolicy(**kwargs),
     ]
     if kwargs.get("_additional_pipeline_policies"):
         policies = policies + kwargs.get("_additional_pipeline_policies")
     return config, AsyncPipeline(config.transport, policies=policies)
    def _create_pipeline(self, credential, **kwargs):
        # type: (Any, **Any) -> Tuple[Configuration, Pipeline]
        self._credential_policy = None
        if hasattr(credential, "get_token"):
            self._credential_policy = StorageBearerTokenCredentialPolicy(credential)
        elif isinstance(credential, SharedKeyCredentialPolicy):
            self._credential_policy = credential
        elif isinstance(credential, AzureSasCredential):
            self._credential_policy = AzureSasCredentialPolicy(credential)
        elif credential is not None:
            raise TypeError("Unsupported credential: {}".format(credential))

        config = kwargs.get("_configuration") or create_configuration(**kwargs)
        if kwargs.get("_pipeline"):
            return config, kwargs["_pipeline"]
        config.transport = kwargs.get("transport")  # type: ignore
        kwargs.setdefault("connection_timeout", CONNECTION_TIMEOUT)
        kwargs.setdefault("read_timeout", READ_TIMEOUT)
        if not config.transport:
            config.transport = RequestsTransport(**kwargs)
        policies = [
            QueueMessagePolicy(),
            config.proxy_policy,
            config.user_agent_policy,
            StorageContentValidation(),
            ContentDecodePolicy(response_encoding="utf-8"),
            RedirectPolicy(**kwargs),
            StorageHosts(hosts=self._hosts, **kwargs),
            config.retry_policy,
            config.headers_policy,
            StorageRequestHook(**kwargs),
            self._credential_policy,
            config.logging_policy,
            StorageResponseHook(**kwargs),
            DistributedTracingPolicy(**kwargs),
            HttpLoggingPolicy(**kwargs)
        ]
        if kwargs.get("_additional_pipeline_policies"):
            policies = policies + kwargs.get("_additional_pipeline_policies")
        return config, Pipeline(config.transport, policies=policies)