def build_mount_blob_request( name, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) from_parameter = kwargs.pop('from_parameter') # type: str mount = kwargs.pop('mount') # type: str accept = _headers.pop('Accept', "application/json") # Construct URL _url = kwargs.pop("template_url", "/v2/{name}/blobs/uploads/") path_format_arguments = { "name": _SERIALIZER.url("name", name, 'str'), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters _params['from'] = _SERIALIZER.query("from_parameter", from_parameter, 'str') _params['mount'] = _SERIALIZER.query("mount", mount, 'str') # Construct headers _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs)
def build_list_request( subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-06-02-preview")) # type: str accept = _headers.pop('Accept', "application/json") # Construct URL _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/providers/Microsoft.ContainerService/fleets") path_format_arguments = { "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str', min_length=1), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') # Construct headers _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest( method="GET", url=_url, params=_params, headers=_headers, **kwargs )
def build_list_credentials_request( subscription_id: str, resource_group_name: str, fleet_name: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-06-02-preview")) # type: str accept = _headers.pop('Accept', "application/json") # Construct URL _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/fleets/{fleetName}/listCredentials") # pylint: disable=line-too-long path_format_arguments = { "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str', min_length=1), "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1), "fleetName": _SERIALIZER.url("fleet_name", fleet_name, 'str', max_length=63, min_length=1, pattern=r'^[a-z0-9]([-a-z0-9]*[a-z0-9])?$'), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') # Construct headers _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest( method="POST", url=_url, params=_params, headers=_headers, **kwargs )
def _create_or_update_initial( self, resource_group_name: str, fleet_name: str, parameters: _models.Fleet, if_match: Optional[str] = None, if_none_match: Optional[str] = None, **kwargs: Any ) -> _models.Fleet: error_map = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError } error_map.update(kwargs.pop('error_map', {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-06-02-preview")) # type: str content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] cls = kwargs.pop('cls', None) # type: ClsType[_models.Fleet] _json = self._serialize.body(parameters, 'Fleet') request = build_create_or_update_request_initial( subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, fleet_name=fleet_name, api_version=api_version, content_type=content_type, json=_json, if_match=if_match, if_none_match=if_none_match, template_url=self._create_or_update_initial.metadata['url'], headers=_headers, params=_params, ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response if response.status_code not in [200, 201]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) if response.status_code == 200: deserialized = self._deserialize('Fleet', pipeline_response) if response.status_code == 201: deserialized = self._deserialize('Fleet', pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized
def build_list_request(**kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-08-01")) # type: str accept = _headers.pop('Accept', "application/json") # Construct URL _url = kwargs.pop("template_url", "/providers/Microsoft.Dashboard/operations") # Construct parameters _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') # Construct headers _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
def build_conversation_analysis_request_initial(*, json: Optional[JSON] = None, content: Any = None, **kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-05-15-preview")) # type: str content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] accept = _headers.pop('Accept', "application/json") # Construct URL _url = "/analyze-conversations/jobs" # Construct parameters _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') # Construct headers if content_type is not None: _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, json=json, content=content, **kwargs)
async def _conversation_analysis_initial( self, task: JSON, **kwargs: Any ) -> Optional[JSON]: error_map = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError } error_map.update(kwargs.pop('error_map', {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-05-15-preview")) # type: str content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] cls = kwargs.pop('cls', None) # type: ClsType[Optional[JSON]] _json = task request = build_conversation_analysis_request_initial( api_version=api_version, content_type=content_type, json=_json, headers=_headers, params=_params, ) path_format_arguments = { "Endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), } request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response if response.status_code not in [200, 202]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) deserialized = None response_headers = {} if response.status_code == 200: if response.content: deserialized = response.json() else: deserialized = None if response.status_code == 202: response_headers['Operation-Location']=self._deserialize('str', response.headers.get('Operation-Location')) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized
async def _approve_initial( self, resource_group_name: str, workspace_name: str, private_endpoint_connection_name: str, body: Optional[_models.PrivateEndpointConnection] = None, **kwargs: Any ) -> _models.PrivateEndpointConnection: error_map = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError } error_map.update(kwargs.pop('error_map', {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-08-01")) # type: str content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateEndpointConnection] if body is not None: _json = self._serialize.body(body, 'PrivateEndpointConnection') else: _json = None request = build_approve_request_initial( subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, workspace_name=workspace_name, private_endpoint_connection_name=private_endpoint_connection_name, api_version=api_version, content_type=content_type, json=_json, template_url=self._approve_initial.metadata['url'], headers=_headers, params=_params, ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response if response.status_code not in [201]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) deserialized = self._deserialize('PrivateEndpointConnection', pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized
def build_update_request(subscription_id: str, resource_group_name: str, workspace_name: str, *, json: Optional[ _models.ManagedGrafanaUpdateParameters] = None, content: Any = None, **kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-08-01")) # type: str content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] accept = _headers.pop('Accept', "application/json") # Construct URL _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Dashboard/grafana/{workspaceName}") # pylint: disable=line-too-long path_format_arguments = { "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str', min_length=1), "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1), "workspaceName": _SERIALIZER.url("workspace_name", workspace_name, 'str'), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') # Construct headers if content_type is not None: _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, json=json, content=content, **kwargs)
def build_get_request(subscription_id: str, resource_group_name: str, resource_name: str, private_endpoint_connection_name: str, **kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-06-02-preview")) # type: str accept = _headers.pop('Accept', "application/json") # Construct URL _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/privateEndpointConnections/{privateEndpointConnectionName}") # pylint: disable=line-too-long path_format_arguments = { "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str', min_length=1), "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1), "resourceName": _SERIALIZER.url( "resource_name", resource_name, 'str', max_length=63, min_length=1, pattern=r'^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$' ), "privateEndpointConnectionName": _SERIALIZER.url("private_endpoint_connection_name", private_endpoint_connection_name, 'str'), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') # Construct headers _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
def build_create_or_update_request_initial( subscription_id: str, resource_group_name: str, fleet_name: str, fleet_member_name: str, *, json: Optional[_models.FleetMember] = None, content: Any = None, if_match: Optional[str] = None, if_none_match: Optional[str] = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-06-02-preview")) # type: str content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] accept = _headers.pop('Accept', "application/json") # Construct URL _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/fleets/{fleetName}/members/{fleetMemberName}") # pylint: disable=line-too-long path_format_arguments = { "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str', min_length=1), "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1), "fleetName": _SERIALIZER.url("fleet_name", fleet_name, 'str', max_length=63, min_length=1, pattern=r'^[a-z0-9]([-a-z0-9]*[a-z0-9])?$'), "fleetMemberName": _SERIALIZER.url("fleet_member_name", fleet_member_name, 'str', max_length=50, min_length=1, pattern=r'^[a-z0-9]([-a-z0-9]*[a-z0-9])?$'), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') # Construct headers if if_match is not None: _headers['If-Match'] = _SERIALIZER.header("if_match", if_match, 'str') if if_none_match is not None: _headers['If-None-Match'] = _SERIALIZER.header("if_none_match", if_none_match, 'str') if content_type is not None: _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest( method="PUT", url=_url, params=_params, headers=_headers, json=json, content=content, **kwargs )
def build_upload_chunk_request( next_link, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] accept = _headers.pop('Accept', "application/json") # Construct URL _url = kwargs.pop("template_url", "/{nextBlobUuidLink}") path_format_arguments = { "nextBlobUuidLink": _SERIALIZER.url("next_link", next_link, 'str', skip_quote=True), } _url = _format_url_section(_url, **path_format_arguments) # Construct headers if content_type is not None: _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="PATCH", url=_url, headers=_headers, **kwargs)
def build_check_chunk_exists_request( name, # type: str digest, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) range = kwargs.pop('range') # type: str accept = _headers.pop('Accept', "application/json") # Construct URL _url = kwargs.pop("template_url", "/v2/{name}/blobs/{digest}") path_format_arguments = { "name": _SERIALIZER.url("name", name, 'str'), "digest": _SERIALIZER.url("digest", digest, 'str'), } _url = _format_url_section(_url, **path_format_arguments) # Construct headers _headers['Range'] = _SERIALIZER.header("range", range, 'str') _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="HEAD", url=_url, headers=_headers, **kwargs)
def build_get_request(subscription_id: str, resource_group_name: str, workspace_name: str, private_link_resource_name: str, **kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-08-01")) # type: str accept = _headers.pop('Accept', "application/json") # Construct URL _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Dashboard/grafana/{workspaceName}/privateLinkResources/{privateLinkResourceName}") # pylint: disable=line-too-long path_format_arguments = { "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str', min_length=1), "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1), "workspaceName": _SERIALIZER.url("workspace_name", workspace_name, 'str'), "privateLinkResourceName": _SERIALIZER.url("private_link_resource_name", private_link_resource_name, 'str'), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') # Construct headers _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
def delete( # pylint: disable=inconsistent-return-statements self, resource_group_name: str, resource_name: str, **kwargs: Any) -> None: """Deletes a managed cluster snapshot. Deletes a managed cluster snapshot. :param resource_group_name: The name of the resource group. The name is case insensitive. :type resource_group_name: str :param resource_name: The name of the managed cluster resource. :type resource_name: str :keyword callable cls: A custom type or function that will be passed the direct response :return: None, or the result of cls(response) :rtype: None :raises: ~azure.core.exceptions.HttpResponseError """ error_map = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError } error_map.update(kwargs.pop('error_map', {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version = kwargs.pop( 'api_version', _params.pop('api-version', "2022-06-02-preview")) # type: str cls = kwargs.pop('cls', None) # type: ClsType[None] request = build_delete_request( subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, resource_name=resource_name, api_version=api_version, template_url=self.delete.metadata['url'], headers=_headers, params=_params, ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200, 204]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) if cls: return cls(pipeline_response, None, {})
def build_post_request( subscription_id: str, resource_group_name: str, resource_name: str, *, json: Optional[_models.PrivateLinkResource] = None, content: Any = None, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-06-02-preview")) # type: str content_type = kwargs.pop('content_type', _headers.pop('Content-Type', None)) # type: Optional[str] accept = _headers.pop('Accept', "application/json") # Construct URL _url = kwargs.pop("template_url", "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/resolvePrivateLinkServiceId") # pylint: disable=line-too-long path_format_arguments = { "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str', min_length=1), "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1), "resourceName": _SERIALIZER.url("resource_name", resource_name, 'str', max_length=63, min_length=1, pattern=r'^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$'), } _url = _format_url_section(_url, **path_format_arguments) # Construct parameters _params['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') # Construct headers if content_type is not None: _headers['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest( method="POST", url=_url, params=_params, headers=_headers, json=json, content=content, **kwargs )
async def _delete_initial( # pylint: disable=inconsistent-return-statements self, resource_group_name: str, fleet_name: str, if_match: Optional[str] = None, **kwargs: Any) -> None: error_map = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError } error_map.update(kwargs.pop('error_map', {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version = kwargs.pop( 'api_version', _params.pop('api-version', "2022-06-02-preview")) # type: str cls = kwargs.pop('cls', None) # type: ClsType[None] request = build_delete_request_initial( subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, fleet_name=fleet_name, api_version=api_version, if_match=if_match, template_url=self._delete_initial.metadata['url'], headers=_headers, params=_params, ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200, 202, 204]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) if cls: return cls(pipeline_response, None, {})
def build_start_upload_request( name, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) accept = _headers.pop('Accept', "application/json") # Construct URL _url = kwargs.pop("template_url", "/v2/{name}/blobs/uploads/") path_format_arguments = { "name": _SERIALIZER.url("name", name, 'str'), } _url = _format_url_section(_url, **path_format_arguments) # Construct headers _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="POST", url=_url, headers=_headers, **kwargs)
def build_cancel_upload_request( next_link, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) accept = _headers.pop('Accept', "application/json") # Construct URL _url = kwargs.pop("template_url", "/{nextBlobUuidLink}") path_format_arguments = { "nextBlobUuidLink": _SERIALIZER.url("next_link", next_link, 'str', skip_quote=True), } _url = _format_url_section(_url, **path_format_arguments) # Construct headers _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="DELETE", url=_url, headers=_headers, **kwargs)
def test_case_insensitive_dict_initialization(): dict_response = { "platformUpdateDomainCount": 5, "platformFaultDomainCount": 3, "virtualMachines": [] } a = case_insensitive_dict(platformUpdateDomainCount=5, platformFaultDomainCount=3, virtualMachines=[]) b = case_insensitive_dict( zip([ 'platformUpdateDomainCount', 'platformFaultDomainCount', 'virtualMachines' ], [5, 3, []])) c = case_insensitive_dict([('platformFaultDomainCount', 3), ('platformUpdateDomainCount', 5), ('virtualMachines', [])]) d = case_insensitive_dict({ 'virtualMachines': [], 'platformFaultDomainCount': 3, 'platformUpdateDomainCount': 5 }) e = case_insensitive_dict( { 'platformFaultDomainCount': 3, 'virtualMachines': [] }, platformUpdateDomainCount=5) f = case_insensitive_dict(dict_response) g = case_insensitive_dict(**dict_response) assert a == b == c == d == e == f == g dicts = [a, b, c, d, e, f, g] for d in dicts: assert len(d) == 3 assert d['platformUpdateDomainCount'] == d[ 'platformupdatedomaincount'] == d['PLATFORMUPDATEDOMAINCOUNT'] == 5 assert d['platformFaultDomainCount'] == d[ 'platformfaultdomaincount'] == d['PLATFORMFAULTDOMAINCOUNT'] == 3 assert d['virtualMachines'] == d['virtualmachines'] == d[ 'VIRTUALMACHINES'] == []
def build_delete_blob_request( name, # type: str digest, # type: str **kwargs # type: Any ): # type: (...) -> HttpRequest _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) accept = _headers.pop('Accept', "application/octet-stream") # Construct URL _url = kwargs.pop("template_url", "/v2/{name}/blobs/{digest}") path_format_arguments = { "name": _SERIALIZER.url("name", name, 'str'), "digest": _SERIALIZER.url("digest", digest, 'str'), } _url = _format_url_section(_url, **path_format_arguments) # Construct headers _headers['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest(method="DELETE", url=_url, headers=_headers, **kwargs)
def begin_create_or_update( self, resource_group_name: str, fleet_name: str, parameters: _models.Fleet, if_match: Optional[str] = None, if_none_match: Optional[str] = None, **kwargs: Any ) -> LROPoller[_models.Fleet]: """Creates or updates a Fleet. Creates or updates a Fleet. :param resource_group_name: The name of the resource group. The name is case insensitive. :type resource_group_name: str :param fleet_name: The name of the Fleet resource. :type fleet_name: str :param parameters: The Fleet to create or update. :type parameters: ~azure.mgmt.containerservice.v2022_06_02_preview.models.Fleet :param if_match: Omit this value to always overwrite the current resource. Specify the last-seen ETag value to prevent accidentally overwriting concurrent changes. Default value is None. :type if_match: str :param if_none_match: Set to '*' to allow a new resource to be created and prevent updating an existing resource. Other values will result in a 412 Pre-condition Failed response. Default value is None. :type if_none_match: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this operation to not poll, or pass in your own initialized polling object for a personal polling strategy. :paramtype polling: bool or ~azure.core.polling.PollingMethod :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present. :return: An instance of LROPoller that returns either Fleet or the result of cls(response) :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.containerservice.v2022_06_02_preview.models.Fleet] :raises: ~azure.core.exceptions.HttpResponseError """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-06-02-preview")) # type: str content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] cls = kwargs.pop('cls', None) # type: ClsType[_models.Fleet] polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] lro_delay = kwargs.pop( 'polling_interval', self._config.polling_interval ) cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] if cont_token is None: raw_result = self._create_or_update_initial( # type: ignore resource_group_name=resource_group_name, fleet_name=fleet_name, parameters=parameters, if_match=if_match, if_none_match=if_none_match, api_version=api_version, content_type=content_type, cls=lambda x,y,z: x, headers=_headers, params=_params, **kwargs ) kwargs.pop('error_map', None) def get_long_running_output(pipeline_response): deserialized = self._deserialize('Fleet', pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized if polling is True: polling_method = cast(PollingMethod, ARMPolling( lro_delay, **kwargs )) # type: PollingMethod elif polling is False: polling_method = cast(PollingMethod, NoPolling()) else: polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, deserialization_callback=get_long_running_output ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
def begin_conversation_analysis(self, task: JSON, **kwargs: Any) -> LROPoller[JSON]: """Submit analysis job for conversations. Submit a collection of conversations for analysis. Specify one or more unique tasks to be executed. :param task: The collection of conversations to analyze and one or more tasks to execute. :type task: JSON :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be LROBasePolling. Pass in False for this operation to not poll, or pass in your own initialized polling object for a personal polling strategy. :paramtype polling: bool or ~azure.core.polling.PollingMethod :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present. :return: An instance of LROPoller that returns JSON object :rtype: ~azure.core.polling.LROPoller[JSON] :raises: ~azure.core.exceptions.HttpResponseError Example: .. code-block:: python # JSON input template you can fill out and use as your body input. task = { "analysisInput": { "conversations": [ { "domain": "str", # Optional. Enumeration of supported conversational domains. Known values are: "finance", "healthcare", "generic". "id": "str", # Required. Unique identifier for the conversation. "language": "str", # Required. The language of the conversation item in BCP-47 format. modality: modality } ] }, "displayName": "str", # Optional. Optional display name for the analysis job. "tasks": [ { "taskName": "str", # Optional. Required. The set of tasks to execute on the input conversation. kind: AnalyzeConversationLROTask } ] } # response body for status code(s): 200 response.json() == { "createdDateTime": "2020-02-20 00:00:00", # Required. "displayName": "str", # Optional. "errors": [ { "code": "str", # Required. One of a server-defined set of error codes. Known values are: "InvalidRequest", "InvalidArgument", "Unauthorized", "Forbidden", "NotFound", "ProjectNotFound", "OperationNotFound", "AzureCognitiveSearchNotFound", "AzureCognitiveSearchIndexNotFound", "TooManyRequests", "AzureCognitiveSearchThrottling", "AzureCognitiveSearchIndexLimitReached", "InternalServerError", "ServiceUnavailable", "Timeout", "QuotaExceeded", "Conflict", "Warning". "details": [ ... ], "innererror": { "code": "str", # Required. One of a server-defined set of error codes. Known values are: "InvalidRequest", "InvalidParameterValue", "KnowledgeBaseNotFound", "AzureCognitiveSearchNotFound", "AzureCognitiveSearchThrottling", "ExtractionFailure", "InvalidRequestBodyFormat", "EmptyRequest", "MissingInputDocuments", "InvalidDocument", "ModelVersionIncorrect", "InvalidDocumentBatch", "UnsupportedLanguageCode", "InvalidCountryHint". "details": { "str": "str" # Optional. Error details. }, "innererror": ..., "message": "str", # Required. Error message. "target": "str" # Optional. Error target. }, "message": "str", # Required. A human-readable representation of the error. "target": "str" # Optional. The target of the error. } ], "expirationDateTime": "2020-02-20 00:00:00", # Optional. "jobId": "str", # Required. "lastUpdatedDateTime": "2020-02-20 00:00:00", # Required. "nextLink": "str", # Optional. "statistics": { "conversationsCount": 0, # Required. Number of conversations submitted in the request. "erroneousConversationsCount": 0, # Required. Number of invalid documents. This includes empty, over-size limit or non-supported languages documents. "transactionsCount": 0.0, # Required. Number of transactions for the request. "validConversationsCount": 0 # Required. Number of conversations documents. This excludes empty, over-size limit or non-supported languages documents. }, "status": "str", # Required. Known values are: "notStarted", "running", "succeeded", "partiallyCompleted", "failed", "cancelled", "cancelling". "tasks": { "completed": 0, # Required. Count of tasks completed successfully. "failed": 0, # Required. Count of tasks that failed. "inProgress": 0, # Required. Count of tasks in progress currently. "items": [ { "lastUpdateDateTime": "2020-02-20 00:00:00", # Required. The last updated time in UTC for the task. "status": "str", # Required. The status of the task at the mentioned last update time. Known values are: "notStarted", "running", "succeeded", "failed", "cancelled", "cancelling". "taskName": "str", # Optional. List of results from tasks (if available). kind: AnalyzeConversationJobResult } ], "total": 0 # Required. Total count of tasks submitted as part of the job. } } """ _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version = kwargs.pop( 'api_version', _params.pop('api-version', "2022-05-15-preview")) # type: str content_type = kwargs.pop( 'content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] cls = kwargs.pop('cls', None) # type: ClsType[JSON] polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] lro_delay = kwargs.pop('polling_interval', self._config.polling_interval) cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] if cont_token is None: raw_result = self._conversation_analysis_initial( # type: ignore task=task, api_version=api_version, content_type=content_type, cls=lambda x, y, z: x, headers=_headers, params=_params, **kwargs) kwargs.pop('error_map', None) def get_long_running_output(pipeline_response): response = pipeline_response.http_response if response.content: deserialized = response.json() else: deserialized = None if cls: return cls(pipeline_response, deserialized, {}) return deserialized path_format_arguments = { "Endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), } if polling is True: polling_method = cast( PollingMethod, LROBasePolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs)) # type: PollingMethod elif polling is False: polling_method = cast(PollingMethod, NoPolling()) else: polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, deserialization_callback=get_long_running_output) return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
def analyze_conversation(self, task: JSON, **kwargs: Any) -> JSON: """Analyzes the input conversation utterance. :param task: A single conversational task to execute. :type task: JSON :return: JSON object :rtype: JSON :raises: ~azure.core.exceptions.HttpResponseError Example: .. code-block:: python kind = 'ConversationalTask' # JSON input template you can fill out and use as your body input. task = { kind: kind } # response body for status code(s): 200 response.json() == { kind: kind } """ error_map = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError } error_map.update(kwargs.pop('error_map', {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version = kwargs.pop( 'api_version', _params.pop('api-version', "2022-05-15-preview")) # type: str content_type = kwargs.pop( 'content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] cls = kwargs.pop('cls', None) # type: ClsType[JSON] _json = task request = build_analyze_conversation_request( api_version=api_version, content_type=content_type, json=_json, headers=_headers, params=_params, ) path_format_arguments = { "Endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), } request.url = self._client.format_url( request.url, **path_format_arguments) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) if response.content: deserialized = response.json() else: deserialized = None if cls: return cls(pipeline_response, cast(JSON, deserialized), {}) return cast(JSON, deserialized)
def post( self, resource_group_name: str, resource_name: str, parameters: _models.PrivateLinkResource, **kwargs: Any ) -> _models.PrivateLinkResource: """Gets the private link service ID for the specified managed cluster. Gets the private link service ID for the specified managed cluster. :param resource_group_name: The name of the resource group. The name is case insensitive. :type resource_group_name: str :param resource_name: The name of the managed cluster resource. :type resource_name: str :param parameters: Parameters required in order to resolve a private link service ID. :type parameters: ~azure.mgmt.containerservice.v2022_06_02_preview.models.PrivateLinkResource :keyword callable cls: A custom type or function that will be passed the direct response :return: PrivateLinkResource, or the result of cls(response) :rtype: ~azure.mgmt.containerservice.v2022_06_02_preview.models.PrivateLinkResource :raises: ~azure.core.exceptions.HttpResponseError """ error_map = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError } error_map.update(kwargs.pop('error_map', {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-06-02-preview")) # type: str content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] cls = kwargs.pop('cls', None) # type: ClsType[_models.PrivateLinkResource] _json = self._serialize.body(parameters, 'PrivateLinkResource') request = build_post_request( subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, resource_name=resource_name, api_version=api_version, content_type=content_type, json=_json, template_url=self.post.metadata['url'], headers=_headers, params=_params, ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response, error_format=ARMErrorFormat) deserialized = self._deserialize('PrivateLinkResource', pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized
def list_credentials( self, resource_group_name: str, fleet_name: str, **kwargs: Any ) -> _models.FleetCredentialResults: """Lists the user credentials of a Fleet. Lists the user credentials of a Fleet. :param resource_group_name: The name of the resource group. The name is case insensitive. :type resource_group_name: str :param fleet_name: The name of the Fleet resource. :type fleet_name: str :keyword callable cls: A custom type or function that will be passed the direct response :return: FleetCredentialResults, or the result of cls(response) :rtype: ~azure.mgmt.containerservice.v2022_06_02_preview.models.FleetCredentialResults :raises: ~azure.core.exceptions.HttpResponseError """ error_map = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError } error_map.update(kwargs.pop('error_map', {}) or {}) _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-06-02-preview")) # type: str cls = kwargs.pop('cls', None) # type: ClsType[_models.FleetCredentialResults] request = build_list_credentials_request( subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, fleet_name=fleet_name, api_version=api_version, template_url=self.list_credentials.metadata['url'], headers=_headers, params=_params, ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) deserialized = self._deserialize('FleetCredentialResults', pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized
def list( self, **kwargs: Any ) -> Iterable[_models.FleetListResult]: """Lists fleets in the specified subscription. Lists fleets in the specified subscription. :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either FleetListResult or the result of cls(response) :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.containerservice.v2022_06_02_preview.models.FleetListResult] :raises: ~azure.core.exceptions.HttpResponseError """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-06-02-preview")) # type: str cls = kwargs.pop('cls', None) # type: ClsType[_models.FleetListResult] error_map = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError } error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: request = build_list_request( subscription_id=self._config.subscription_id, api_version=api_version, template_url=self.list.metadata['url'], headers=_headers, params=_params, ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore else: request = build_list_request( subscription_id=self._config.subscription_id, api_version=api_version, template_url=next_link, headers=_headers, params=_params, ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore request.method = "GET" return request def extract_data(pipeline_response): deserialized = self._deserialize("FleetListResult", pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) return deserialized.next_link or None, iter(list_of_elem) def get_next(next_link=None): request = prepare_request(next_link) pipeline_response = self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) return pipeline_response return ItemPaged( get_next, extract_data )
def begin_delete( # pylint: disable=inconsistent-return-statements self, resource_group_name: str, fleet_name: str, if_match: Optional[str] = None, **kwargs: Any ) -> LROPoller[None]: """Deletes a Fleet. Deletes a Fleet. :param resource_group_name: The name of the resource group. The name is case insensitive. :type resource_group_name: str :param fleet_name: The name of the Fleet resource. :type fleet_name: str :param if_match: Omit this value to always overwrite the current resource. Specify the last-seen ETag value to prevent accidentally overwriting concurrent changes. Default value is None. :type if_match: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this operation to not poll, or pass in your own initialized polling object for a personal polling strategy. :paramtype polling: bool or ~azure.core.polling.PollingMethod :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present. :return: An instance of LROPoller that returns either None or the result of cls(response) :rtype: ~azure.core.polling.LROPoller[None] :raises: ~azure.core.exceptions.HttpResponseError """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-06-02-preview")) # type: str cls = kwargs.pop('cls', None) # type: ClsType[None] polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod] lro_delay = kwargs.pop( 'polling_interval', self._config.polling_interval ) cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] if cont_token is None: raw_result = self._delete_initial( # type: ignore resource_group_name=resource_group_name, fleet_name=fleet_name, if_match=if_match, api_version=api_version, cls=lambda x,y,z: x, headers=_headers, params=_params, **kwargs ) kwargs.pop('error_map', None) def get_long_running_output(pipeline_response): if cls: return cls(pipeline_response, None, {}) if polling is True: polling_method = cast(PollingMethod, ARMPolling( lro_delay, lro_options={'final-state-via': 'location'}, **kwargs )) # type: PollingMethod elif polling is False: polling_method = cast(PollingMethod, NoPolling()) else: polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, deserialization_callback=get_long_running_output ) return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
def update( self, resource_group_name: str, fleet_name: str, if_match: Optional[str] = None, parameters: Optional[_models.FleetPatch] = None, **kwargs: Any ) -> _models.Fleet: """Patches a fleet resource. Patches a fleet resource. :param resource_group_name: The name of the resource group. The name is case insensitive. :type resource_group_name: str :param fleet_name: The name of the Fleet resource. :type fleet_name: str :param if_match: Omit this value to always overwrite the current resource. Specify the last-seen ETag value to prevent accidentally overwriting concurrent changes. Default value is None. :type if_match: str :param parameters: The properties of a Fleet to update. Default value is None. :type parameters: ~azure.mgmt.containerservice.v2022_06_02_preview.models.FleetPatch :keyword callable cls: A custom type or function that will be passed the direct response :return: Fleet, or the result of cls(response) :rtype: ~azure.mgmt.containerservice.v2022_06_02_preview.models.Fleet :raises: ~azure.core.exceptions.HttpResponseError """ error_map = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError } error_map.update(kwargs.pop('error_map', {}) or {}) _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-06-02-preview")) # type: str content_type = kwargs.pop('content_type', _headers.pop('Content-Type', "application/json")) # type: Optional[str] cls = kwargs.pop('cls', None) # type: ClsType[_models.Fleet] if parameters is not None: _json = self._serialize.body(parameters, 'FleetPatch') else: _json = None request = build_update_request( subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, fleet_name=fleet_name, api_version=api_version, content_type=content_type, json=_json, if_match=if_match, template_url=self.update.metadata['url'], headers=_headers, params=_params, ) request = _convert_request(request) request.url = self._client.format_url(request.url) # type: ignore pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access request, stream=False, **kwargs ) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) deserialized = self._deserialize('Fleet', pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized
def list( self, resource_group_name: str, workspace_name: str, **kwargs: Any ) -> AsyncIterable[_models.PrivateLinkResourceListResult]: """List all private link resources information for this grafana resource. List all private link resources information for this grafana resource. :param resource_group_name: The name of the resource group. The name is case insensitive. :type resource_group_name: str :param workspace_name: The workspace name of Azure Managed Grafana. :type workspace_name: str :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either PrivateLinkResourceListResult or the result of cls(response) :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.dashboard.models.PrivateLinkResourceListResult] :raises: ~azure.core.exceptions.HttpResponseError """ _headers = kwargs.pop("headers", {}) or {} _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version = kwargs.pop('api_version', _params.pop('api-version', "2022-08-01")) # type: str cls = kwargs.pop( 'cls', None) # type: ClsType[_models.PrivateLinkResourceListResult] error_map = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError } error_map.update(kwargs.pop('error_map', {}) or {}) def prepare_request(next_link=None): if not next_link: request = build_list_request( subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, workspace_name=workspace_name, api_version=api_version, template_url=self.list.metadata['url'], headers=_headers, params=_params, ) request = _convert_request(request) request.url = self._client.format_url( request.url) # type: ignore else: request = build_list_request( subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, workspace_name=workspace_name, api_version=api_version, template_url=next_link, headers=_headers, params=_params, ) request = _convert_request(request) request.url = self._client.format_url( request.url) # type: ignore request.method = "GET" return request async def extract_data(pipeline_response): deserialized = self._deserialize("PrivateLinkResourceListResult", pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): request = prepare_request(next_link) pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize( _models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) return pipeline_response return AsyncItemPaged(get_next, extract_data)