class EventGridPublisherClient(EventGridPublisherClientOperationsMixin):
"""EventGrid Python Publisher Client.
:keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
"""
def __init__(
self,
**kwargs # type: Any
):
# type: (...) -> None
base_url = 'https://{topicHostname}'
self._config = EventGridPublisherClientConfiguration(**kwargs)
self._client = PipelineClient(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)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> EventGridPublisherClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class KeyVaultClient(KeyVaultClientOperationsMixin):
"""The key vault client performs cryptographic key operations and vault operations against the Key Vault service.
:param credentials: Credentials needed for the client to connect to Azure.
:type credentials: :mod:`A msrestazure Credentials
object<msrestazure.azure_active_directory>`
"""
def __init__(self, credentials, **kwargs):
base_url = '{vaultBaseUrl}'
self._config = KeyVaultClientConfiguration(credentials, **kwargs)
self._client = PipelineClient(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 = '7.1-preview'
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
def close(self):
self._client.close()
def __enter__(self):
self._client.__enter__()
return self
def __exit__(self, *exc_details):
self._client.__exit__(*exc_details)
class SparkClient(object):
"""SparkClient.
:ivar spark_batch: SparkBatchOperations operations
:vartype spark_batch: azure.synapse.spark.operations.SparkBatchOperations
:ivar spark_session: SparkSessionOperations operations
:vartype spark_session: azure.synapse.spark.operations.SparkSessionOperations
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials.TokenCredential
:param endpoint: The workspace development endpoint, for example https://myworkspace.dev.azuresynapse.net.
:type endpoint: str
:param spark_pool_name: Name of the spark pool.
:type spark_pool_name: str
:param livy_api_version: Valid api-version for the request.
:type livy_api_version: str
"""
def __init__(
self,
credential, # type: "TokenCredential"
endpoint, # type: str
spark_pool_name, # type: str
livy_api_version="2019-11-01-preview", # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{endpoint}/livyApi/versions/{livyApiVersion}/sparkPools/{sparkPoolName}'
self._config = SparkClientConfiguration(credential, endpoint,
spark_pool_name,
livy_api_version, **kwargs)
self._client = PipelineClient(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 close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> SparkClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class MediaTypesClient(MediaTypesClientOperationsMixin):
"""Play with produces/consumes and media-types in general.
:param str base_url: Service URL
:keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
"""
def __init__(
self,
base_url=None, # type: Optional[str]
**kwargs # type: Any
):
# type: (...) -> None
if not base_url:
base_url = 'http://localhost:3000'
self._config = MediaTypesClientConfiguration(**kwargs)
self._client = PipelineClient(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)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> MediaTypesClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class KeyVaultClient(KeyVaultClientOperationsMixin):
"""The key vault client performs cryptographic key operations and vault operations against the Key Vault service.
"""
def __init__(
self,
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{vaultBaseUrl}'
self._config = KeyVaultClientConfiguration(**kwargs)
self._client = PipelineClient(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)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> KeyVaultClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class EventGridPublisherClient(EventGridPublisherClientOperationsMixin):
"""EventGrid Python Publisher Client.
"""
def __init__(
self,
**kwargs # type: Any
):
# type: (...) -> None
base_url = 'https://{topicHostname}'
self._config = EventGridPublisherClientConfiguration(**kwargs)
self._client = PipelineClient(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)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> EventGridPublisherClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class ObjectTypeClient(ObjectTypeClientOperationsMixin):
"""Service client for testing basic type: object swaggers.
:param str base_url: Service URL
:keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
"""
def __init__(
self,
base_url=None, # type: Optional[str]
**kwargs # type: Any
):
# type: (...) -> None
if not base_url:
base_url = 'http://localhost:3000'
self._config = ObjectTypeClientConfiguration(**kwargs)
self._client = PipelineClient(base_url=base_url,
config=self._config,
**kwargs)
client_models = {}
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> ObjectTypeClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class AzureDigitalTwinsAPI(object):
"""A service for managing and querying digital twins and digital twin models.
:ivar digital_twin_models: DigitalTwinModelsOperations operations
:vartype digital_twin_models: azure.digitaltwins.core.operations.DigitalTwinModelsOperations
:ivar query: QueryOperations operations
:vartype query: azure.digitaltwins.core.operations.QueryOperations
:ivar digital_twins: DigitalTwinsOperations operations
:vartype digital_twins: azure.digitaltwins.core.operations.DigitalTwinsOperations
:ivar event_routes: EventRoutesOperations operations
:vartype event_routes: azure.digitaltwins.core.operations.EventRoutesOperations
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials.TokenCredential
:param str base_url: Service URL
:keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
"""
def __init__(
self,
credential, # type: "TokenCredential"
base_url=None, # type: Optional[str]
**kwargs # type: Any
):
# type: (...) -> None
if not base_url:
base_url = 'https://digitaltwins-name.digitaltwins.azure.net'
self._config = AzureDigitalTwinsAPIConfiguration(credential, **kwargs)
self._client = PipelineClient(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 close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> AzureDigitalTwinsAPI
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class TextAnalyticsClient(TextAnalyticsClientOperationsMixin):
"""The Text Analytics API is a suite of text analytics web services built with best-in-class Microsoft machine learning algorithms. The API can be used to analyze unstructured text for tasks such as sentiment analysis, key phrase extraction and language detection. No training data is needed to use this API; just bring your text data. This API uses advanced natural language processing techniques to deliver best in class predictions. Further documentation can be found in https://docs.microsoft.com/en-us/azure/cognitive-services/text-analytics/overview
:param credentials: Credentials needed for the client to connect to Azure.
:type credentials: :mod:`A msrestazure Credentials
object<msrestazure.azure_active_directory>`
:param endpoint: Supported Cognitive Services endpoints (protocol and
hostname, for example: https://westus.api.cognitive.microsoft.com).
:type endpoint: str
"""
def __init__(
self, credentials, endpoint, **kwargs):
base_url = '{Endpoint}/text/analytics/v3.0-preview.1'
self._config = TextAnalyticsClientConfiguration(credentials, endpoint, **kwargs)
self._client = PipelineClient(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 = 'v3.0-preview.1'
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
def close(self):
self._client.close()
def __enter__(self):
self._client.__enter__()
return self
def __exit__(self, *exc_details):
self._client.__exit__(*exc_details)
class LayersManager(object):
"""Layers Manager server.
:ivar layers: LayersOperations operations
:vartype layers: layers_manager.operations.LayersOperations
:param str base_url: Service URL
"""
def __init__(
self,
base_url=None, # type: Optional[str]
**kwargs # type: Any
):
# type: (...) -> None
if not base_url:
base_url = 'http://localhost:3000/api/v1'
self._config = LayersManagerConfiguration(**kwargs)
self._client = PipelineClient(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.layers = LayersOperations(self._client, self._config,
self._serialize, self._deserialize)
def _send_request(self, http_request, **kwargs):
# type: (HttpRequest, Any) -> HttpResponse
"""Runs the network request through the client's chained policies.
:param http_request: The network request you want to make. Required.
:type http_request: ~azure.core.pipeline.transport.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to True.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.pipeline.transport.HttpResponse
"""
http_request.url = self._client.format_url(http_request.url)
stream = kwargs.pop("stream", True)
pipeline_response = self._client._pipeline.run(http_request,
stream=stream,
**kwargs)
return pipeline_response.http_response
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> LayersManager
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class ManagedPrivateEndpointsClient(object):
"""ManagedPrivateEndpointsClient.
:ivar managed_private_endpoints: ManagedPrivateEndpointsOperations operations
:vartype managed_private_endpoints: azure.synapse.managedprivateendpoints.operations.ManagedPrivateEndpointsOperations
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials.TokenCredential
:param endpoint: The workspace development endpoint, for example https://myworkspace.dev.azuresynapse.net.
:type endpoint: str
"""
def __init__(
self,
credential, # type: "TokenCredential"
endpoint, # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{endpoint}'
self._config = ManagedPrivateEndpointsClientConfiguration(credential, endpoint, **kwargs)
self._client = PipelineClient(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.managed_private_endpoints = ManagedPrivateEndpointsOperations(
self._client, self._config, self._serialize, self._deserialize)
def _send_request(self, http_request, **kwargs):
# type: (HttpRequest, Any) -> HttpResponse
"""Runs the network request through the client's chained policies.
:param http_request: The network request you want to make. Required.
:type http_request: ~azure.core.pipeline.transport.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to True.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.pipeline.transport.HttpResponse
"""
path_format_arguments = {
'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True),
}
http_request.url = self._client.format_url(http_request.url, **path_format_arguments)
stream = kwargs.pop("stream", True)
pipeline_response = self._client._pipeline.run(http_request, stream=stream, **kwargs)
return pipeline_response.http_response
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> ManagedPrivateEndpointsClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class StorageImportExport(object):
"""The Storage Import/Export Resource Provider API.
:ivar location: LocationOperations operations
:vartype location: storage_import_export.operations.LocationOperations
:ivar job: JobOperations operations
:vartype job: storage_import_export.operations.JobOperations
:ivar bit_locker_key: BitLockerKeyOperations operations
:vartype bit_locker_key: storage_import_export.operations.BitLockerKeyOperations
:ivar operation: OperationOperations operations
:vartype operation: storage_import_export.operations.OperationOperations
:param credential: Credential needed for the client to connect to Azure.
:type credential: azure.core.credentials.TokenCredential
:param subscription_id: The subscription ID for the Azure user.
:type subscription_id: str
:param acceptlanguage: Specifies the preferred language for the response.
:type acceptlanguage: str
:param str base_url: Service URL
"""
def __init__(
self,
credential, # type: "TokenCredential"
subscription_id, # type: str
acceptlanguage=None, # type: Optional[str]
base_url=None, # type: Optional[str]
**kwargs # type: Any
):
# type: (...) -> None
if not base_url:
base_url = 'https://management.azure.com'
self._config = StorageImportExportConfiguration(credential, subscription_id, acceptlanguage, **kwargs)
self._client = PipelineClient(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 close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> StorageImportExport
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class AutoRestUrlTestService(object):
"""Test Infrastructure for AutoRest.
:ivar paths: PathsOperations operations
:vartype paths: url.operations.PathsOperations
:ivar queries: QueriesOperations operations
:vartype queries: url.operations.QueriesOperations
:ivar path_items: PathItemsOperations operations
:vartype path_items: url.operations.PathItemsOperations
:param global_string_path: A string value 'globalItemStringPath' that appears in the path.
:type global_string_path: str
:param global_string_query: should contain value null.
:type global_string_query: str
:param str base_url: Service URL
:keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
"""
def __init__(
self,
global_string_path, # type: str
global_string_query=None, # type: Optional[str]
base_url=None, # type: Optional[str]
**kwargs # type: Any
):
# type: (...) -> None
if not base_url:
base_url = 'http://localhost:3000'
self._config = AutoRestUrlTestServiceConfiguration(
global_string_path, global_string_query, **kwargs)
self._client = PipelineClient(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.paths = PathsOperations(self._client, self._config,
self._serialize, self._deserialize)
self.queries = QueriesOperations(self._client, self._config,
self._serialize, self._deserialize)
self.path_items = PathItemsOperations(self._client, self._config,
self._serialize,
self._deserialize)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> AutoRestUrlTestService
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class AzureAppConfiguration(AzureAppConfigurationOperationsMixin):
"""AzureAppConfiguration.
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials.TokenCredential
:param endpoint: The endpoint of the App Configuration instance to send requests to.
:type endpoint: str
:param sync_token: Used to guarantee real-time consistency between requests.
:type sync_token: str
"""
def __init__(
self,
credential, # type: "TokenCredential"
endpoint, # type: str
sync_token=None, # type: Optional[str]
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{endpoint}'
self._config = AzureAppConfigurationConfiguration(credential, endpoint, sync_token, **kwargs)
self._client = PipelineClient(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)
def _send_request(self, http_request, **kwargs):
# type: (HttpRequest, Any) -> HttpResponse
"""Runs the network request through the client's chained policies.
:param http_request: The network request you want to make. Required.
:type http_request: ~azure.core.pipeline.transport.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to True.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.pipeline.transport.HttpResponse
"""
path_format_arguments = {
'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True),
}
http_request.url = self._client.format_url(http_request.url, **path_format_arguments)
stream = kwargs.pop("stream", True)
pipeline_response = self._client._pipeline.run(http_request, stream=stream, **kwargs)
return pipeline_response.http_response
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> AzureAppConfiguration
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class AutoRestRequiredOptionalTestService(object):
"""Test Infrastructure for AutoRest.
:ivar implicit: ImplicitOperations operations
:vartype implicit: requiredoptional.operations.ImplicitOperations
:ivar explicit: ExplicitOperations operations
:vartype explicit: requiredoptional.operations.ExplicitOperations
:param required_global_path: number of items to skip.
:type required_global_path: str
:param required_global_query: number of items to skip.
:type required_global_query: str
:param optional_global_query: number of items to skip.
:type optional_global_query: int
:param str base_url: Service URL
:keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
"""
def __init__(
self,
required_global_path, # type: str
required_global_query, # type: str
optional_global_query=None, # type: Optional[int]
base_url=None, # type: Optional[str]
**kwargs # type: Any
):
# type: (...) -> None
if not base_url:
base_url = 'http://localhost:3000'
self._config = AutoRestRequiredOptionalTestServiceConfiguration(
required_global_path, required_global_query, optional_global_query,
**kwargs)
self._client = PipelineClient(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.implicit = ImplicitOperations(self._client, self._config,
self._serialize, self._deserialize)
self.explicit = ExplicitOperations(self._client, self._config,
self._serialize, self._deserialize)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> AutoRestRequiredOptionalTestService
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class FormRecognizerClient(FormRecognizerClientOperationsMixin):
"""Extracts content, layout, and structured data from documents.
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials.TokenCredential
:param endpoint: Supported Cognitive Services endpoints (protocol and hostname, for
example: https://westus2.api.cognitive.microsoft.com).
:type endpoint: str
:keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
"""
def __init__(
self,
credential, # type: "TokenCredential"
endpoint, # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{endpoint}/formrecognizer'
self._config = FormRecognizerClientConfiguration(credential, endpoint, **kwargs)
self._client = PipelineClient(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)
def _send_request(self, http_request, **kwargs):
# type: (HttpRequest, Any) -> HttpResponse
"""Runs the network request through the client's chained policies.
:param http_request: The network request you want to make. Required.
:type http_request: ~azure.core.pipeline.transport.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to True.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.pipeline.transport.HttpResponse
"""
path_format_arguments = {
'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True),
}
http_request.url = self._client.format_url(http_request.url, **path_format_arguments)
stream = kwargs.pop("stream", True)
pipeline_response = self._client._pipeline.run(http_request, stream=stream, **kwargs)
return pipeline_response.http_response
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> FormRecognizerClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class PhoneNumbersClient(object):
"""The phone numbers client uses Azure Communication Services to purchase and manage phone numbers.
:ivar phone_numbers: PhoneNumbersOperations operations
:vartype phone_numbers: azure.communication.phonenumbers.operations.PhoneNumbersOperations
:param endpoint: The communication resource, for example https://resourcename.communication.azure.com.
:type endpoint: str
:keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
"""
def __init__(
self,
endpoint, # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{endpoint}'
self._config = PhoneNumbersClientConfiguration(endpoint, **kwargs)
self._client = PipelineClient(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.phone_numbers = PhoneNumbersOperations(
self._client, self._config, self._serialize, self._deserialize)
def _send_request(self, http_request, **kwargs):
# type: (HttpRequest, Any) -> HttpResponse
"""Runs the network request through the client's chained policies.
:param http_request: The network request you want to make. Required.
:type http_request: ~azure.core.pipeline.transport.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to True.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.pipeline.transport.HttpResponse
"""
path_format_arguments = {
'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True),
}
http_request.url = self._client.format_url(http_request.url, **path_format_arguments)
stream = kwargs.pop("stream", True)
pipeline_response = self._client._pipeline.run(http_request, stream=stream, **kwargs)
return pipeline_response.http_response
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> PhoneNumbersClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class CommunicationNetworkTraversalClient(object):
"""Azure Communication Networking Service.
:ivar communication_network_traversal: CommunicationNetworkTraversalOperations operations
:vartype communication_network_traversal: azure.communication.networktraversal.operations.CommunicationNetworkTraversalOperations
:param endpoint: The communication resource, for example https://my-resource.communication.azure.com.
:type endpoint: str
"""
def __init__(
self,
endpoint, # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{endpoint}'
self._config = CommunicationNetworkTraversalClientConfiguration(endpoint, **kwargs)
self._client = PipelineClient(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.communication_network_traversal = CommunicationNetworkTraversalOperations(
self._client, self._config, self._serialize, self._deserialize)
def _send_request(self, http_request, **kwargs):
# type: (HttpRequest, Any) -> HttpResponse
"""Runs the network request through the client's chained policies.
:param http_request: The network request you want to make. Required.
:type http_request: ~azure.core.pipeline.transport.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to True.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.pipeline.transport.HttpResponse
"""
path_format_arguments = {
'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True),
}
http_request.url = self._client.format_url(http_request.url, **path_format_arguments)
stream = kwargs.pop("stream", True)
pipeline_response = self._client._pipeline.run(http_request, stream=stream, **kwargs)
return pipeline_response.http_response
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> CommunicationNetworkTraversalClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class AzureBlobStorage(object):
"""AzureBlobStorage
:ivar service: Service operations
:vartype service: azure.storage.blob.operations.ServiceOperations
:ivar container: Container operations
:vartype container: azure.storage.blob.operations.ContainerOperations
:ivar directory: Directory operations
:vartype directory: azure.storage.blob.operations.DirectoryOperations
:ivar blob: Blob operations
:vartype blob: azure.storage.blob.operations.BlobOperations
:ivar page_blob: PageBlob operations
:vartype page_blob: azure.storage.blob.operations.PageBlobOperations
:ivar append_blob: AppendBlob operations
:vartype append_blob: azure.storage.blob.operations.AppendBlobOperations
:ivar block_blob: BlockBlob operations
:vartype block_blob: azure.storage.blob.operations.BlockBlobOperations
:param url: The URL of the service account, container, or blob that is the
targe of the desired operation.
:type url: str
"""
def __init__(self, url, **kwargs):
base_url = '{url}'
self._config = AzureBlobStorageConfiguration(url, **kwargs)
self._client = PipelineClient(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-12-12'
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 close(self):
self._client.close()
def __enter__(self):
self._client.__enter__()
return self
def __exit__(self, *exc_details):
self._client.__exit__(*exc_details)
class AzureFileStorage(object):
"""AzureFileStorage.
:ivar service: ServiceOperations operations
:vartype service: azure.storage.fileshare.operations.ServiceOperations
:ivar share: ShareOperations operations
:vartype share: azure.storage.fileshare.operations.ShareOperations
:ivar directory: DirectoryOperations operations
:vartype directory: azure.storage.fileshare.operations.DirectoryOperations
:ivar file: FileOperations operations
:vartype file: azure.storage.fileshare.operations.FileOperations
:param url: The URL of the service account, share, directory or file that is the target of the desired operation.
:type url: str
"""
def __init__(
self,
url, # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{url}'
self._config = AzureFileStorageConfiguration(url, **kwargs)
self._client = PipelineClient(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.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 close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> AzureFileStorage
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class SynapseClient(object):
"""
:ivar monitoring: MonitoringOperations operations
:vartype monitoring: azure.synapse.operations.MonitoringOperations
:ivar spark_batch: SparkBatchOperations operations
:vartype spark_batch: azure.synapse.operations.SparkBatchOperations
:ivar spark_session: SparkSessionOperations operations
:vartype spark_session: azure.synapse.operations.SparkSessionOperations
:ivar workspace_acl: WorkspaceAclOperations operations
:vartype workspace_acl: azure.synapse.operations.WorkspaceAclOperations
:param credential: Credential needed for the client to connect to Azure.
:type credential: azure.core.credentials.TokenCredential
:param synapse_dns_suffix: Gets the DNS suffix used as the base for all Synapse service requests.
:type synapse_dns_suffix: str
:param livy_api_version: Valid api-version for the request.
:type livy_api_version: str
"""
def __init__(
self,
credential, # type: "TokenCredential"
synapse_dns_suffix="dev.azuresynapse.net", # type: str
livy_api_version="2019-11-01-preview", # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = 'https://{workspaceName}.{SynapseDnsSuffix}'
self._config = SynapseClientConfiguration(credential, synapse_dns_suffix, livy_api_version, **kwargs)
self._client = PipelineClient(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)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> SynapseClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class MicrosoftAzureMetricsAdvisorRESTAPIOpenAPIV2(MicrosoftAzureMetricsAdvisorRESTAPIOpenAPIV2OperationsMixin):
"""Microsoft Azure Metrics Advisor REST API (OpenAPI v2).
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials.TokenCredential
:param endpoint: Supported Cognitive Services endpoints (protocol and hostname, for example: https://:code:`<resource-name>`.cognitiveservices.azure.com).
:type endpoint: str
"""
def __init__(
self,
credential, # type: "TokenCredential"
endpoint, # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{endpoint}/metricsadvisor/v1.0'
self._config = MicrosoftAzureMetricsAdvisorRESTAPIOpenAPIV2Configuration(credential, endpoint, **kwargs)
self._client = PipelineClient(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)
def _send_request(self, http_request, **kwargs):
# type: (HttpRequest, Any) -> HttpResponse
"""Runs the network request through the client's chained policies.
:param http_request: The network request you want to make. Required.
:type http_request: ~azure.core.pipeline.transport.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to True.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.pipeline.transport.HttpResponse
"""
path_format_arguments = {
'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True),
}
http_request.url = self._client.format_url(http_request.url, **path_format_arguments)
stream = kwargs.pop("stream", True)
pipeline_response = self._client._pipeline.run(http_request, stream=stream, **kwargs)
return pipeline_response.http_response
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> MicrosoftAzureMetricsAdvisorRESTAPIOpenAPIV2
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class Portal(object):
"""Allows creation and deletion of Azure Shared Dashboards.
:ivar operation: OperationOperations operations
:vartype operation: portal.operations.OperationOperations
:ivar dashboard: DashboardOperations operations
:vartype dashboard: portal.operations.DashboardOperations
:param credential: Credential needed for the client to connect to Azure.
:type credential: azure.core.credentials.TokenCredential
:param subscription_id: The Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000).
:type subscription_id: str
:param str base_url: Service URL
"""
def __init__(
self,
credential, # type: "TokenCredential"
subscription_id, # type: str
base_url=None, # type: Optional[str]
**kwargs # type: Any
):
# type: (...) -> None
if not base_url:
base_url = 'https://management.azure.com'
self._config = PortalConfiguration(credential, subscription_id,
**kwargs)
self._client = PipelineClient(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.operation = OperationOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.dashboard = DashboardOperations(self._client, self._config,
self._serialize,
self._deserialize)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> Portal
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class AzureFileStorage(object):
"""AzureFileStorage
:ivar service: Service operations
:vartype service: azure.storage.fileshare.operations.ServiceOperations
:ivar share: Share operations
:vartype share: azure.storage.fileshare.operations.ShareOperations
:ivar directory: Directory operations
:vartype directory: azure.storage.fileshare.operations.DirectoryOperations
:ivar file: File operations
:vartype file: azure.storage.fileshare.operations.FileOperations
:param version: Specifies the version of the operation to use for this
request.
:type version: str
:param url: The URL of the service account, share, directory or file that
is the target of the desired operation.
:type url: str
"""
def __init__(self, version, url, **kwargs):
base_url = '{url}'
self._config = AzureFileStorageConfiguration(version, url, **kwargs)
self._client = PipelineClient(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-02-10'
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 close(self):
self._client.close()
def __enter__(self):
self._client.__enter__()
return self
def __exit__(self, *exc_details):
self._client.__exit__(*exc_details)
class DataLakeStorageClient(object):
"""Azure Data Lake Storage provides storage for Hadoop and other big data workloads.
:ivar service: Service operations
:vartype service: azure.storage.filedatalake.operations.ServiceOperations
:ivar file_system: FileSystem operations
:vartype file_system: azure.storage.filedatalake.operations.FileSystemOperations
:ivar path: Path operations
:vartype path: azure.storage.filedatalake.operations.PathOperations
:param url: The URL of the service account, container, or blob that is the
targe of the desired operation.
:type url: str
:param file_system: The filesystem identifier.
:type file_system: str
:param path1: The file or directory path.
:type path1: str
"""
def __init__(self, url, file_system, path1, **kwargs):
base_url = '{url}'
self._config = DataLakeStorageClientConfiguration(
url, file_system, path1, **kwargs)
self._client = PipelineClient(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-12-12'
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
self.service = ServiceOperations(self._client, self._config,
self._serialize, self._deserialize)
self.file_system = FileSystemOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.path = PathOperations(self._client, self._config, self._serialize,
self._deserialize)
def close(self):
self._client.close()
def __enter__(self):
self._client.__enter__()
return self
def __exit__(self, *exc_details):
self._client.__exit__(*exc_details)
class AzureDataLakeStorageRESTAPI(object):
"""Azure Data Lake Storage provides storage for Hadoop and other big data workloads.
:ivar service: ServiceOperations operations
:vartype service: azure.storage.filedatalake.operations.ServiceOperations
:ivar file_system: FileSystemOperations operations
:vartype file_system: azure.storage.filedatalake.operations.FileSystemOperations
:ivar path: PathOperations operations
:vartype path: azure.storage.filedatalake.operations.PathOperations
:param url: The URL of the service account, container, or blob that is the targe of the desired operation.
:type url: str
"""
def __init__(
self,
url, # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{url}'
self._config = AzureDataLakeStorageRESTAPIConfiguration(url, **kwargs)
self._client = PipelineClient(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.service = ServiceOperations(self._client, self._config,
self._serialize, self._deserialize)
self.file_system = FileSystemOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.path = PathOperations(self._client, self._config, self._serialize,
self._deserialize)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> AzureDataLakeStorageRESTAPI
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class AzureQueueStorage(object):
"""AzureQueueStorage.
:ivar service: ServiceOperations operations
:vartype service: azure.storage.queue.operations.ServiceOperations
:ivar queue: QueueOperations operations
:vartype queue: azure.storage.queue.operations.QueueOperations
:ivar messages: MessagesOperations operations
:vartype messages: azure.storage.queue.operations.MessagesOperations
:ivar message_id: MessageIdOperations operations
:vartype message_id: azure.storage.queue.operations.MessageIdOperations
:param url: The URL of the service account, queue or message that is the targe of the desired operation.
:type url: str
"""
def __init__(
self,
url, # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{url}'
self._config = AzureQueueStorageConfiguration(url, **kwargs)
self._client = PipelineClient(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.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 close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> AzureQueueStorage
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class AccessControlClient(object):
"""AccessControlClient.
:ivar role_assignments: RoleAssignmentsOperations operations
:vartype role_assignments: azure.synapse.accesscontrol.operations.RoleAssignmentsOperations
:ivar role_definitions: RoleDefinitionsOperations operations
:vartype role_definitions: azure.synapse.accesscontrol.operations.RoleDefinitionsOperations
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials.TokenCredential
:param endpoint: The workspace development endpoint, for example https://myworkspace.dev.azuresynapse.net.
:type endpoint: str
"""
def __init__(
self,
credential, # type: "TokenCredential"
endpoint, # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{endpoint}'
self._config = AccessControlClientConfiguration(
credential, endpoint, **kwargs)
self._client = PipelineClient(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.role_assignments = RoleAssignmentsOperations(
self._client, self._config, self._serialize, self._deserialize)
self.role_definitions = RoleDefinitionsOperations(
self._client, self._config, self._serialize, self._deserialize)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> AccessControlClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class ServiceBusManagementClient(ServiceBusManagementClientOperationsMixin):
"""Azure Service Bus client for managing Queues, Topics, and Subscriptions.
:ivar entity: EntityOperations operations
:vartype entity: azure.servicebus.management._generated.operations.EntityOperations
:ivar subscription: SubscriptionOperations operations
:vartype subscription: azure.servicebus.management._generated.operations.SubscriptionOperations
:ivar rule: RuleOperations operations
:vartype rule: azure.servicebus.management._generated.operations.RuleOperations
:ivar namespace: NamespaceOperations operations
:vartype namespace: azure.servicebus.management._generated.operations.NamespaceOperations
:param endpoint: The Service Bus fully qualified domain name.
:type endpoint: str
:keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
"""
def __init__(
self,
endpoint, # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = 'https://{endpoint}'
self._config = ServiceBusManagementClientConfiguration(endpoint, **kwargs)
self._client = PipelineClient(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.entity = EntityOperations(
self._client, self._config, self._serialize, self._deserialize)
self.subscription = SubscriptionOperations(
self._client, self._config, self._serialize, self._deserialize)
self.rule = RuleOperations(
self._client, self._config, self._serialize, self._deserialize)
self.namespace = NamespaceOperations(
self._client, self._config, self._serialize, self._deserialize)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> ServiceBusManagementClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class AccessControlClient(object):
"""AccessControlClient.
:ivar access_control: AccessControlOperations operations
:vartype access_control: azure.synapse.accesscontrol.operations.AccessControlOperations
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials.TokenCredential
:param endpoint: The workspace development endpoint, for example https://myworkspace.dev.azuresynapse.net.
:type endpoint: str
:keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
"""
def __init__(
self,
credential, # type: "TokenCredential"
endpoint, # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{endpoint}'
self._config = AccessControlClientConfiguration(
credential, endpoint, **kwargs)
self._client = PipelineClient(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.access_control = AccessControlOperations(self._client,
self._config,
self._serialize,
self._deserialize)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> AccessControlClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
