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 FarmBeatsClient(object):
"""APIs documentation for Azure AgPlatform DataPlane Service.
:ivar application_data: ApplicationDataOperations operations
:vartype application_data: azure.agrifood.farming.operations.ApplicationDataOperations
:ivar attachments: AttachmentsOperations operations
:vartype attachments: azure.agrifood.farming.operations.AttachmentsOperations
:ivar boundaries: BoundariesOperations operations
:vartype boundaries: azure.agrifood.farming.operations.BoundariesOperations
:ivar crops: CropsOperations operations
:vartype crops: azure.agrifood.farming.operations.CropsOperations
:ivar crop_varieties: CropVarietiesOperations operations
:vartype crop_varieties: azure.agrifood.farming.operations.CropVarietiesOperations
:ivar farmers: FarmersOperations operations
:vartype farmers: azure.agrifood.farming.operations.FarmersOperations
:ivar farm_operations: FarmOperationsOperations operations
:vartype farm_operations: azure.agrifood.farming.operations.FarmOperationsOperations
:ivar farms: FarmsOperations operations
:vartype farms: azure.agrifood.farming.operations.FarmsOperations
:ivar fields: FieldsOperations operations
:vartype fields: azure.agrifood.farming.operations.FieldsOperations
:ivar harvest_data: HarvestDataOperations operations
:vartype harvest_data: azure.agrifood.farming.operations.HarvestDataOperations
:ivar image_processing: ImageProcessingOperations operations
:vartype image_processing: azure.agrifood.farming.operations.ImageProcessingOperations
:ivar oauth_providers: OAuthProvidersOperations operations
:vartype oauth_providers: azure.agrifood.farming.operations.OAuthProvidersOperations
:ivar oauth_tokens: OAuthTokensOperations operations
:vartype oauth_tokens: azure.agrifood.farming.operations.OAuthTokensOperations
:ivar planting_data: PlantingDataOperations operations
:vartype planting_data: azure.agrifood.farming.operations.PlantingDataOperations
:ivar scenes: ScenesOperations operations
:vartype scenes: azure.agrifood.farming.operations.ScenesOperations
:ivar seasonal_fields: SeasonalFieldsOperations operations
:vartype seasonal_fields: azure.agrifood.farming.operations.SeasonalFieldsOperations
:ivar seasons: SeasonsOperations operations
:vartype seasons: azure.agrifood.farming.operations.SeasonsOperations
:ivar tillage_data: TillageDataOperations operations
:vartype tillage_data: azure.agrifood.farming.operations.TillageDataOperations
:ivar weather: WeatherOperations operations
:vartype weather: azure.agrifood.farming.operations.WeatherOperations
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials.TokenCredential
:param endpoint: The endpoint of your FarmBeats resource (protocol and hostname, for example: https://{resourceName}.farmbeats.azure.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 = FarmBeatsClientConfiguration(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.application_data = ApplicationDataOperations(
self._client, self._config, self._serialize, self._deserialize)
self.attachments = AttachmentsOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.boundaries = BoundariesOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.crops = CropsOperations(self._client, self._config,
self._serialize, self._deserialize)
self.crop_varieties = CropVarietiesOperations(self._client,
self._config,
self._serialize,
self._deserialize)
self.farmers = FarmersOperations(self._client, self._config,
self._serialize, self._deserialize)
self.farm_operations = FarmOperationsOperations(
self._client, self._config, self._serialize, self._deserialize)
self.farms = FarmsOperations(self._client, self._config,
self._serialize, self._deserialize)
self.fields = FieldsOperations(self._client, self._config,
self._serialize, self._deserialize)
self.harvest_data = HarvestDataOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.image_processing = ImageProcessingOperations(
self._client, self._config, self._serialize, self._deserialize)
self.oauth_providers = OAuthProvidersOperations(
self._client, self._config, self._serialize, self._deserialize)
self.oauth_tokens = OAuthTokensOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.planting_data = PlantingDataOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.scenes = ScenesOperations(self._client, self._config,
self._serialize, self._deserialize)
self.seasonal_fields = SeasonalFieldsOperations(
self._client, self._config, self._serialize, self._deserialize)
self.seasons = SeasonsOperations(self._client, self._config,
self._serialize, self._deserialize)
self.tillage_data = TillageDataOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.weather = WeatherOperations(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: () -> FarmBeatsClient
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. The default value is "2022-02-01". 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 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 _InkRecognizerClientBase(object):
def __init__(self, url, credential, **kwargs):
# type: (str, TokenCredential, Any) -> None
self._url = str(url)
self._default_arguments = _DEFAULT_ARGUMENTS.copy()
self._default_arguments.update(kwargs)
azure_config = _AzureConfiguration(credential, **kwargs)
self._pipeline_client = PipelineClient(
base_url=url,
config=azure_config,
transport=azure_config.transport)
def __enter__(self):
self._pipeline_client.__enter__()
return self
def __exit__(self, *exc_details):
self._pipeline_client.__exit__(*exc_details)
def _generate_config(self, request_arguments):
arguments = self._default_arguments.copy()
arguments.update(request_arguments)
config = _InkRecognizerConfiguration(**arguments)
return config
def _generate_url(self, config):
return self._url + config.service_version._to_string() # pylint:disable=protected-access
def _pack_one_stroke(self, stroke): # pylint:disable=no-self-use
stroke_points = [{
"x": point.x,
"y": point.y
} for point in stroke.points]
stroke_json = {
"id": stroke.id,
"points": stroke_points,
}
if stroke.kind in [InkStrokeKind.DRAWING, InkStrokeKind.WRITING]:
stroke_json["kind"] = stroke.kind.value
if stroke.language:
stroke_json["language"] = stroke.language
return stroke_json
def _pack_request(self, ink_stroke_list, config):
return json.dumps({
"applicationType":
config.application_kind.value,
"language":
config.language,
"unit":
config.ink_point_unit.value,
"unitMultiple":
config.unit_multiple,
"strokes": [
self._pack_one_stroke(stroke) for stroke in ink_stroke_list
if len(stroke.points) != 0
]
})
def _parse_result(self, response, config): # pylint:disable=inconsistent-return-statements
status_code = response.status_code
headers = response.headers
content = response.body().decode("utf-8")
if status_code == 200:
content_json = json.loads(content, encoding="utf-8")
if config.response_hook:
config.response_hook(headers, content_json)
try:
return _parse_recognition_units(content_json)
except Exception as err: # pylint:disable=broad-except
msg = "Cannot parse response from server."
raise_with_traceback(ServiceResponseError, msg, err)
else:
self._error_handler(status_code, content)
def _error_handler(self, status_code, content): # pylint:disable=no-self-use
if status_code == 404:
logging.warning(content)
raise ResourceNotFoundError(content)
if status_code == 401:
logging.warning(content)
raise ClientAuthenticationError(content)
logging.warning(content)
raise HttpResponseError(content)
def __init__(self, arguments):
super().__init__(arguments)
self.pipeline_client = PipelineClient(base_url=self.args.url, **self._client_kwargs)
self.async_pipeline_client = AsyncPipelineClient(base_url=self.args.url, **self._client_kwargs)
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 api_version: Api Version. Default value is "7.2". 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,
**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
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,
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)
def client():
# The poller itself don't use it, so we don't need something functionnal
return PipelineClient("https://baseurl")
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)
class PurviewCatalogClient(object):
"""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.
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials.TokenCredential
:param endpoint: The catalog endpoint of your Purview account. Example: https://{accountName}.catalog.purview.azure.com.
:type endpoint: str
"""
def __init__(
self,
credential, # type: "TokenCredential"
endpoint, # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{Endpoint}/api'
self._config = PurviewCatalogClientConfiguration(
credential, endpoint, **kwargs)
self._client = PipelineClient(base_url=base_url,
config=self._config,
**kwargs)
self._serialize = Serializer()
self._deserialize = Deserializer()
self._serialize.client_side_validation = False
def send_request(self, http_request, **kwargs):
# type: (HttpRequest, Any) -> 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.catalog.rest`.
Use these helper methods to create the request you pass to this method. See our example below:
>>> from azure.purview.catalog.rest import build_create_or_update_request
>>> request = build_create_or_update_request(json, content)
<HttpRequest [POST], url: '/atlas/v2/entity'>
>>> 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.purview.catalog.core.rest.HttpRequest`
and pass it in.
:param http_request: The network request you want to make. Required.
:type http_request: ~azure.purview.catalog.core.rest.HttpRequest
:keyword bool stream_response: 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.purview.catalog.core.rest.HttpResponse
"""
request_copy = deepcopy(http_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)
if kwargs.pop("stream_response", False):
return _StreamContextManager(
client=self._client._pipeline,
request=request_copy,
)
pipeline_response = self._client._pipeline.run(
request_copy._internal_request, **kwargs)
response = HttpResponse(
status_code=pipeline_response.http_response.status_code,
request=request_copy,
_internal_response=pipeline_response.http_response)
response.read()
return response
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 BadEndpointError(Exception):
pass
TEST_NAME = 'foo'
RESPONSE_BODY = {'properties': {'provisioningState': 'InProgress'}}
ASYNC_BODY = json.dumps({'status': 'Succeeded'})
ASYNC_URL = 'http://dummyurlFromAzureAsyncOPHeader_Return200'
LOCATION_BODY = json.dumps({'name': TEST_NAME})
LOCATION_URL = 'http://dummyurlurlFromLocationHeader_Return200'
RESOURCE_BODY = json.dumps({'name': TEST_NAME})
RESOURCE_URL = 'http://subscriptions/sub1/resourcegroups/g1/resourcetype1/resource1'
ERROR = 'http://dummyurl_ReturnError'
POLLING_STATUS = 200
CLIENT = PipelineClient("http://example.org")
CLIENT.http_request_type = None
CLIENT.http_response_type = None
def mock_run(client_self, request, **kwargs):
return TestBasePolling.mock_update(client_self.http_request_type,
client_self.http_response_type,
request.url, request.headers)
CLIENT._pipeline.run = types.MethodType(mock_run, CLIENT)
@pytest.fixture
def client():
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)
def test_add_custom_policy():
class BooPolicy(HTTPPolicy):
def send(*args):
raise AzureError('boo')
class FooPolicy(HTTPPolicy):
def send(*args):
raise AzureError('boo')
config = Configuration()
retry_policy = RetryPolicy()
config.retry_policy = retry_policy
boo_policy = BooPolicy()
foo_policy = FooPolicy()
client = PipelineClient(base_url="test",
config=config,
per_call_policies=boo_policy)
policies = client._pipeline._impl_policies
assert boo_policy in policies
pos_boo = policies.index(boo_policy)
pos_retry = policies.index(retry_policy)
assert pos_boo < pos_retry
client = PipelineClient(base_url="test",
config=config,
per_call_policies=[boo_policy])
policies = client._pipeline._impl_policies
assert boo_policy in policies
pos_boo = policies.index(boo_policy)
pos_retry = policies.index(retry_policy)
assert pos_boo < pos_retry
client = PipelineClient(base_url="test",
config=config,
per_retry_policies=boo_policy)
policies = client._pipeline._impl_policies
assert boo_policy in policies
pos_boo = policies.index(boo_policy)
pos_retry = policies.index(retry_policy)
assert pos_boo > pos_retry
client = PipelineClient(base_url="test",
config=config,
per_retry_policies=[boo_policy])
policies = client._pipeline._impl_policies
assert boo_policy in policies
pos_boo = policies.index(boo_policy)
pos_retry = policies.index(retry_policy)
assert pos_boo > pos_retry
client = PipelineClient(base_url="test",
config=config,
per_call_policies=boo_policy,
per_retry_policies=foo_policy)
policies = client._pipeline._impl_policies
assert boo_policy in policies
assert foo_policy in policies
pos_boo = policies.index(boo_policy)
pos_foo = policies.index(foo_policy)
pos_retry = policies.index(retry_policy)
assert pos_boo < pos_retry
assert pos_foo > pos_retry
client = PipelineClient(base_url="test",
config=config,
per_call_policies=[boo_policy],
per_retry_policies=[foo_policy])
policies = client._pipeline._impl_policies
assert boo_policy in policies
assert foo_policy in policies
pos_boo = policies.index(boo_policy)
pos_foo = policies.index(foo_policy)
pos_retry = policies.index(retry_policy)
assert pos_boo < pos_retry
assert pos_foo > pos_retry
policies = [UserAgentPolicy(), RetryPolicy(), DistributedTracingPolicy()]
client = PipelineClient(base_url="test",
policies=policies,
per_call_policies=boo_policy)
actual_policies = client._pipeline._impl_policies
assert boo_policy == actual_policies[0]
client = PipelineClient(base_url="test",
policies=policies,
per_call_policies=[boo_policy])
actual_policies = client._pipeline._impl_policies
assert boo_policy == actual_policies[0]
client = PipelineClient(base_url="test",
policies=policies,
per_retry_policies=foo_policy)
actual_policies = client._pipeline._impl_policies
assert foo_policy == actual_policies[2]
client = PipelineClient(base_url="test",
policies=policies,
per_retry_policies=[foo_policy])
actual_policies = client._pipeline._impl_policies
assert foo_policy == actual_policies[2]
client = PipelineClient(base_url="test",
policies=policies,
per_call_policies=boo_policy,
per_retry_policies=foo_policy)
actual_policies = client._pipeline._impl_policies
assert boo_policy == actual_policies[0]
assert foo_policy == actual_policies[3]
client = PipelineClient(base_url="test",
policies=policies,
per_call_policies=[boo_policy],
per_retry_policies=[foo_policy])
actual_policies = client._pipeline._impl_policies
assert boo_policy == actual_policies[0]
assert foo_policy == actual_policies[3]
policies = [UserAgentPolicy(), DistributedTracingPolicy()]
with pytest.raises(ValueError):
client = PipelineClient(base_url="test",
policies=policies,
per_retry_policies=foo_policy)
with pytest.raises(ValueError):
client = PipelineClient(base_url="test",
policies=policies,
per_retry_policies=[foo_policy])
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 PhoneNumbersClient(object):
"""The phone numbers client uses Azure Communication Services to acquire and manage phone numbers.
:ivar phone_numbers: PhoneNumbersOperations operations
:vartype phone_numbers: azure.communication.phonenumbers.operations.PhoneNumbersOperations
:param endpoint: The communication resource, for example https://resourcename.communication.azure.com.
:type endpoint: str
:keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
"""
def __init__(
self,
endpoint, # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{endpoint}'
self._config = PhoneNumbersClientConfiguration(endpoint, **kwargs)
self._client = PipelineClient(base_url=base_url,
config=self._config,
**kwargs)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
self.phone_numbers = PhoneNumbersOperations(self._client, self._config,
self._serialize,
self._deserialize)
def _send_request(self, http_request, **kwargs):
# type: (HttpRequest, Any) -> HttpResponse
"""Runs the network request through the client's chained policies.
:param http_request: The network request you want to make. Required.
:type http_request: ~azure.core.pipeline.transport.HttpRequest
:keyword bool stream: Whether the response payload will be streamed. Defaults to True.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.core.pipeline.transport.HttpResponse
"""
path_format_arguments = {
'endpoint':
self._serialize.url("self._config.endpoint",
self._config.endpoint,
'str',
skip_quote=True),
}
http_request.url = self._client.format_url(http_request.url,
**path_format_arguments)
stream = kwargs.pop("stream", True)
pipeline_response = self._client._pipeline.run(http_request,
stream=stream,
**kwargs)
return pipeline_response.http_response
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> PhoneNumbersClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class 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._serialize.client_side_validation = False
self._deserialize = Deserializer(client_models)
self.documents = DocumentsOperations(
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),
'indexName': self._serialize.url("self._config.index_name", self._config.index_name, 'str'),
}
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 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 directory: DirectoryOperations operations
:vartype directory: azure.storage.blob.operations.DirectoryOperations
: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.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 _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 MonitoringClient(object):
"""MonitoringClient.
:ivar monitoring: MonitoringOperations operations
:vartype monitoring: azure.synapse.monitoring.operations.MonitoringOperations
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials.TokenCredential
:param endpoint: The workspace development endpoint, for example https://myworkspace.dev.azuresynapse.net.
:type endpoint: str
"""
def __init__(
self,
credential, # type: "TokenCredential"
endpoint, # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{endpoint}'
self._config = MonitoringClientConfiguration(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.monitoring = MonitoringOperations(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: () -> MonitoringClient
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
"""
def __init__(
self,
url, # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{url}'
self._config = ContainerRegistryConfiguration(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.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, 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: () -> ContainerRegistry
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
class FormRecognizerClient(FormRecognizerClientOperationsMixin, MultiApiClientMixin, _SDKClient):
"""Extracts content, layout, and structured data from documents.
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 = '2021-09-30-preview'
_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 == '2021-09-30-preview':
base_url = '{endpoint}/formrecognizer'
elif api_version == '2.0':
base_url = '{endpoint}/formrecognizer/v2.0'
elif api_version == '2.1':
base_url = '{endpoint}/formrecognizer/v2.1'
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:
* 2021-09-30-preview: :mod:`v2021_09_30_preview.models<azure.ai.formrecognizer.v2021_09_30_preview.models>`
* 2.0: :mod:`v2_0.models<azure.ai.formrecognizer.v2_0.models>`
* 2.1: :mod:`v2_1.models<azure.ai.formrecognizer.v2_1.models>`
"""
if api_version == '2021-09-30-preview':
from .v2021_09_30_preview import models
return models
elif api_version == '2.0':
from .v2_0 import models
return models
elif api_version == '2.1':
from .v2_1 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 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 ConfidentialLedgerClient(object):
"""The ConfidentialLedgerClient writes and retrieves ledger entries against the Confidential Ledger service.
:ivar confidential_ledger: ConfidentialLedgerOperations operations
:vartype confidential_ledger: azure.confidentialledger._generated/_generated_ledger.v0_1_preview.operations.ConfidentialLedgerOperations
:param ledger_uri: The Confidential Ledger URL, for example https://contoso.confidentialledger.azure.com.
:type ledger_uri: str
"""
def __init__(
self,
ledger_uri, # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{ledgerUri}'
self._config = ConfidentialLedgerClientConfiguration(
ledger_uri, **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.confidential_ledger = ConfidentialLedgerOperations(
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 = {
'ledgerUri':
self._serialize.url("self._config.ledger_uri",
self._config.ledger_uri,
'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: () -> ConfidentialLedgerClient
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
:ivar workspace_git_repo_management: WorkspaceGitRepoManagementOperations operations
:vartype workspace_git_repo_management: azure.synapse.artifacts.operations.WorkspaceGitRepoManagementOperations
: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)
self.workspace_git_repo_management = WorkspaceGitRepoManagementOperations(
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 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
"""
def __init__(
self,
url, # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{url}'
self._config = AzureDataLakeStorageRESTAPIConfiguration(url, **kwargs)
self._client = PipelineClient(base_url=base_url,
config=self._config,
**kwargs)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer(client_models)
self._serialize.client_side_validation = False
self._deserialize = Deserializer(client_models)
self.service = ServiceOperations(self._client, self._config,
self._serialize, self._deserialize)
self.file_system = FileSystemOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.path = PathOperations(self._client, self._config, self._serialize,
self._deserialize)
def _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: () -> AzureDataLakeStorageRESTAPI
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.2'
_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' or api_version == '7.3-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: :mod:`v7_2.models<azure.keyvault.v7_2.models>`
* 7.3-preview: :mod:`v7_3_preview.models<azure.keyvault.v7_3_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':
from .v7_2 import models
return models
elif api_version == '7.3-preview':
from .v7_3_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 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 directory: DirectoryOperations operations
:vartype directory: azure.storage.blob.operations.DirectoryOperations
: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 targe 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.directory = DirectoryOperations(
self._client, self._config, self._serialize, self._deserialize)
self.blob = BlobOperations(
self._client, self._config, self._serialize, self._deserialize)
self.page_blob = PageBlobOperations(
self._client, self._config, self._serialize, self._deserialize)
self.append_blob = AppendBlobOperations(
self._client, self._config, self._serialize, self._deserialize)
self.block_blob = BlockBlobOperations(
self._client, self._config, self._serialize, self._deserialize)
def close(self):
# 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)
def __init__(
self,
credential, # type: "TokenCredential"
endpoint, # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{Endpoint}'
self._config = FarmBeatsClientConfiguration(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.application_data = ApplicationDataOperations(
self._client, self._config, self._serialize, self._deserialize)
self.attachments = AttachmentsOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.boundaries = BoundariesOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.crops = CropsOperations(self._client, self._config,
self._serialize, self._deserialize)
self.crop_varieties = CropVarietiesOperations(self._client,
self._config,
self._serialize,
self._deserialize)
self.farmers = FarmersOperations(self._client, self._config,
self._serialize, self._deserialize)
self.farm_operations = FarmOperationsOperations(
self._client, self._config, self._serialize, self._deserialize)
self.farms = FarmsOperations(self._client, self._config,
self._serialize, self._deserialize)
self.fields = FieldsOperations(self._client, self._config,
self._serialize, self._deserialize)
self.harvest_data = HarvestDataOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.image_processing = ImageProcessingOperations(
self._client, self._config, self._serialize, self._deserialize)
self.oauth_providers = OAuthProvidersOperations(
self._client, self._config, self._serialize, self._deserialize)
self.oauth_tokens = OAuthTokensOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.planting_data = PlantingDataOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.scenes = ScenesOperations(self._client, self._config,
self._serialize, self._deserialize)
self.seasonal_fields = SeasonalFieldsOperations(
self._client, self._config, self._serialize, self._deserialize)
self.seasons = SeasonsOperations(self._client, self._config,
self._serialize, self._deserialize)
self.tillage_data = TillageDataOperations(self._client, self._config,
self._serialize,
self._deserialize)
self.weather = WeatherOperations(self._client, self._config,
self._serialize, self._deserialize)
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
:keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
"""
DEFAULT_API_VERSION = '7.2'
_PROFILE_TAG = "azure.keyvault.KeyVaultClient"
LATEST_PROFILE = ProfileDefinition(
{_PROFILE_TAG: {
None: DEFAULT_API_VERSION,
}}, _PROFILE_TAG + " latest")
def __init__(
self,
api_version=None, # type: Optional[str]
profile=KnownProfiles.default, # type: KnownProfiles
**kwargs # type: Any
):
if api_version == '7.2' or api_version == '7.3-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:
* 7.2: :mod:`v7_2.models<azure.keyvault.v7_2.models>`
* 7.3-preview: :mod:`v7_3_preview.models<azure.keyvault.v7_3_preview.models>`
"""
if api_version == '7.2':
from .v7_2 import models
return models
elif api_version == '7.3-preview':
from .v7_3_preview import models
return models
raise ValueError("API version {} is not available".format(api_version))
@property
def role_assignments(self):
"""Instance depends on the API version:
* 7.2: :class:`RoleAssignmentsOperations<azure.keyvault.v7_2.operations.RoleAssignmentsOperations>`
* 7.3-preview: :class:`RoleAssignmentsOperations<azure.keyvault.v7_3_preview.operations.RoleAssignmentsOperations>`
"""
api_version = self._get_api_version('role_assignments')
if api_version == '7.2':
from .v7_2.operations import RoleAssignmentsOperations as OperationClass
elif api_version == '7.3-preview':
from .v7_3_preview.operations import RoleAssignmentsOperations as OperationClass
else:
raise ValueError(
"API version {} does not have operation group 'role_assignments'"
.format(api_version))
return OperationClass(self._client, self._config,
Serializer(self._models_dict(api_version)),
Deserializer(self._models_dict(api_version)))
@property
def role_definitions(self):
"""Instance depends on the API version:
* 7.2: :class:`RoleDefinitionsOperations<azure.keyvault.v7_2.operations.RoleDefinitionsOperations>`
* 7.3-preview: :class:`RoleDefinitionsOperations<azure.keyvault.v7_3_preview.operations.RoleDefinitionsOperations>`
"""
api_version = self._get_api_version('role_definitions')
if api_version == '7.2':
from .v7_2.operations import RoleDefinitionsOperations as OperationClass
elif api_version == '7.3-preview':
from .v7_3_preview.operations import RoleDefinitionsOperations as OperationClass
else:
raise ValueError(
"API version {} does not have operation group 'role_definitions'"
.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 SearchServiceClient(SearchServiceClientOperationsMixin):
"""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
"""
def __init__(
self,
endpoint, # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{endpoint}'
self._config = SearchServiceClientConfiguration(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 close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> SearchServiceClient
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)