def __init__(self, endpoint: str, **kwargs: Any) -> None:
_base_url = '{endpoint}'
self._config = SearchClientConfiguration(endpoint=endpoint, **kwargs)
self._client = AsyncPipelineClient(base_url=_base_url,
config=self._config,
**kwargs)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
self._serialize.client_side_validation = False
self.data_sources = DataSourcesOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.indexers = IndexersOperations(self._client, self._config,
self._serialize, self._deserialize)
self.skillsets = SkillsetsOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.synonym_maps = SynonymMapsOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.indexes = IndexesOperations(self._client, self._config,
self._serialize, self._deserialize)
def __init__(self, version, url, **kwargs):
base_url = '{url}'
self._config = AzureFileStorageConfiguration(version, url, **kwargs)
self._client = AsyncPipelineClient(base_url=base_url,
config=self._config,
**kwargs)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self.api_version = '2019-02-02'
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
self.service = ServiceOperations(self._client, self._config,
self._serialize, self._deserialize)
self.share = ShareOperations(self._client, self._config,
self._serialize, self._deserialize)
self.directory = DirectoryOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.file = FileOperations(self._client, self._config, self._serialize,
self._deserialize)
def __init__(self, endpoint: str, credential: "AsyncTokenCredential",
**kwargs: Any) -> None:
_endpoint = '{Endpoint}/catalog/api'
self._config = PurviewCatalogClientConfiguration(endpoint=endpoint,
credential=credential,
**kwargs)
self._client = AsyncPipelineClient(base_url=_endpoint,
config=self._config,
**kwargs)
self._serialize = Serializer()
self._deserialize = Deserializer()
self._serialize.client_side_validation = False
self.entity = EntityOperations(self._client, self._config,
self._serialize, self._deserialize)
self.glossary = GlossaryOperations(self._client, self._config,
self._serialize, self._deserialize)
self.discovery = DiscoveryOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.lineage = LineageOperations(self._client, self._config,
self._serialize, self._deserialize)
self.relationship = RelationshipOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.types = TypesOperations(self._client, self._config,
self._serialize, self._deserialize)
self.collection = CollectionOperations(self._client, self._config,
self._serialize,
self._deserialize)
def __init__(self, url: str, base_url: str = "", **kwargs: Any) -> None:
self._config = AzureBlobStorageConfiguration(url=url, **kwargs)
self._client = AsyncPipelineClient(base_url=base_url,
config=self._config,
**kwargs)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
self._serialize.client_side_validation = False
self.service = ServiceOperations(self._client, self._config,
self._serialize, self._deserialize)
self.container = ContainerOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.blob = BlobOperations(self._client, self._config, self._serialize,
self._deserialize)
self.page_blob = PageBlobOperations(self._client, self._config,
self._serialize, self._deserialize)
self.append_blob = AppendBlobOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.block_blob = BlockBlobOperations(self._client, self._config,
self._serialize,
self._deserialize)
def __init__(self, credential: "AsyncTokenCredential",
account_endpoint: str, instance_id: str,
**kwargs: Any) -> None:
base_url = 'https://{accountEndpoint}'
self._config = DeviceUpdateClientConfiguration(credential,
account_endpoint,
instance_id, **kwargs)
self._client = AsyncPipelineClient(base_url=base_url,
config=self._config,
**kwargs)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer(client_models)
self._serialize.client_side_validation = False
self._deserialize = Deserializer(client_models)
self.updates = UpdatesOperations(self._client, self._config,
self._serialize, self._deserialize)
self.devices = DevicesOperations(self._client, self._config,
self._serialize, self._deserialize)
self.deployments = DeploymentsOperations(self._client, self._config,
self._serialize,
self._deserialize)
def __init__(self, endpoint: str, credential: "AsyncTokenCredential",
**kwargs: Any) -> None:
_endpoint = '{Endpoint}'
self._config = PurviewScanningClientConfiguration(
endpoint, credential, **kwargs)
self._client = AsyncPipelineClient(base_url=_endpoint,
config=self._config,
**kwargs)
self._serialize = Serializer()
self._deserialize = Deserializer()
self._serialize.client_side_validation = False
self.key_vault_connections = KeyVaultConnectionsOperations(
self._client, self._config, self._serialize, self._deserialize)
self.classification_rules = ClassificationRulesOperations(
self._client, self._config, self._serialize, self._deserialize)
self.data_sources = DataSourcesOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.filters = FiltersOperations(self._client, self._config,
self._serialize, self._deserialize)
self.scans = ScansOperations(self._client, self._config,
self._serialize, self._deserialize)
self.scan_result = ScanResultOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.scan_rulesets = ScanRulesetsOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.system_scan_rulesets = SystemScanRulesetsOperations(
self._client, self._config, self._serialize, self._deserialize)
self.triggers = TriggersOperations(self._client, self._config,
self._serialize, self._deserialize)
def __init__(self,
credential: "TokenCredential",
synapse_dns_suffix: str = "dev.azuresynapse.net",
livy_api_version: str = "2019-11-01-preview",
**kwargs: Any) -> None:
base_url = 'https://{workspaceName}.{SynapseDnsSuffix}'
self._config = SynapseClientConfiguration(credential,
synapse_dns_suffix,
livy_api_version, **kwargs)
self._client = AsyncPipelineClient(base_url=base_url,
config=self._config,
**kwargs)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
self.monitoring = MonitoringOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.spark_batch = SparkBatchOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.spark_session = SparkSessionOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.workspace_acl = WorkspaceAclOperations(self._client, self._config,
self._serialize,
self._deserialize)
async def test_example_async_retry_policy():
url = "https://bing.com"
request = HttpRequest("GET", "https://bing.com")
policies = [
UserAgentPolicy("myuseragent"),
AsyncRedirectPolicy(),
]
# [START async_retry_policy]
from azure.core.pipeline.policies import AsyncRetryPolicy
retry_policy = AsyncRetryPolicy()
# Total number of retries to allow. Takes precedence over other counts.
# Default value is 10.
retry_policy.total_retries = 5
# How many connection-related errors to retry on.
# These are errors raised before the request is sent to the remote server,
# which we assume has not triggered the server to process the request. Default value is 3
retry_policy.connect_retries = 2
# How many times to retry on read errors.
# These errors are raised after the request was sent to the server, so the
# request may have side-effects. Default value is 3.
retry_policy.read_retries = 4
# How many times to retry on bad status codes. Default value is 3.
retry_policy.status_retries = 3
# A backoff factor to apply between attempts after the second try
# (most errors are resolved immediately by a second try without a delay).
# Retry policy will sleep for:
# {backoff factor} * (2 ** ({number of total retries} - 1))
# seconds. If the backoff_factor is 0.1, then the retry will sleep
# for [0.0s, 0.2s, 0.4s, ...] between retries.
# The default value is 0.8.
retry_policy.backoff_factor = 0.5
# The maximum back off time. Default value is 120 seconds (2 minutes).
retry_policy.backoff_max = 120
# Alternatively you can disable redirects entirely
retry_policy = AsyncRetryPolicy.no_retries()
# All of these settings can also be configured per operation.
policies.append(retry_policy)
async with AsyncPipelineClient(base_url=url, policies=policies) as client:
response = await client._pipeline.run(request,
retry_total=10,
retry_connect=1,
retry_read=1,
retry_status=5,
retry_backoff_factor=0.5,
retry_backoff_max=60,
retry_on_methods=['GET'])
# [END async_retry_policy]
assert client._pipeline._transport.session is None
assert response.http_response.status_code == 200
def __init__(self,
credential: "AsyncTokenCredential",
base_url: Optional[str] = None,
**kwargs: Any) -> None:
if not base_url:
base_url = 'https://digitaltwins-name.digitaltwins.azure.net'
self._config = AzureDigitalTwinsAPIConfiguration(credential, **kwargs)
self._client = AsyncPipelineClient(base_url=base_url,
config=self._config,
**kwargs)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
self.digital_twin_models = DigitalTwinModelsOperations(
self._client, self._config, self._serialize, self._deserialize)
self.query = QueryOperations(self._client, self._config,
self._serialize, self._deserialize)
self.digital_twins = DigitalTwinsOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.event_routes = EventRoutesOperations(self._client, self._config,
self._serialize,
self._deserialize)
def __init__(self,
url: str,
api_version: Optional[str] = "2021-07-01",
**kwargs: Any) -> None:
_base_url = '{url}'
self._config = ContainerRegistryConfiguration(url=url,
api_version=api_version,
**kwargs)
self._client = AsyncPipelineClient(base_url=_base_url,
config=self._config,
**kwargs)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
self._serialize.client_side_validation = False
self.container_registry = ContainerRegistryOperations(
self._client, self._config, self._serialize, self._deserialize)
self.container_registry_blob = ContainerRegistryBlobOperations(
self._client, self._config, self._serialize, self._deserialize)
self.authentication = AuthenticationOperations(self._client,
self._config,
self._serialize,
self._deserialize)
def __init__(self, url, **kwargs):
base_url = '{url}'
self._config = AzureQueueStorageConfiguration(url, **kwargs)
self._client = AsyncPipelineClient(base_url=base_url,
config=self._config,
**kwargs)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self.api_version = '2018-03-28'
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
self.service = ServiceOperations(self._client, self._config,
self._serialize, self._deserialize)
self.queue = QueueOperations(self._client, self._config,
self._serialize, self._deserialize)
self.messages = MessagesOperations(self._client, self._config,
self._serialize, self._deserialize)
self.message_id = MessageIdOperations(self._client, self._config,
self._serialize,
self._deserialize)
def __init__(self,
credential: "AsyncTokenCredential",
subscription_id: str,
resource_group_name: str,
workspace_name: str,
base_url: str = "https://quantum.azure.com",
**kwargs: Any) -> None:
self._config = QuantumClientConfiguration(
credential=credential,
subscription_id=subscription_id,
resource_group_name=resource_group_name,
workspace_name=workspace_name,
**kwargs)
self._client = AsyncPipelineClient(base_url=base_url,
config=self._config,
**kwargs)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
self._serialize.client_side_validation = False
self.jobs = JobsOperations(self._client, self._config, self._serialize,
self._deserialize)
self.providers = ProvidersOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.storage = StorageOperations(self._client, self._config,
self._serialize, self._deserialize)
self.quotas = QuotasOperations(self._client, self._config,
self._serialize, self._deserialize)
def __init__(self,
host: str = "https://management.azure.com",
base_url: Optional[str] = None,
**kwargs: Any) -> None:
if not base_url:
base_url = 'https://api.loganalytics.io/v1'
self._config = MonitorQueryClientConfiguration(host, **kwargs)
self._client = AsyncPipelineClient(base_url=base_url,
config=self._config,
**kwargs)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer(client_models)
self._serialize.client_side_validation = False
self._deserialize = Deserializer(client_models)
self.query = QueryOperations(self._client, self._config,
self._serialize, self._deserialize)
self.metadata = MetadataOperations(self._client, self._config,
self._serialize, self._deserialize)
self.metric_definitions = MetricDefinitionsOperations(
self._client, self._config, self._serialize, self._deserialize)
self.metric_namespaces = MetricNamespacesOperations(
self._client, self._config, self._serialize, self._deserialize)
self.metrics = MetricsOperations(self._client, self._config,
self._serialize, self._deserialize)
def __init__(self,
credential: "AsyncTokenCredential",
base_url: Optional[str] = None,
**kwargs: Any) -> None:
if not base_url:
base_url = 'https://management.azure.com'
self._config = AzureQuotaExtensionAPIConfiguration(
credential, **kwargs)
self._client = AsyncPipelineClient(base_url=base_url,
config=self._config,
**kwargs)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer(client_models)
self._serialize.client_side_validation = False
self._deserialize = Deserializer(client_models)
self.usages = usagesOperations(self._client, self._config,
self._serialize, self._deserialize)
self.quota = quotaOperations(self._client, self._config,
self._serialize, self._deserialize)
self.quotarequeststatus = quotarequeststatusOperations(
self._client, self._config, self._serialize, self._deserialize)
self.quotaoperation = quotaoperationOperations(self._client,
self._config,
self._serialize,
self._deserialize)
async def test_example_async_redirect_policy():
url = "https://bing.com"
request = HttpRequest("GET", url)
# [START async_redirect_policy]
from azure.core.pipeline.policies import AsyncRedirectPolicy
redirect_policy = AsyncRedirectPolicy()
# Client allows redirects. Defaults to True.
redirect_policy.allow = True
# The maximum allowed redirects. The default value is 30
redirect_policy.max_redirects = 10
# Alternatively you can disable redirects entirely
redirect_policy = AsyncRedirectPolicy.no_redirects()
# It can also be overridden per operation.
async with AsyncPipelineClient(base_url=url,
policies=[redirect_policy]) as client:
response = await client._pipeline.run(request,
permit_redirects=True,
redirect_max=5)
# [END async_redirect_policy]
assert client._pipeline._transport.session is None
assert response.http_response.status_code == 200
def __init__(
self, url, **kwargs):
base_url = '{url}'
self._config = AzureBlobStorageConfiguration(url, **kwargs)
self._client = AsyncPipelineClient(base_url=base_url, config=self._config, **kwargs)
client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
self.api_version = '2020-04-08'
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
self.service = ServiceOperations(
self._client, self._config, self._serialize, self._deserialize)
self.container = ContainerOperations(
self._client, self._config, self._serialize, self._deserialize)
self.directory = DirectoryOperations(
self._client, self._config, self._serialize, self._deserialize)
self.blob = BlobOperations(
self._client, self._config, self._serialize, self._deserialize)
self.page_blob = PageBlobOperations(
self._client, self._config, self._serialize, self._deserialize)
self.append_blob = AppendBlobOperations(
self._client, self._config, self._serialize, self._deserialize)
self.block_blob = BlockBlobOperations(
self._client, self._config, self._serialize, self._deserialize)
def __init__(self, url: str, **kwargs: Any) -> None:
base_url = '{url}'
self._config = ContainerRegistryConfiguration(url, **kwargs)
self._client = AsyncPipelineClient(base_url=base_url,
config=self._config,
**kwargs)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer(client_models)
self._serialize.client_side_validation = False
self._deserialize = Deserializer(client_models)
self.container_registry = ContainerRegistryOperations(
self._client, self._config, self._serialize, self._deserialize)
self.container_registry_repository = ContainerRegistryRepositoryOperations(
self._client, self._config, self._serialize, self._deserialize)
self.container_registry_blob = ContainerRegistryBlobOperations(
self._client, self._config, self._serialize, self._deserialize)
self.refresh_tokens = RefreshTokensOperations(self._client,
self._config,
self._serialize,
self._deserialize)
self.access_tokens = AccessTokensOperations(self._client, self._config,
self._serialize,
self._deserialize)
def __init__(self,
credential: "TokenCredential",
subscription_id: str,
acceptlanguage: Optional[str] = None,
base_url: Optional[str] = None,
**kwargs: Any) -> None:
if not base_url:
base_url = 'https://management.azure.com'
self._config = StorageImportExportConfiguration(
credential, subscription_id, acceptlanguage, **kwargs)
self._client = AsyncPipelineClient(base_url=base_url,
config=self._config,
**kwargs)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
self.location = LocationOperations(self._client, self._config,
self._serialize, self._deserialize)
self.job = JobOperations(self._client, self._config, self._serialize,
self._deserialize)
self.bit_locker_key = BitLockerKeyOperations(self._client,
self._config,
self._serialize,
self._deserialize)
self.operation = OperationOperations(self._client, self._config,
self._serialize,
self._deserialize)
def __init__(self, port, **kwargs):
self._config = TestRestClientConfiguration(**kwargs)
self._client = AsyncPipelineClient(
base_url="http://localhost:{}".format(port),
config=self._config,
**kwargs)
def __init__(
self,
base_url: Optional[str] = None,
**kwargs: Any
) -> None:
if not base_url:
base_url = 'http://localhost:3000'
self._config = AutoRestHttpInfrastructureTestServiceConfiguration(**kwargs)
self._client = AsyncPipelineClient(base_url=base_url, config=self._config, **kwargs)
client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
self.http_failure = HttpFailureOperations(
self._client, self._config, self._serialize, self._deserialize)
self.http_success = HttpSuccessOperations(
self._client, self._config, self._serialize, self._deserialize)
self.http_redirects = HttpRedirectsOperations(
self._client, self._config, self._serialize, self._deserialize)
self.http_client_failure = HttpClientFailureOperations(
self._client, self._config, self._serialize, self._deserialize)
self.http_server_failure = HttpServerFailureOperations(
self._client, self._config, self._serialize, self._deserialize)
self.http_retry = HttpRetryOperations(
self._client, self._config, self._serialize, self._deserialize)
self.multiple_responses = MultipleResponsesOperations(
self._client, self._config, self._serialize, self._deserialize)
def __init__(self, credential: "AsyncTokenCredential", instance_url: str,
**kwargs: Any) -> None:
base_url = '{instanceUrl}'
self._config = AzureAttestationRestClientConfiguration(
credential, instance_url, **kwargs)
self._client = AsyncPipelineClient(base_url=base_url,
config=self._config,
**kwargs)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer(client_models)
self._serialize.client_side_validation = False
self._deserialize = Deserializer(client_models)
self.policy = PolicyOperations(self._client, self._config,
self._serialize, self._deserialize)
self.policy_certificates = PolicyCertificatesOperations(
self._client, self._config, self._serialize, self._deserialize)
self.attestation = AttestationOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.signing_certificates = SigningCertificatesOperations(
self._client, self._config, self._serialize, self._deserialize)
self.metadata_configuration = MetadataConfigurationOperations(
self._client, self._config, self._serialize, self._deserialize)
def __init__(self,
credential: "AsyncTokenCredential",
endpoint: str,
spark_pool_name: str,
livy_api_version: str = "2019-11-01-preview",
**kwargs: Any) -> None:
base_url = '{endpoint}/livyApi/versions/{livyApiVersion}/sparkPools/{sparkPoolName}'
self._config = SparkClientConfiguration(credential, endpoint,
spark_pool_name,
livy_api_version, **kwargs)
self._client = AsyncPipelineClient(base_url=base_url,
config=self._config,
**kwargs)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer(client_models)
self._serialize.client_side_validation = False
self._deserialize = Deserializer(client_models)
self.spark_batch = SparkBatchOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.spark_session = SparkSessionOperations(self._client, self._config,
self._serialize,
self._deserialize)
def __init__(self,
credential: "TokenCredential",
subscription_id: str,
base_url: Optional[str] = None,
**kwargs: Any) -> None:
if not base_url:
base_url = 'https://management.azure.com'
self._config = ManagedNetworkManagementClientConfiguration(
credential, subscription_id, **kwargs)
self._client = AsyncPipelineClient(base_url=base_url,
config=self._config,
**kwargs)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
self.managed_network = ManagedNetworkOperations(
self._client, self._config, self._serialize, self._deserialize)
self.scope_assignment = ScopeAssignmentOperations(
self._client, self._config, self._serialize, self._deserialize)
self.managed_network_group = ManagedNetworkGroupOperations(
self._client, self._config, self._serialize, self._deserialize)
self.managed_network_peering_policy = ManagedNetworkPeeringPolicyOperations(
self._client, self._config, self._serialize, self._deserialize)
self.operation = OperationOperations(self._client, self._config,
self._serialize,
self._deserialize)
def __init__(self, credential: "AsyncTokenCredential", endpoint: str,
**kwargs: Any) -> None:
base_url = '{endpoint}'
self._config = ArtifactsClientConfiguration(credential, endpoint,
**kwargs)
self._client = AsyncPipelineClient(base_url=base_url,
config=self._config,
**kwargs)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer(client_models)
self._serialize.client_side_validation = False
self._deserialize = Deserializer(client_models)
self.linked_service = LinkedServiceOperations(self._client,
self._config,
self._serialize,
self._deserialize)
self.dataset = DatasetOperations(self._client, self._config,
self._serialize, self._deserialize)
self.pipeline = PipelineOperations(self._client, self._config,
self._serialize, self._deserialize)
self.pipeline_run = PipelineRunOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.trigger = TriggerOperations(self._client, self._config,
self._serialize, self._deserialize)
self.trigger_run = TriggerRunOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.data_flow = DataFlowOperations(self._client, self._config,
self._serialize, self._deserialize)
self.data_flow_debug_session = DataFlowDebugSessionOperations(
self._client, self._config, self._serialize, self._deserialize)
self.sql_script = SqlScriptOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.spark_job_definition = SparkJobDefinitionOperations(
self._client, self._config, self._serialize, self._deserialize)
self.notebook = NotebookOperations(self._client, self._config,
self._serialize, self._deserialize)
self.workspace = WorkspaceOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.sql_pools = SqlPoolsOperations(self._client, self._config,
self._serialize, self._deserialize)
self.big_data_pools = BigDataPoolsOperations(self._client,
self._config,
self._serialize,
self._deserialize)
self.integration_runtimes = IntegrationRuntimesOperations(
self._client, self._config, self._serialize, self._deserialize)
self.library = LibraryOperations(self._client, self._config,
self._serialize, self._deserialize)
self.workspace_git_repo_management = WorkspaceGitRepoManagementOperations(
self._client, self._config, self._serialize, self._deserialize)
def __init__(self, hub: str, endpoint: str, credential: "AsyncTokenCredential", **kwargs: Any) -> None:
_endpoint = "{Endpoint}"
self._config = WebPubSubServiceClientConfiguration(hub=hub, endpoint=endpoint, credential=credential, **kwargs)
self._client = AsyncPipelineClient(base_url=_endpoint, config=self._config, **kwargs)
self._serialize = Serializer()
self._deserialize = Deserializer()
self._serialize.client_side_validation = False
def __init__(self, url, credential, **kwargs):
# type: (str, TokenCredential, Any) -> None
super().__init__(url, credential, **kwargs)
azure_config = _AzureConfigurationAsync(credential, **kwargs)
self._pipeline_client = AsyncPipelineClient(
base_url=url,
config=azure_config,
transport=azure_config.transport)
def __init__(self, endpoint: str, credential: AzureKeyCredential, **kwargs: Any) -> None:
_endpoint = "{Endpoint}/language"
self._config = QuestionAnsweringClientConfiguration(endpoint=endpoint, credential=credential, **kwargs)
self._client = AsyncPipelineClient(base_url=_endpoint, config=self._config, **kwargs)
client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
self._serialize.client_side_validation = False
def test_pass_in_http_logging_policy():
config = Configuration()
http_logging_policy = HttpLoggingPolicy()
http_logging_policy.allowed_header_names.update({"x-ms-added-header"})
config.http_logging_policy = http_logging_policy
pipeline_client = AsyncPipelineClient(base_url="test")
pipeline = pipeline_client._build_pipeline(config)
http_logging_policy = pipeline._impl_policies[-1]._policy
assert http_logging_policy.allowed_header_names == HttpLoggingPolicy.DEFAULT_HEADERS_WHITELIST.union(
{"x-ms-added-header"})
def test_polling_with_path_format_arguments():
method = AsyncARMPolling(
timeout=0,
path_format_arguments={"host": "host:3000", "accountName": "local"}
)
client = AsyncPipelineClient(base_url="http://{accountName}{host}")
method._operation = LocationPolling()
method._operation._location_url = "/results/1"
method._client = client
assert "http://localhost:3000/results/1" == method._client.format_url(method._operation.get_polling_url(), **method._path_format_arguments)
def __init__(self, **kwargs: Any) -> None:
base_url = 'https://{topicHostname}'
self._config = EventGridPublisherClientConfiguration(**kwargs)
self._client = AsyncPipelineClient(base_url=base_url,
config=self._config,
**kwargs)
client_models = {} # type: Dict[str, Any]
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
self._serialize.client_side_validation = False
