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)