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. 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: str, endpoint: str, credential: "TokenCredential", **kwargs: Any) -> 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: 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: () -> WebPubSubServiceClient
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.
:ivar role_definitions: RoleDefinitionsOperations operations
:vartype role_definitions: azure.keyvault.v7_2.operations.RoleDefinitionsOperations
:ivar role_assignments: RoleAssignmentsOperations operations
:vartype role_assignments: azure.keyvault.v7_2.operations.RoleAssignmentsOperations
: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 = '{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._serialize.client_side_validation = False
self._deserialize = Deserializer(client_models)
self.role_definitions = RoleDefinitionsOperations(
self._client, self._config, self._serialize, self._deserialize)
self.role_assignments = RoleAssignmentsOperations(
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: () -> KeyVaultClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class MonitorQueryClient(object):
"""Azure Monitor Query Python Client.
:ivar query: QueryOperations operations
:vartype query: monitor_query_client.operations.QueryOperations
:ivar metadata: MetadataOperations operations
:vartype metadata: monitor_query_client.operations.MetadataOperations
:ivar metric_definitions: MetricDefinitionsOperations operations
:vartype metric_definitions: monitor_query_client.operations.MetricDefinitionsOperations
:ivar metric_namespaces: MetricNamespacesOperations operations
:vartype metric_namespaces: monitor_query_client.operations.MetricNamespacesOperations
:ivar metrics: MetricsOperations operations
:vartype metrics: monitor_query_client.operations.MetricsOperations
:param host: server parameter.
:type host: str
:param str base_url: Service URL
"""
def __init__(
self,
host="https://management.azure.com", # type: str
base_url=None, # type: Optional[str]
**kwargs # type: Any
):
# type: (...) -> None
if not base_url:
base_url = 'https://api.loganalytics.io/v1'
self._config = MonitorQueryClientConfiguration(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._serialize.client_side_validation = False
self._deserialize = Deserializer(client_models)
self.query = QueryOperations(self._client, self._config,
self._serialize, self._deserialize)
self.metadata = MetadataOperations(self._client, self._config,
self._serialize, self._deserialize)
self.metric_definitions = MetricDefinitionsOperations(
self._client, self._config, self._serialize, self._deserialize)
self.metric_namespaces = MetricNamespacesOperations(
self._client, self._config, self._serialize, self._deserialize)
self.metrics = MetricsOperations(self._client, self._config,
self._serialize, self._deserialize)
def _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: () -> MonitorQueryClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class ArtifactsClient(object):
"""ArtifactsClient.
:ivar linked_service: LinkedServiceOperations operations
:vartype linked_service: azure.synapse.artifacts.operations.LinkedServiceOperations
:ivar dataset: DatasetOperations operations
:vartype dataset: azure.synapse.artifacts.operations.DatasetOperations
: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 trigger: TriggerOperations operations
:vartype trigger: azure.synapse.artifacts.operations.TriggerOperations
:ivar trigger_run: TriggerRunOperations operations
:vartype trigger_run: azure.synapse.artifacts.operations.TriggerRunOperations
: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 sql_script: SqlScriptOperations operations
:vartype sql_script: azure.synapse.artifacts.operations.SqlScriptOperations
:ivar spark_job_definition: SparkJobDefinitionOperations operations
:vartype spark_job_definition: azure.synapse.artifacts.operations.SparkJobDefinitionOperations
:ivar notebook: NotebookOperations operations
:vartype notebook: azure.synapse.artifacts.operations.NotebookOperations
:ivar workspace: WorkspaceOperations operations
:vartype workspace: azure.synapse.artifacts.operations.WorkspaceOperations
:ivar sql_pools: SqlPoolsOperations operations
:vartype sql_pools: azure.synapse.artifacts.operations.SqlPoolsOperations
:ivar big_data_pools: BigDataPoolsOperations operations
:vartype big_data_pools: azure.synapse.artifacts.operations.BigDataPoolsOperations
:ivar integration_runtimes: IntegrationRuntimesOperations operations
:vartype integration_runtimes: azure.synapse.artifacts.operations.IntegrationRuntimesOperations
: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 = ArtifactsClientConfiguration(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.linked_service = LinkedServiceOperations(
self._client, self._config, self._serialize, self._deserialize)
self.dataset = DatasetOperations(
self._client, self._config, self._serialize, self._deserialize)
self.pipeline = PipelineOperations(
self._client, self._config, self._serialize, self._deserialize)
self.pipeline_run = PipelineRunOperations(
self._client, self._config, self._serialize, self._deserialize)
self.trigger = TriggerOperations(
self._client, self._config, self._serialize, self._deserialize)
self.trigger_run = TriggerRunOperations(
self._client, self._config, self._serialize, self._deserialize)
self.data_flow = DataFlowOperations(
self._client, self._config, self._serialize, self._deserialize)
self.data_flow_debug_session = DataFlowDebugSessionOperations(
self._client, self._config, self._serialize, self._deserialize)
self.sql_script = SqlScriptOperations(
self._client, self._config, self._serialize, self._deserialize)
self.spark_job_definition = SparkJobDefinitionOperations(
self._client, self._config, self._serialize, self._deserialize)
self.notebook = NotebookOperations(
self._client, self._config, self._serialize, self._deserialize)
self.workspace = WorkspaceOperations(
self._client, self._config, self._serialize, self._deserialize)
self.sql_pools = SqlPoolsOperations(
self._client, self._config, self._serialize, self._deserialize)
self.big_data_pools = BigDataPoolsOperations(
self._client, self._config, self._serialize, self._deserialize)
self.integration_runtimes = IntegrationRuntimesOperations(
self._client, self._config, self._serialize, self._deserialize)
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 TextAnalyticsClient(TextAnalyticsClientOperationsMixin,
MultiApiClientMixin, _SDKClient):
"""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.
This ready contains multiple API versions, to help you deal with all of the Azure clouds
(Azure Stack, Azure Government, Azure China, etc.).
By default, it uses the latest API version available on public Azure.
For production, you should stick to a particular api-version and/or profile.
The profile sets a mapping between an operation group and its API version.
The api-version parameter sets the default API version if the operation
group is not described in the profile.
: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
:param api_version: API version to use if no profile is provided, or if missing in profile.
:type api_version: str
:param profile: A profile definition, from KnownProfiles to dict.
:type profile: azure.profiles.KnownProfiles
:keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
"""
DEFAULT_API_VERSION = 'v3.0'
_PROFILE_TAG = "azure.ai.textanalytics.TextAnalyticsClient"
LATEST_PROFILE = ProfileDefinition(
{_PROFILE_TAG: {
None: DEFAULT_API_VERSION,
}}, _PROFILE_TAG + " latest")
def __init__(
self,
credential, # type: "TokenCredential"
endpoint, # type: str
api_version=None, # type: Optional[str]
profile=KnownProfiles.default, # type: KnownProfiles
**kwargs # type: Any
):
if api_version == 'v3.0':
base_url = '{Endpoint}/text/analytics/v3.0'
elif api_version == 'v3.1-preview.5':
base_url = '{Endpoint}/text/analytics/v3.1-preview.5'
else:
raise ValueError(
"API version {} is not available".format(api_version))
self._config = TextAnalyticsClientConfiguration(
credential, endpoint, **kwargs)
self._client = PipelineClient(base_url=base_url,
config=self._config,
**kwargs)
super(TextAnalyticsClient, self).__init__(api_version=api_version,
profile=profile)
@classmethod
def _models_dict(cls, api_version):
return {
k: v
for k, v in cls.models(api_version).__dict__.items()
if isinstance(v, type)
}
@classmethod
def models(cls, api_version=DEFAULT_API_VERSION):
"""Module depends on the API version:
* v3.0: :mod:`v3_0.models<azure.ai.textanalytics.v3_0.models>`
* v3.1-preview.5: :mod:`v3_1_preview_5.models<azure.ai.textanalytics.v3_1_preview_5.models>`
"""
if api_version == 'v3.0':
from .v3_0 import models
return models
elif api_version == 'v3.1-preview.5':
from .v3_1_preview_5 import models
return models
raise ValueError("API version {} is not available".format(api_version))
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 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.v2020_06.operations.DataSourcesOperations
:ivar indexers: IndexersOperations operations
:vartype indexers: azure.search.documents.indexes.v2020_06.operations.IndexersOperations
:ivar skillsets: SkillsetsOperations operations
:vartype skillsets: azure.search.documents.indexes.v2020_06.operations.SkillsetsOperations
:ivar synonym_maps: SynonymMapsOperations operations
:vartype synonym_maps: azure.search.documents.indexes.v2020_06.operations.SynonymMapsOperations
:ivar indexes: IndexesOperations operations
:vartype indexes: azure.search.documents.indexes.v2020_06.operations.IndexesOperations
:param endpoint: The endpoint URL of the search service.
:type endpoint: str
"""
def __init__(
self,
endpoint, # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{endpoint}'
self._config = SearchClientConfiguration(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.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, 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: () -> SearchClient
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
"""
def __init__(
self,
credential, # type: AzureKeyCredential
endpoint, # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{Endpoint}/anomalydetector/v1.1-preview'
self._config = AnomalyDetectorClientConfiguration(
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: () -> AnomalyDetectorClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class AzureCommunicationChatService(object):
"""Azure Communication Chat Service.
:ivar chat_thread: ChatThreadOperations operations
:vartype chat_thread: azure.communication.chat.operations.ChatThreadOperations
:ivar chat: ChatOperations operations
:vartype chat: azure.communication.chat.operations.ChatOperations
:param endpoint: The endpoint of the Azure Communication resource.
:type endpoint: str
"""
def __init__(
self,
endpoint, # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{endpoint}'
self._config = AzureCommunicationChatServiceConfiguration(
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.chat_thread = ChatThreadOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.chat = ChatOperations(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: () -> AzureCommunicationChatService
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.1-preview.4'
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._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: () -> TextAnalyticsClient
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
:keyword api_version: Api Version. The default value is "2021-07-01". Note that overriding this
default value may result in unsupported behavior.
:paramtype api_version: str
"""
def __init__(
self,
url, # type: str
**kwargs # type: Any
):
# type: (...) -> None
_base_url = '{url}'
self._config = ContainerRegistryConfiguration(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.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 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-02-02'
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 __enter__(self):
self._client.__enter__()
return self
def __exit__(self, *exc_details):
self._client.__exit__(*exc_details)
class AzureQuotaExtensionAPI(object):
"""Microsoft Azure Quota Resource Provider.
:ivar usages: usagesOperations operations
:vartype usages: azure_quota_extension_api.operations.usagesOperations
:ivar quota: quotaOperations operations
:vartype quota: azure_quota_extension_api.operations.quotaOperations
:ivar quotarequeststatus: quotarequeststatusOperations operations
:vartype quotarequeststatus: azure_quota_extension_api.operations.quotarequeststatusOperations
:ivar quotaoperation: quotaoperationOperations operations
:vartype quotaoperation: azure_quota_extension_api.operations.quotaoperationOperations
: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://management.azure.com'
self._config = AzureQuotaExtensionAPIConfiguration(
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._serialize.client_side_validation = False
self._deserialize = Deserializer(client_models)
self.usages = usagesOperations(self._client, self._config,
self._serialize, self._deserialize)
self.quota = quotaOperations(self._client, self._config,
self._serialize, self._deserialize)
self.quotarequeststatus = quotarequeststatusOperations(
self._client, self._config, self._serialize, self._deserialize)
self.quotaoperation = quotaoperationOperations(self._client,
self._config,
self._serialize,
self._deserialize)
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> AzureQuotaExtensionAPI
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class FormRecognizerClient(FormRecognizerClientOperationsMixin, MultiApiClientMixin, _SDKClient):
"""Extracts information from forms and images into structured data.
This ready contains multiple API versions, to help you deal with all of the Azure clouds
(Azure Stack, Azure Government, Azure China, etc.).
By default, it uses the latest API version available on public Azure.
For production, you should stick to a particular api-version and/or profile.
The profile sets a mapping between an operation group and its API version.
The api-version parameter sets the default API version if the operation
group is not described in the profile.
: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
:param api_version: API version to use if no profile is provided, or if missing in profile.
:type api_version: str
:param profile: A profile definition, from KnownProfiles to dict.
:type profile: azure.profiles.KnownProfiles
:keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
"""
DEFAULT_API_VERSION = '2.1-preview.3'
_PROFILE_TAG = "azure.ai.formrecognizer.FormRecognizerClient"
LATEST_PROFILE = ProfileDefinition({
_PROFILE_TAG: {
None: DEFAULT_API_VERSION,
}},
_PROFILE_TAG + " latest"
)
def __init__(
self,
credential, # type: "TokenCredential"
endpoint, # type: str
api_version=None, # type: Optional[str]
profile=KnownProfiles.default, # type: KnownProfiles
**kwargs # type: Any
):
if api_version == '2.0':
base_url = '{endpoint}/formrecognizer/v2.0'
elif api_version == '2.1-preview.3':
base_url = '{endpoint}/formrecognizer/v2.1-preview.3'
else:
raise ValueError("API version {} is not available".format(api_version))
self._config = FormRecognizerClientConfiguration(credential, endpoint, **kwargs)
self._client = PipelineClient(base_url=base_url, config=self._config, **kwargs)
super(FormRecognizerClient, self).__init__(
api_version=api_version,
profile=profile
)
@classmethod
def _models_dict(cls, api_version):
return {k: v for k, v in cls.models(api_version).__dict__.items() if isinstance(v, type)}
@classmethod
def models(cls, api_version=DEFAULT_API_VERSION):
"""Module depends on the API version:
* 2.0: :mod:`v2_0.models<azure.ai.formrecognizer.v2_0.models>`
* 2.1-preview.3: :mod:`v2_1_preview_3.models<azure.ai.formrecognizer.v2_1_preview_3.models>`
"""
if api_version == '2.0':
from .v2_0 import models
return models
elif api_version == '2.1-preview.3':
from .v2_1_preview_3 import models
return models
raise ValueError("API version {} is not available".format(api_version))
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 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 VnetClient(MultiApiClientMixin, _SDKClient):
"""VnetClient.
This ready contains multiple API versions, to help you deal with all of the Azure clouds
(Azure Stack, Azure Government, Azure China, etc.).
By default, it uses the latest API version available on public Azure.
For production, you should stick to a particular api-version and/or profile.
The profile sets a mapping between an operation group and its API version.
The api-version parameter sets the default API version if the operation
group is not described in the profile.
: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 api_version: API version to use if no profile is provided, or if missing in profile.
:type api_version: str
:param profile: A profile definition, from KnownProfiles to dict.
:type profile: azure.profiles.KnownProfiles
"""
DEFAULT_API_VERSION = '2020-12-01'
_PROFILE_TAG = "azure.synapse.managedprivateendpoints.VnetClient"
LATEST_PROFILE = ProfileDefinition({
_PROFILE_TAG: {
None: DEFAULT_API_VERSION,
}},
_PROFILE_TAG + " latest"
)
def __init__(
self,
credential, # type: "TokenCredential"
endpoint, # type: str
api_version=DEFAULT_API_VERSION, # type: Optional[str]
profile=KnownProfiles.default, # type: KnownProfiles
**kwargs # type: Any
):
if api_version == '2020-12-01' or api_version == '2021-06-01-preview':
base_url = '{endpoint}'
else:
raise ValueError("API version {} is not available".format(api_version))
self._config = VnetClientConfiguration(credential, endpoint, **kwargs)
self._client = PipelineClient(base_url=base_url, config=self._config, **kwargs)
super(VnetClient, self).__init__(
api_version=api_version,
profile=profile
)
@classmethod
def _models_dict(cls, api_version):
return {k: v for k, v in cls.models(api_version).__dict__.items() if isinstance(v, type)}
@classmethod
def models(cls, api_version=DEFAULT_API_VERSION):
"""Module depends on the API version:
* 2020-12-01: :mod:`v2020_12_01.models<azure.synapse.managedprivateendpoints.v2020_12_01.models>`
* 2021-06-01-preview: :mod:`v2021_06_01_preview.models<azure.synapse.managedprivateendpoints.v2021_06_01_preview.models>`
"""
if api_version == '2020-12-01':
from .v2020_12_01 import models
return models
elif api_version == '2021-06-01-preview':
from .v2021_06_01_preview import models
return models
raise ValueError("API version {} is not available".format(api_version))
@property
def managed_private_endpoints(self):
"""Instance depends on the API version:
* 2020-12-01: :class:`ManagedPrivateEndpointsOperations<azure.synapse.managedprivateendpoints.v2020_12_01.operations.ManagedPrivateEndpointsOperations>`
* 2021-06-01-preview: :class:`ManagedPrivateEndpointsOperations<azure.synapse.managedprivateendpoints.v2021_06_01_preview.operations.ManagedPrivateEndpointsOperations>`
"""
api_version = self._get_api_version('managed_private_endpoints')
if api_version == '2020-12-01':
from .v2020_12_01.operations import ManagedPrivateEndpointsOperations as OperationClass
elif api_version == '2021-06-01-preview':
from .v2021_06_01_preview.operations import ManagedPrivateEndpointsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'managed_private_endpoints'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
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 AzureBlobStorage(object):
"""AzureBlobStorage.
:ivar service: ServiceOperations operations
:vartype service: azure.storage.blob.operations.ServiceOperations
:ivar container: ContainerOperations operations
:vartype container: azure.storage.blob.operations.ContainerOperations
:ivar blob: BlobOperations operations
:vartype blob: azure.storage.blob.operations.BlobOperations
:ivar page_blob: PageBlobOperations operations
:vartype page_blob: azure.storage.blob.operations.PageBlobOperations
:ivar append_blob: AppendBlobOperations operations
:vartype append_blob: azure.storage.blob.operations.AppendBlobOperations
:ivar block_blob: BlockBlobOperations operations
:vartype block_blob: azure.storage.blob.operations.BlockBlobOperations
:param url: The URL of the service account, container, or blob 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 = 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._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.container = ContainerOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.blob = BlobOperations(self._client, self._config, self._serialize,
self._deserialize)
self.page_blob = PageBlobOperations(self._client, self._config,
self._serialize, self._deserialize)
self.append_blob = AppendBlobOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.block_blob = BlockBlobOperations(self._client, self._config,
self._serialize,
self._deserialize)
def _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 = {
'url':
self._serialize.url("self._config.url",
self._config.url,
'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: () -> AzureBlobStorage
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.3-preview". 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 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
: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 "2021-04-10". Note that overriding this default value may result in unsupported behavior.
:paramtype version: str
:keyword file_range_write_from_url: Only update is supported: - Update: Writes the bytes
downloaded from the source url into the specified range. Default value is "update". Note that
overriding this default value may result in unsupported behavior.
:paramtype file_range_write_from_url: str
"""
def __init__(
self,
url, # type: str
base_url="", # type: str
**kwargs # type: Any
):
# type: (...) -> None
self._config = AzureFileStorageConfiguration(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.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 _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: () -> AzureFileStorage
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, Conversation, 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
"""
def __init__(
self,
endpoint, # type: str
credential, # type: AzureKeyCredential
**kwargs # type: Any
):
# type: (...) -> None
_endpoint = '{Endpoint}/language'
self._config = ConversationAnalysisClientConfiguration(
endpoint, 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, # 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: () -> ConversationAnalysisClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class ArtifactsClient(object):
"""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, # type: "TokenCredential"
endpoint, # type: str
**kwargs # type: Any
):
# type: (...) -> 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 # 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: () -> ArtifactsClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class KeyVaultClient(KeyVaultClientOperationsMixin, MultiApiClientMixin,
_SDKClient):
"""The key vault client performs cryptographic key operations and vault operations against the Key Vault service.
This ready contains multiple API versions, to help you deal with all of the Azure clouds
(Azure Stack, Azure Government, Azure China, etc.).
By default, it uses the latest API version available on public Azure.
For production, you should stick to a particular api-version and/or profile.
The profile sets a mapping between an operation group and its API version.
The api-version parameter sets the default API version if the operation
group is not described in the profile.
:param api_version: API version to use if no profile is provided, or if missing in profile.
:type api_version: str
:param profile: A profile definition, from KnownProfiles to dict.
:type profile: azure.profiles.KnownProfiles
"""
DEFAULT_API_VERSION = '7.1'
_PROFILE_TAG = "azure.keyvault.KeyVaultClient"
LATEST_PROFILE = ProfileDefinition(
{
_PROFILE_TAG: {
None: DEFAULT_API_VERSION,
'backup_certificate': '7.0',
'backup_secret': '7.0',
'backup_storage_account': '7.0',
'create_certificate': '7.0',
'delete_certificate': '7.0',
'delete_certificate_contacts': '7.0',
'delete_certificate_issuer': '7.0',
'delete_certificate_operation': '7.0',
'delete_sas_definition': '7.0',
'delete_secret': '7.0',
'delete_storage_account': '7.0',
'get_certificate': '7.0',
'get_certificate_contacts': '7.0',
'get_certificate_issuer': '7.0',
'get_certificate_issuers': '7.0',
'get_certificate_operation': '7.0',
'get_certificate_policy': '7.0',
'get_certificate_versions': '7.0',
'get_certificates': '7.0',
'get_deleted_certificate': '7.0',
'get_deleted_certificates': '7.0',
'get_deleted_sas_definition': '7.0',
'get_deleted_sas_definitions': '7.0',
'get_deleted_secret': '7.0',
'get_deleted_secrets': '7.0',
'get_deleted_storage_account': '7.0',
'get_deleted_storage_accounts': '7.0',
'get_sas_definition': '7.0',
'get_sas_definitions': '7.0',
'get_secret': '7.0',
'get_secret_versions': '7.0',
'get_secrets': '7.0',
'get_storage_account': '7.0',
'get_storage_accounts': '7.0',
'import_certificate': '7.0',
'merge_certificate': '7.0',
'purge_deleted_certificate': '7.0',
'purge_deleted_secret': '7.0',
'purge_deleted_storage_account': '7.0',
'recover_deleted_certificate': '7.0',
'recover_deleted_sas_definition': '7.0',
'recover_deleted_secret': '7.0',
'recover_deleted_storage_account': '7.0',
'regenerate_storage_account_key': '7.0',
'restore_certificate': '7.0',
'restore_secret': '7.0',
'restore_storage_account': '7.0',
'set_certificate_contacts': '7.0',
'set_certificate_issuer': '7.0',
'set_sas_definition': '7.0',
'set_secret': '7.0',
'set_storage_account': '7.0',
'update_certificate': '7.0',
'update_certificate_issuer': '7.0',
'update_certificate_operation': '7.0',
'update_certificate_policy': '7.0',
'update_sas_definition': '7.0',
'update_secret': '7.0',
'update_storage_account': '7.0',
}
}, _PROFILE_TAG + " latest")
def __init__(
self,
api_version=None, # type: Optional[str]
profile=KnownProfiles.default, # type: KnownProfiles
**kwargs # type: Any
):
if api_version == '2016-10-01' or api_version == '7.0' or api_version == '7.1' or api_version == '7.2-preview':
base_url = '{vaultBaseUrl}'
else:
raise ValueError(
"API version {} is not available".format(api_version))
self._config = KeyVaultClientConfiguration(**kwargs)
self._client = PipelineClient(base_url=base_url,
config=self._config,
**kwargs)
super(KeyVaultClient, self).__init__(api_version=api_version,
profile=profile)
@classmethod
def _models_dict(cls, api_version):
return {
k: v
for k, v in cls.models(api_version).__dict__.items()
if isinstance(v, type)
}
@classmethod
def models(cls, api_version=DEFAULT_API_VERSION):
"""Module depends on the API version:
* 2016-10-01: :mod:`v2016_10_01.models<azure.keyvault.v2016_10_01.models>`
* 7.0: :mod:`v7_0.models<azure.keyvault.v7_0.models>`
* 7.1: :mod:`v7_1.models<azure.keyvault.v7_1.models>`
* 7.2-preview: :mod:`v7_2_preview.models<azure.keyvault.v7_2_preview.models>`
"""
if api_version == '2016-10-01':
from .v2016_10_01 import models
return models
elif api_version == '7.0':
from .v7_0 import models
return models
elif api_version == '7.1':
from .v7_1 import models
return models
elif api_version == '7.2-preview':
from .v7_2_preview import models
return models
raise ValueError("API version {} is not available".format(api_version))
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 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
: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
index_name, # type: str
**kwargs # type: Any
):
# type: (...) -> None
_base_url = '{endpoint}/indexes(\'{indexName}\')'
self._config = SearchClientConfiguration(endpoint=endpoint,
index_name=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)
