class TestRestClient(object):
def __init__(self, port, **kwargs):
self._config = TestRestClientConfiguration(**kwargs)
self._client = PipelineClient(
base_url="http://localhost:{}/".format(port),
config=self._config,
**kwargs)
def send_request(self, request, **kwargs):
"""Runs the network request through the client's chained policies.
>>> from azure.core.rest import HttpRequest
>>> request = HttpRequest("GET", "http://localhost:3000/helloWorld")
<HttpRequest [GET], url: 'http://localhost:3000/helloWorld'>
>>> response = client.send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
request_copy.url = self._client.format_url(request_copy.url)
return self._client.send_request(request_copy, **kwargs)
class FormRecognizerClient(FormRecognizerClientOperationsMixin):
"""Extracts information from forms and images into structured data.
: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/v2.1'
self._config = FormRecognizerClientConfiguration(credential=credential,
endpoint=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._serialize.client_side_validation = False
def _send_request(
self,
request, # type: HttpRequest
**kwargs # type: Any
):
# type: (...) -> HttpResponse
"""Runs the network request through the client's chained policies.
>>> from azure.core.rest import HttpRequest
>>> request = HttpRequest("GET", "https://www.example.org/")
<HttpRequest [GET], url: 'https://www.example.org/'>
>>> response = client._send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
path_format_arguments = {
"endpoint":
self._serialize.url("self._config.endpoint",
self._config.endpoint,
'str',
skip_quote=True),
}
request_copy.url = self._client.format_url(request_copy.url,
**path_format_arguments)
return self._client.send_request(request_copy, **kwargs)
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 TextAnalyticsClient(TextAnalyticsClientOperationsMixin):
"""The Text Analytics API is a suite of natural language processing (NLP) 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. Functionality for analysis of text specific to the healthcare domain and personal information are also available in the API. Further documentation can be found in :code:`<a href="https://docs.microsoft.com/en-us/azure/cognitive-services/text-analytics/overview">https://docs.microsoft.com/en-us/azure/cognitive-services/text-analytics/overview</a>`.
: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://westus.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}/text/analytics/v3.2-preview.2'
self._config = TextAnalyticsClientConfiguration(
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._serialize.client_side_validation = False
def _send_request(
self,
request, # type: HttpRequest
**kwargs # type: Any
):
# type: (...) -> HttpResponse
"""Runs the network request through the client's chained policies.
>>> from azure.core.rest import HttpRequest
>>> request = HttpRequest("GET", "https://www.example.org/")
<HttpRequest [GET], url: 'https://www.example.org/'>
>>> response = client._send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
path_format_arguments = {
"Endpoint":
self._serialize.url("self._config.endpoint",
self._config.endpoint,
'str',
skip_quote=True),
}
request_copy.url = self._client.format_url(request_copy.url,
**path_format_arguments)
return self._client.send_request(request_copy, **kwargs)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> TextAnalyticsClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class AnomalyDetectorClient(AnomalyDetectorClientOperationsMixin):
"""The Anomaly Detector API detects anomalies automatically in time series data. It supports two kinds of mode, one is for stateless using, another is for stateful using. In stateless mode, there are three functionalities. Entire Detect is for detecting the whole series with model trained by the time series, Last Detect is detecting last point with model trained by points before. ChangePoint Detect is for detecting trend changes in time series. In stateful mode, user can store time series, the stored time series will be used for detection anomalies. Under this mode, user can still use the above three functionalities by only giving a time range without preparing time series in client side. Besides the above three functionalities, stateful model also provide group based detection and labeling service. By leveraging labeling service user can provide labels for each detection result, these labels will be used for retuning or regenerating detection models. Inconsistency detection is a kind of group based detection, this detection will find inconsistency ones in a set of time series. By using anomaly detector service, business customers can discover incidents and establish a logic flow for root cause analysis.
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials.AzureKeyCredential
:param endpoint: Supported Cognitive Services endpoints (protocol and hostname, for example:
https://westus2.api.cognitive.microsoft.com).
:type endpoint: str
:keyword api_version: Anomaly Detector API version (for example, v1.0). The default value is
"v1.1-preview.1". Note that overriding this default value may result in unsupported behavior.
:paramtype api_version: str
"""
def __init__(
self,
credential, # type: AzureKeyCredential
endpoint, # type: str
**kwargs # type: Any
):
# type: (...) -> None
_base_url = '{Endpoint}/anomalydetector/{ApiVersion}'
self._config = AnomalyDetectorClientConfiguration(credential=credential, endpoint=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._serialize.client_side_validation = False
def _send_request(
self,
request, # type: HttpRequest
**kwargs # type: Any
):
# type: (...) -> HttpResponse
"""Runs the network request through the client's chained policies.
>>> from azure.core.rest import HttpRequest
>>> request = HttpRequest("GET", "https://www.example.org/")
<HttpRequest [GET], url: 'https://www.example.org/'>
>>> response = client._send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
path_format_arguments = {
"Endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True),
}
request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments)
return self._client.send_request(request_copy, **kwargs)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> AnomalyDetectorClient
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.
:keyword api_version: Api Version. The default value is "7.1". Note that overriding this
default value may result in unsupported behavior.
:paramtype api_version: str
"""
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)
self._serialize.client_side_validation = False
def _send_request(
self,
request, # type: HttpRequest
**kwargs # type: Any
):
# type: (...) -> HttpResponse
"""Runs the network request through the client's chained policies.
>>> from azure.core.rest import HttpRequest
>>> request = HttpRequest("GET", "https://www.example.org/")
<HttpRequest [GET], url: 'https://www.example.org/'>
>>> response = client._send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
request_copy.url = self._client.format_url(request_copy.url)
return self._client.send_request(request_copy, **kwargs)
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 AzureSchemaRegistry(object):
"""Azure Schema Registry is as a central schema repository, complete with support for versioning, management, compatibility checking, and RBAC.
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials.TokenCredential
:param endpoint: The Schema Registry service endpoint, for example
my-namespace.servicebus.windows.net.
:type endpoint: str
"""
def __init__(
self,
credential, # type: "TokenCredential"
endpoint, # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = 'https://{endpoint}'
self._config = AzureSchemaRegistryConfiguration(credential, endpoint, **kwargs)
self._client = PipelineClient(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
def send_request(
self,
request, # type: HttpRequest
**kwargs # type: Any
):
# type: (...) -> HttpResponse
"""Runs the network request through the client's chained policies.
We have helper methods to create requests specific to this service in `azure.schemaregistry._generated.rest`.
Use these helper methods to create the request you pass to this method.
>>> from azure.schemaregistry._generated.rest import schema
>>> request = schema.build_get_by_id_request(schema_id, **kwargs)
<HttpRequest [GET], url: '/$schemagroups/getSchemaById/{schema-id}'>
>>> response = client.send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
For advanced cases, you can also create your own :class:`~azure.core.rest.HttpRequest`
and pass it in.
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
path_format_arguments = {
'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True),
}
request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments)
return self._client.send_request(request_copy, **kwargs)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> AzureSchemaRegistry
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class TeamCloudClient(TeamCloudClientOperationsMixin):
"""API for working with a TeamCloud instance.
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials.TokenCredential
:param base_url: Service URL. Default value is ''.
:type base_url: str
"""
def __init__(
self,
credential, # type: "TokenCredential"
base_url="", # type: str
**kwargs # type: Any
):
# type: (...) -> None
self._config = TeamCloudClientConfiguration(credential=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._serialize.client_side_validation = False
def _send_request(
self,
request, # type: HttpRequest
**kwargs # type: Any
):
# type: (...) -> HttpResponse
"""Runs the network request through the client's chained policies.
>>> from azure.core.rest import HttpRequest
>>> request = HttpRequest("GET", "https://www.example.org/")
<HttpRequest [GET], url: 'https://www.example.org/'>
>>> response = client._send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
request_copy.url = self._client.format_url(request_copy.url)
return self._client.send_request(request_copy, **kwargs)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> TeamCloudClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
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 target of the
desired operation.
:type url: str
:param base_url: Service URL. Default value is "".
:type base_url: str
:keyword resource: The value must be "filesystem" for all filesystem operations. Default value
is "filesystem". Note that overriding this default value may result in unsupported behavior.
:paramtype resource: str
:keyword version: Specifies the version of the operation to use for this request. Default value
is "2020-10-02". Note that overriding this default value may result in unsupported behavior.
:paramtype version: str
"""
def __init__(
self,
url, # type: str
base_url="", # type: str
**kwargs # type: Any
):
# type: (...) -> None
self._config = AzureDataLakeStorageRESTAPIConfiguration(url=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._deserialize = Deserializer(client_models)
self._serialize.client_side_validation = False
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 _send_request(
self,
request, # type: HttpRequest
**kwargs # type: Any
):
# type: (...) -> HttpResponse
"""Runs the network request through the client's chained policies.
>>> from azure.core.rest import HttpRequest
>>> request = HttpRequest("GET", "https://www.example.org/")
<HttpRequest [GET], url: 'https://www.example.org/'>
>>> response = client._send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
request_copy.url = self._client.format_url(request_copy.url)
return self._client.send_request(request_copy, **kwargs)
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 ConversationAnalysisClient(ConversationAnalysisClientOperationsMixin):
"""This API accepts a request and mediates among multiple language projects, such as LUIS
Generally Available, Question Answering, Conversational Language Understanding, and then calls
the best candidate service to handle the request. At last, it returns a response with the
candidate service's response as a payload.
In some cases, this API needs to forward requests and responses between the caller and an
upstream service.
:param endpoint: Supported Cognitive Services endpoint (e.g.,
https://:code:`<resource-name>`.api.cognitiveservices.azure.com).
:type endpoint: str
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials.AzureKeyCredential
:keyword api_version: Api Version. Default value is "2022-03-01-preview". Note that overriding
this default value may result in unsupported behavior.
:paramtype api_version: str
"""
def __init__(self, endpoint: str, credential: AzureKeyCredential,
**kwargs: Any) -> None:
_endpoint = '{Endpoint}/language'
self._config = ConversationAnalysisClientConfiguration(
endpoint=endpoint, credential=credential, **kwargs)
self._client = PipelineClient(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 send_request(self, request: HttpRequest,
**kwargs: Any) -> HttpResponse:
"""Runs the network request through the client's chained policies.
>>> from azure.core.rest import HttpRequest
>>> request = HttpRequest("GET", "https://www.example.org/")
<HttpRequest [GET], url: 'https://www.example.org/'>
>>> response = client.send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
path_format_arguments = {
"Endpoint":
self._serialize.url("self._config.endpoint",
self._config.endpoint,
'str',
skip_quote=True),
}
request_copy.url = self._client.format_url(request_copy.url,
**path_format_arguments)
return self._client.send_request(request_copy, **kwargs)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> ConversationAnalysisClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class AzureMonitorClient(AzureMonitorClientOperationsMixin):
"""OpenTelemetry Exporter for Azure Monitor.
:param host: Breeze endpoint: https://dc.services.visualstudio.com. Default value is
"https://dc.services.visualstudio.com".
:type host: str
"""
def __init__(
self,
host="https://dc.services.visualstudio.com", # type: str
**kwargs # type: Any
):
# type: (...) -> None
_base_url = '{Host}/v2.1'
self._config = AzureMonitorClientConfiguration(host=host, **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._serialize.client_side_validation = False
def _send_request(
self,
request, # type: HttpRequest
**kwargs # type: Any
):
# type: (...) -> HttpResponse
"""Runs the network request through the client's chained policies.
>>> from azure.core.rest import HttpRequest
>>> request = HttpRequest("GET", "https://www.example.org/")
<HttpRequest [GET], url: 'https://www.example.org/'>
>>> response = client._send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
path_format_arguments = {
"Host":
self._serialize.url("self._config.host",
self._config.host,
'str',
skip_quote=True),
}
request_copy.url = self._client.format_url(request_copy.url,
**path_format_arguments)
return self._client.send_request(request_copy, **kwargs)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> AzureMonitorClient
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 target of the desired
operation.
:type url: str
:param base_url: Service URL. Default value is "".
:type base_url: str
:keyword version: Specifies the version of the operation to use for this request. Default value
is "2018-03-28". Note that overriding this default value may result in unsupported behavior.
:paramtype version: str
"""
def __init__(
self,
url, # type: str
base_url="", # type: str
**kwargs # type: Any
):
# type: (...) -> None
self._config = AzureQueueStorageConfiguration(url=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._deserialize = Deserializer(client_models)
self._serialize.client_side_validation = False
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 _send_request(
self,
request, # type: HttpRequest
**kwargs # type: Any
):
# type: (...) -> HttpResponse
"""Runs the network request through the client's chained policies.
>>> from azure.core.rest import HttpRequest
>>> request = HttpRequest("GET", "https://www.example.org/")
<HttpRequest [GET], url: 'https://www.example.org/'>
>>> response = client._send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
request_copy.url = self._client.format_url(request_copy.url)
return self._client.send_request(request_copy, **kwargs)
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 SearchClient(SearchClientOperationsMixin):
"""Client that can be used to manage and query indexes and documents, as well as manage other resources, on a search service.
:ivar data_sources: DataSourcesOperations operations
:vartype data_sources: azure.search.documents.indexes.operations.DataSourcesOperations
:ivar indexers: IndexersOperations operations
:vartype indexers: azure.search.documents.indexes.operations.IndexersOperations
:ivar skillsets: SkillsetsOperations operations
:vartype skillsets: azure.search.documents.indexes.operations.SkillsetsOperations
:ivar synonym_maps: SynonymMapsOperations operations
:vartype synonym_maps: azure.search.documents.indexes.operations.SynonymMapsOperations
:ivar indexes: IndexesOperations operations
:vartype indexes: azure.search.documents.indexes.operations.IndexesOperations
:param endpoint: The endpoint URL of the search service.
:type endpoint: str
:keyword api_version: Api Version. The default value is "2021-04-30-Preview". Note that
overriding this default value may result in unsupported behavior.
:paramtype api_version: str
"""
def __init__(
self,
endpoint, # type: str
**kwargs # type: Any
):
# type: (...) -> None
_base_url = '{endpoint}'
self._config = SearchClientConfiguration(endpoint=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._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 _send_request(
self,
request, # type: HttpRequest
**kwargs # type: Any
):
# type: (...) -> HttpResponse
"""Runs the network request through the client's chained policies.
>>> from azure.core.rest import HttpRequest
>>> request = HttpRequest("GET", "https://www.example.org/")
<HttpRequest [GET], url: 'https://www.example.org/'>
>>> response = client._send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
path_format_arguments = {
"endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True),
}
request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments)
return self._client.send_request(request_copy, **kwargs)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> SearchClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class PurviewScanningClient(object):
"""Creates a Microsoft.Scanning management client.
:ivar key_vault_connections: KeyVaultConnectionsOperations operations
:vartype key_vault_connections: azure.purview.scanning.operations.KeyVaultConnectionsOperations
:ivar classification_rules: ClassificationRulesOperations operations
:vartype classification_rules: azure.purview.scanning.operations.ClassificationRulesOperations
:ivar data_sources: DataSourcesOperations operations
:vartype data_sources: azure.purview.scanning.operations.DataSourcesOperations
:ivar filters: FiltersOperations operations
:vartype filters: azure.purview.scanning.operations.FiltersOperations
:ivar scans: ScansOperations operations
:vartype scans: azure.purview.scanning.operations.ScansOperations
:ivar scan_result: ScanResultOperations operations
:vartype scan_result: azure.purview.scanning.operations.ScanResultOperations
:ivar scan_rulesets: ScanRulesetsOperations operations
:vartype scan_rulesets: azure.purview.scanning.operations.ScanRulesetsOperations
:ivar system_scan_rulesets: SystemScanRulesetsOperations operations
:vartype system_scan_rulesets: azure.purview.scanning.operations.SystemScanRulesetsOperations
:ivar triggers: TriggersOperations operations
:vartype triggers: azure.purview.scanning.operations.TriggersOperations
:param endpoint: The scanning endpoint of your purview account. Example:
https://{accountName}.scan.purview.azure.com.
:type endpoint: str
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials.TokenCredential
"""
def __init__(
self,
endpoint, # type: str
credential, # type: "TokenCredential"
**kwargs # type: Any
):
# type: (...) -> None
_endpoint = '{Endpoint}'
self._config = PurviewScanningClientConfiguration(endpoint, credential, **kwargs)
self._client = PipelineClient(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 send_request(
self,
request, # type: HttpRequest
**kwargs # type: Any
):
# type: (...) -> HttpResponse
"""Runs the network request through the client's chained policies.
>>> from azure.core.rest import HttpRequest
>>> request = HttpRequest("GET", "https://www.example.org/")
<HttpRequest [GET], url: 'https://www.example.org/'>
>>> response = client.send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
path_format_arguments = {
"Endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True),
}
request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments)
return self._client.send_request(request_copy, **kwargs)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> PurviewScanningClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class EventGridPublisherClient(object):
"""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 = {} # type: Dict[str, Any]
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
self._serialize.client_side_validation = False
def send_request(
self,
request, # type: HttpRequest
**kwargs # type: Any
):
# type: (...) -> HttpResponse
"""Runs the network request through the client's chained policies.
We have helper methods to create requests specific to this service in `event_grid_publisher_client.rest`.
Use these helper methods to create the request you pass to this method.
>>> from event_grid_publisher_client.rest import build_publish_events_request
>>> request = build_publish_events_request(json=json, content=content, **kwargs)
<HttpRequest [POST], url: '/api/events'>
>>> response = client.send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
For advanced cases, you can also create your own :class:`~azure.core.rest.HttpRequest`
and pass it in.
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
request_copy.url = self._client.format_url(request_copy.url)
return self._client.send_request(request_copy, **kwargs)
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 WebPubSubServiceClient(WebPubSubServiceClientOperationsMixin):
"""WebPubSubServiceClient.
:param hub: Target hub name, which should start with alphabetic characters and only contain
alpha-numeric characters or underscore.
:type hub: str
:param endpoint: HTTP or HTTPS endpoint for the Web PubSub service instance.
:type endpoint: str
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials.TokenCredential
:keyword api_version: Api Version. The default value is "2021-10-01". Note that overriding this
default value may result in unsupported behavior.
:paramtype api_version: str
"""
def __init__(
self,
hub, # type: str
endpoint, # type: str
credential, # type: "TokenCredential"
**kwargs # type: Any
):
# type: (...) -> None
_endpoint = '{Endpoint}'
self._config = WebPubSubServiceClientConfiguration(
hub=hub, endpoint=endpoint, credential=credential, **kwargs)
self._client = PipelineClient(base_url=_endpoint,
config=self._config,
**kwargs)
self._serialize = Serializer()
self._deserialize = Deserializer()
self._serialize.client_side_validation = False
def send_request(
self,
request, # type: HttpRequest
**kwargs # type: Any
):
# type: (...) -> HttpResponse
"""Runs the network request through the client's chained policies.
>>> from azure.core.rest import HttpRequest
>>> request = HttpRequest("GET", "https://www.example.org/")
<HttpRequest [GET], url: 'https://www.example.org/'>
>>> response = client.send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
path_format_arguments = {
"Endpoint":
self._serialize.url("self._config.endpoint",
self._config.endpoint,
'str',
skip_quote=True),
}
request_copy.url = self._client.format_url(request_copy.url,
**path_format_arguments)
return self._client.send_request(request_copy, **kwargs)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> WebPubSubServiceClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class SearchClient(object):
"""Client that can be used to query an index and upload, merge, or delete documents.
:ivar documents: DocumentsOperations operations
:vartype documents: azure.search.documents.operations.DocumentsOperations
:param endpoint: The endpoint URL of the search service.
:type endpoint: str
:param index_name: The name of the index.
:type index_name: str
"""
def __init__(
self,
endpoint, # type: str
index_name, # type: str
**kwargs # type: Any
):
# type: (...) -> None
_base_url = '{endpoint}/indexes(\'{indexName}\')'
self._config = SearchClientConfiguration(endpoint, index_name, **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._serialize.client_side_validation = False
self.documents = DocumentsOperations(self._client, self._config, self._serialize, self._deserialize)
def _send_request(
self,
request, # type: HttpRequest
**kwargs # type: Any
):
# type: (...) -> HttpResponse
"""Runs the network request through the client's chained policies.
>>> from azure.core.rest import HttpRequest
>>> request = HttpRequest("GET", "https://www.example.org/")
<HttpRequest [GET], url: 'https://www.example.org/'>
>>> response = client._send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
path_format_arguments = {
"endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True),
"indexName": self._serialize.url("self._config.index_name", self._config.index_name, 'str'),
}
request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments)
return self._client.send_request(request_copy, **kwargs)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> SearchClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class QuantumClient(object):
"""Azure Quantum REST API client.
:ivar jobs: JobsOperations operations
:vartype jobs: azure.quantum._client.operations.JobsOperations
:ivar providers: ProvidersOperations operations
:vartype providers: azure.quantum._client.operations.ProvidersOperations
:ivar storage: StorageOperations operations
:vartype storage: azure.quantum._client.operations.StorageOperations
:ivar quotas: QuotasOperations operations
:vartype quotas: azure.quantum._client.operations.QuotasOperations
: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 resource_group_name: Name of an Azure resource group.
:type resource_group_name: str
:param workspace_name: Name of the workspace.
:type workspace_name: str
:param base_url: Service URL. Default value is "https://quantum.azure.com".
:type base_url: str
"""
def __init__(
self,
credential, # type: "TokenCredential"
subscription_id, # type: str
resource_group_name, # type: str
workspace_name, # type: str
base_url="https://quantum.azure.com", # type: str
**kwargs # type: Any
):
# type: (...) -> None
self._config = QuantumClientConfiguration(credential=credential, subscription_id=subscription_id, resource_group_name=resource_group_name, workspace_name=workspace_name, **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._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 _send_request(
self,
request, # type: HttpRequest
**kwargs # type: Any
):
# type: (...) -> HttpResponse
"""Runs the network request through the client's chained policies.
>>> from azure.core.rest import HttpRequest
>>> request = HttpRequest("GET", "https://www.example.org/")
<HttpRequest [GET], url: 'https://www.example.org/'>
>>> response = client._send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
request_copy.url = self._client.format_url(request_copy.url)
return self._client.send_request(request_copy, **kwargs)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> QuantumClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class ArtifactsClient:
"""ArtifactsClient.
:ivar kql_scripts: KqlScriptsOperations operations
:vartype kql_scripts: azure.synapse.artifacts.operations.KqlScriptsOperations
:ivar kql_script: KqlScriptOperations operations
:vartype kql_script: azure.synapse.artifacts.operations.KqlScriptOperations
:ivar metastore: MetastoreOperations operations
:vartype metastore: azure.synapse.artifacts.operations.MetastoreOperations
:ivar spark_configuration: SparkConfigurationOperations operations
:vartype spark_configuration: azure.synapse.artifacts.operations.SparkConfigurationOperations
:ivar big_data_pools: BigDataPoolsOperations operations
:vartype big_data_pools: azure.synapse.artifacts.operations.BigDataPoolsOperations
:ivar data_flow: DataFlowOperations operations
:vartype data_flow: azure.synapse.artifacts.operations.DataFlowOperations
:ivar data_flow_debug_session: DataFlowDebugSessionOperations operations
:vartype data_flow_debug_session:
azure.synapse.artifacts.operations.DataFlowDebugSessionOperations
:ivar dataset: DatasetOperations operations
:vartype dataset: azure.synapse.artifacts.operations.DatasetOperations
:ivar workspace_git_repo_management: WorkspaceGitRepoManagementOperations operations
:vartype workspace_git_repo_management:
azure.synapse.artifacts.operations.WorkspaceGitRepoManagementOperations
:ivar integration_runtimes: IntegrationRuntimesOperations operations
:vartype integration_runtimes: azure.synapse.artifacts.operations.IntegrationRuntimesOperations
:ivar library: LibraryOperations operations
:vartype library: azure.synapse.artifacts.operations.LibraryOperations
:ivar linked_service: LinkedServiceOperations operations
:vartype linked_service: azure.synapse.artifacts.operations.LinkedServiceOperations
:ivar notebook: NotebookOperations operations
:vartype notebook: azure.synapse.artifacts.operations.NotebookOperations
:ivar notebook_operation_result: NotebookOperationResultOperations operations
:vartype notebook_operation_result:
azure.synapse.artifacts.operations.NotebookOperationResultOperations
:ivar pipeline: PipelineOperations operations
:vartype pipeline: azure.synapse.artifacts.operations.PipelineOperations
:ivar pipeline_run: PipelineRunOperations operations
:vartype pipeline_run: azure.synapse.artifacts.operations.PipelineRunOperations
:ivar spark_job_definition: SparkJobDefinitionOperations operations
:vartype spark_job_definition: azure.synapse.artifacts.operations.SparkJobDefinitionOperations
:ivar sql_pools: SqlPoolsOperations operations
:vartype sql_pools: azure.synapse.artifacts.operations.SqlPoolsOperations
:ivar sql_script: SqlScriptOperations operations
:vartype sql_script: azure.synapse.artifacts.operations.SqlScriptOperations
:ivar trigger: TriggerOperations operations
:vartype trigger: azure.synapse.artifacts.operations.TriggerOperations
:ivar trigger_run: TriggerRunOperations operations
:vartype trigger_run: azure.synapse.artifacts.operations.TriggerRunOperations
:ivar workspace: WorkspaceOperations operations
:vartype workspace: azure.synapse.artifacts.operations.WorkspaceOperations
: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: "TokenCredential", endpoint: str,
**kwargs: Any) -> None:
_base_url = '{endpoint}'
self._config = ArtifactsClientConfiguration(credential=credential,
endpoint=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._serialize.client_side_validation = False
self.kql_scripts = KqlScriptsOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.kql_script = KqlScriptOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.metastore = MetastoreOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.spark_configuration = SparkConfigurationOperations(
self._client, self._config, self._serialize, self._deserialize)
self.big_data_pools = BigDataPoolsOperations(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.dataset = DatasetOperations(self._client, self._config,
self._serialize, self._deserialize)
self.workspace_git_repo_management = WorkspaceGitRepoManagementOperations(
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.linked_service = LinkedServiceOperations(self._client,
self._config,
self._serialize,
self._deserialize)
self.notebook = NotebookOperations(self._client, self._config,
self._serialize, self._deserialize)
self.notebook_operation_result = NotebookOperationResultOperations(
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.spark_job_definition = SparkJobDefinitionOperations(
self._client, self._config, self._serialize, self._deserialize)
self.sql_pools = SqlPoolsOperations(self._client, self._config,
self._serialize, self._deserialize)
self.sql_script = SqlScriptOperations(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.workspace = WorkspaceOperations(self._client, self._config,
self._serialize,
self._deserialize)
def _send_request(
self,
request, # type: HttpRequest
**kwargs: Any) -> HttpResponse:
"""Runs the network request through the client's chained policies.
>>> from azure.core.rest import HttpRequest
>>> request = HttpRequest("GET", "https://www.example.org/")
<HttpRequest [GET], url: 'https://www.example.org/'>
>>> response = client._send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
path_format_arguments = {
"endpoint":
self._serialize.url("self._config.endpoint",
self._config.endpoint,
'str',
skip_quote=True),
}
request_copy.url = self._client.format_url(request_copy.url,
**path_format_arguments)
return self._client.send_request(request_copy, **kwargs)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> ArtifactsClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class PurviewCatalogClient: # pylint: disable=too-many-instance-attributes
"""Purview Catalog Service is a fully managed cloud service whose users can discover the data
sources they need and understand the data sources they find. At the same time, Data Catalog
helps organizations get more value from their existing investments. This spec defines REST API
of Purview Catalog Service.
:ivar entity: EntityOperations operations
:vartype entity: azure.purview.catalog.operations.EntityOperations
:ivar glossary: GlossaryOperations operations
:vartype glossary: azure.purview.catalog.operations.GlossaryOperations
:ivar discovery: DiscoveryOperations operations
:vartype discovery: azure.purview.catalog.operations.DiscoveryOperations
:ivar lineage: LineageOperations operations
:vartype lineage: azure.purview.catalog.operations.LineageOperations
:ivar relationship: RelationshipOperations operations
:vartype relationship: azure.purview.catalog.operations.RelationshipOperations
:ivar types: TypesOperations operations
:vartype types: azure.purview.catalog.operations.TypesOperations
:ivar collection: CollectionOperations operations
:vartype collection: azure.purview.catalog.operations.CollectionOperations
:param endpoint: The catalog endpoint of your Purview account. Example:
https://{accountName}.purview.azure.com.
:type endpoint: str
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials.TokenCredential
:keyword api_version: Api Version. Default value is "2021-05-01-preview". Note that overriding
this default value may result in unsupported behavior.
:paramtype api_version: 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: str, credential: "TokenCredential",
**kwargs: Any) -> None:
_endpoint = '{Endpoint}/catalog/api'
self._config = PurviewCatalogClientConfiguration(endpoint=endpoint,
credential=credential,
**kwargs)
self._client = PipelineClient(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 send_request(self, request: HttpRequest,
**kwargs: Any) -> HttpResponse:
"""Runs the network request through the client's chained policies.
>>> from azure.core.rest import HttpRequest
>>> request = HttpRequest("GET", "https://www.example.org/")
<HttpRequest [GET], url: 'https://www.example.org/'>
>>> response = client.send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
path_format_arguments = {
"Endpoint":
self._serialize.url("self._config.endpoint",
self._config.endpoint,
'str',
skip_quote=True),
}
request_copy.url = self._client.format_url(request_copy.url,
**path_format_arguments)
return self._client.send_request(request_copy, **kwargs)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> PurviewCatalogClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class ContainerRegistry(object):
"""Metadata API definition for the Azure Container Registry runtime.
:ivar container_registry: ContainerRegistryOperations operations
:vartype container_registry: container_registry.operations.ContainerRegistryOperations
:ivar container_registry_blob: ContainerRegistryBlobOperations operations
:vartype container_registry_blob: container_registry.operations.ContainerRegistryBlobOperations
:ivar authentication: AuthenticationOperations operations
:vartype authentication: container_registry.operations.AuthenticationOperations
:param url: Registry login URL.
:type url: str
:param api_version: Api Version. The default value is "2021-07-01".
:type api_version: str
"""
def __init__(
self,
url, # type: str
api_version="2021-07-01", # type: Optional[str]
**kwargs # type: Any
):
# type: (...) -> None
_base_url = '{url}'
self._config = ContainerRegistryConfiguration(url=url, api_version=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._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 _send_request(
self,
request, # type: HttpRequest
**kwargs # type: Any
):
# type: (...) -> HttpResponse
"""Runs the network request through the client's chained policies.
>>> from azure.core.rest import HttpRequest
>>> request = HttpRequest("GET", "https://www.example.org/")
<HttpRequest [GET], url: 'https://www.example.org/'>
>>> response = client._send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
path_format_arguments = {
"url": self._serialize.url("self._config.url", self._config.url, 'str', skip_quote=True),
}
request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments)
return self._client.send_request(request_copy, **kwargs)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> ContainerRegistry
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class AzureSchemaRegistry(object):
"""Azure Schema Registry is as a central schema repository, with support for versioning, management, compatibility checking, and RBAC.
:param endpoint: The Schema Registry service endpoint, for example
my-namespace.servicebus.windows.net.
:type endpoint: str
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials.TokenCredential
:keyword api_version: Api Version. The default value is "2021-10". Note that overriding this
default value may result in unsupported behavior.
:paramtype api_version: str
"""
def __init__(
self,
endpoint, # type: str
credential, # type: "TokenCredential"
**kwargs # type: Any
):
# type: (...) -> None
_endpoint = 'https://{endpoint}'
self._config = AzureSchemaRegistryConfiguration(endpoint=endpoint,
credential=credential,
**kwargs)
self._client = PipelineClient(base_url=_endpoint,
config=self._config,
**kwargs)
self._serialize = Serializer()
self._deserialize = Deserializer()
self._serialize.client_side_validation = False
def send_request(
self,
request, # type: HttpRequest
**kwargs # type: Any
):
# type: (...) -> HttpResponse
"""Runs the network request through the client's chained policies.
We have helper methods to create requests specific to this service in `azure.schemaregistry._generated.rest`.
Use these helper methods to create the request you pass to this method.
>>> from azure.schemaregistry._generated.rest import schema_groups
>>> request = schema_groups.build_list_request(**kwargs)
<HttpRequest [GET], url: '/$schemaGroups'>
>>> response = client.send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
path_format_arguments = {
"endpoint":
self._serialize.url("self._config.endpoint",
self._config.endpoint,
'str',
skip_quote=True),
}
request_copy.url = self._client.format_url(request_copy.url,
**path_format_arguments)
return self._client.send_request(request_copy, **kwargs)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> AzureSchemaRegistry
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class QuestionAnsweringClient(QuestionAnsweringClientOperationsMixin):
"""The language service API is a suite of natural language processing (NLP) skills 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, language detection and question answering. Further documentation can be found in https://docs.microsoft.com/en-us/azure/cognitive-services/text-analytics/overview.
:param endpoint: Supported Cognitive Services endpoint (e.g.,
https://<resource-name>.api.cognitiveservices.azure.com).
:type endpoint: str
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials.AzureKeyCredential
"""
def __init__(
self,
endpoint, # type: str
credential, # type: AzureKeyCredential
**kwargs # type: Any
):
# type: (...) -> None
base_url = "{Endpoint}/language"
self._config = QuestionAnsweringClientConfiguration(
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._serialize.client_side_validation = False
def send_request(
self,
request, # type: HttpRequest
**kwargs # type: Any
):
# type: (...) -> HttpResponse
"""Runs the network request through the client's chained policies.
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
path_format_arguments = {
"Endpoint":
self._serialize.url("self._config.endpoint",
self._config.endpoint,
"str",
skip_quote=True),
}
request_copy.url = self._client.format_url(request_copy.url,
**path_format_arguments)
return self._client.send_request(request_copy, **kwargs)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> QuestionAnsweringClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class DeviceUpdateClient:
"""Device Update for IoT Hub is an Azure service that enables customers to publish update for their IoT devices to the cloud, and then deploy that update to their devices (approve updates to groups of devices managed and provisioned in IoT Hub). It leverages the proven security and reliability of the Windows Update platform, optimized for IoT devices. It works globally and knows when and how to update devices, enabling customers to focus on their business goals and let Device Update for IoT Hub handle the updates.
:ivar device_update: DeviceUpdateOperations operations
:vartype device_update: azure.iot.deviceupdate.operations.DeviceUpdateOperations
:ivar device_management: DeviceManagementOperations operations
:vartype device_management: azure.iot.deviceupdate.operations.DeviceManagementOperations
:param endpoint: Account endpoint.
:type endpoint: str
:param instance_id: Account instance identifier.
:type instance_id: str
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials.TokenCredential
:keyword api_version: Api Version. The default value is "2021-06-01-preview". Note that
overriding this default value may result in unsupported behavior.
:paramtype api_version: 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: str, instance_id: str,
credential: "TokenCredential", **kwargs: Any) -> None:
_endpoint = 'https://{endpoint}'
self._config = DeviceUpdateClientConfiguration(endpoint=endpoint,
instance_id=instance_id,
credential=credential,
**kwargs)
self._client = PipelineClient(base_url=_endpoint,
config=self._config,
**kwargs)
self._serialize = Serializer()
self._deserialize = Deserializer()
self._serialize.client_side_validation = False
self.device_update = DeviceUpdateOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.device_management = DeviceManagementOperations(
self._client, self._config, self._serialize, self._deserialize)
def send_request(
self,
request, # type: HttpRequest
**kwargs: Any) -> HttpResponse:
"""Runs the network request through the client's chained policies.
>>> from azure.core.rest import HttpRequest
>>> request = HttpRequest("GET", "https://www.example.org/")
<HttpRequest [GET], url: 'https://www.example.org/'>
>>> response = client.send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
path_format_arguments = {
"endpoint":
self._serialize.url("self._config.endpoint",
self._config.endpoint,
'str',
skip_quote=True),
}
request_copy.url = self._client.format_url(request_copy.url,
**path_format_arguments)
return self._client.send_request(request_copy, **kwargs)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> DeviceUpdateClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class CommunicationNetworkTraversalClient(object):
"""Azure Communication Network Traversal 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
:keyword api_version: Api Version. Default value is "2022-03-01-preview". Note that overriding
this default value may result in unsupported behavior.
:paramtype api_version: str
"""
def __init__(
self,
endpoint, # type: str
**kwargs # type: Any
):
# type: (...) -> None
_base_url = '{endpoint}'
self._config = CommunicationNetworkTraversalClientConfiguration(
endpoint=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._serialize.client_side_validation = False
self.communication_network_traversal = CommunicationNetworkTraversalOperations(
self._client, self._config, self._serialize, self._deserialize)
def _send_request(
self,
request, # type: HttpRequest
**kwargs # type: Any
):
# type: (...) -> HttpResponse
"""Runs the network request through the client's chained policies.
>>> from azure.core.rest import HttpRequest
>>> request = HttpRequest("GET", "https://www.example.org/")
<HttpRequest [GET], url: 'https://www.example.org/'>
>>> response = client._send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
path_format_arguments = {
"endpoint":
self._serialize.url("self._config.endpoint",
self._config.endpoint,
'str',
skip_quote=True),
}
request_copy.url = self._client.format_url(request_copy.url,
**path_format_arguments)
return self._client.send_request(request_copy, **kwargs)
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 PurviewAccountClient(object):
"""Creates a Microsoft.Purview data plane account client.
:ivar accounts: AccountsOperations operations
:vartype accounts: azure.purview.account.operations.AccountsOperations
:ivar collections: CollectionsOperations operations
:vartype collections: azure.purview.account.operations.CollectionsOperations
:ivar resource_set_rules: ResourceSetRulesOperations operations
:vartype resource_set_rules: azure.purview.account.operations.ResourceSetRulesOperations
:param endpoint: The account endpoint of your Purview account. Example:
https://{accountName}.purview.azure.com/account/.
:type endpoint: str
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials.TokenCredential
"""
def __init__(
self,
endpoint, # type: str
credential, # type: "TokenCredential"
**kwargs # type: Any
):
# type: (...) -> None
_endpoint = '{endpoint}'
self._config = PurviewAccountClientConfiguration(endpoint, credential, **kwargs)
self._client = PipelineClient(base_url=_endpoint, config=self._config, **kwargs)
self._serialize = Serializer()
self._deserialize = Deserializer()
self._serialize.client_side_validation = False
self.accounts = AccountsOperations(self._client, self._config, self._serialize, self._deserialize)
self.collections = CollectionsOperations(self._client, self._config, self._serialize, self._deserialize)
self.resource_set_rules = ResourceSetRulesOperations(self._client, self._config, self._serialize, self._deserialize)
def send_request(
self,
request, # type: HttpRequest
**kwargs # type: Any
):
# type: (...) -> HttpResponse
"""Runs the network request through the client's chained policies.
We have helper methods to create requests specific to this service in `azure.purview.account.rest`.
Use these helper methods to create the request you pass to this method.
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
For advanced cases, you can also create your own :class:`~azure.core.rest.HttpRequest`
and pass it in.
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
path_format_arguments = {
"endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True),
}
request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments)
return self._client.send_request(request_copy, **kwargs)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> PurviewAccountClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class QuestionAnsweringProjectsClient(QuestionAnsweringProjectsClientOperationsMixin):
"""The language service API is a suite of natural language processing (NLP) skills 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, language
detection and question answering. Further documentation can be found in :code:`<a
href="https://docs.microsoft.com/en-us/azure/cognitive-services/text-analytics/overview">https://docs.microsoft.com/en-us/azure/cognitive-services/text-analytics/overview</a>`.
:param endpoint: Supported Cognitive Services endpoint (e.g.,
https://:code:`<resource-name>`.api.cognitiveservices.azure.com).
:type endpoint: str
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials.AzureKeyCredential
:keyword api_version: Api Version. The default value is "2021-10-01". Note that overriding this
default value may result in unsupported behavior.
:paramtype api_version: 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
credential, # type: AzureKeyCredential
**kwargs # type: Any
):
# type: (...) -> None
_endpoint = '{Endpoint}/language'
self._config = QuestionAnsweringProjectsClientConfiguration(endpoint=endpoint, credential=credential, **kwargs)
self._client = PipelineClient(base_url=_endpoint, config=self._config, **kwargs)
self._serialize = Serializer()
self._deserialize = Deserializer()
self._serialize.client_side_validation = False
def send_request(
self,
request, # type: HttpRequest
**kwargs # type: Any
):
# type: (...) -> HttpResponse
"""Runs the network request through the client's chained policies.
>>> from azure.core.rest import HttpRequest
>>> request = HttpRequest("GET", "https://www.example.org/")
<HttpRequest [GET], url: 'https://www.example.org/'>
>>> response = client.send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
:param request: The network request you want to make. Required.
:type request: ~azure.core.rest.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.rest.HttpResponse
"""
request_copy = deepcopy(request)
path_format_arguments = {
"Endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True),
}
request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments)
return self._client.send_request(request_copy, **kwargs)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> QuestionAnsweringProjectsClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
