def create_or_update(self, resource_group_name: str,
restore_point_collection_name: str,
parameters: "_models.RestorePointCollection",
**kwargs: Any) -> "_models.RestorePointCollection":
"""The operation to create or update the restore point collection. Please refer to
https://aka.ms/RestorePoints for more details. When updating a restore point collection, only
tags may be modified.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param restore_point_collection_name: The name of the restore point collection.
:type restore_point_collection_name: str
:param parameters: Parameters supplied to the Create or Update restore point collection
operation.
:type parameters: ~azure.mgmt.compute.v2021_07_01.models.RestorePointCollection
:keyword callable cls: A custom type or function that will be passed the direct response
:return: RestorePointCollection, or the result of cls(response)
:rtype: ~azure.mgmt.compute.v2021_07_01.models.RestorePointCollection
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop(
'cls', None) # type: ClsType["_models.RestorePointCollection"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
content_type = kwargs.pop('content_type',
"application/json") # type: Optional[str]
_json = self._serialize.body(parameters, 'RestorePointCollection')
request = build_create_or_update_request(
subscription_id=self._config.subscription_id,
resource_group_name=resource_group_name,
restore_point_collection_name=restore_point_collection_name,
content_type=content_type,
json=_json,
template_url=self.create_or_update.metadata['url'],
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
pipeline_response = self._client._pipeline.run(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('RestorePointCollection',
pipeline_response)
if response.status_code == 201:
deserialized = self._deserialize('RestorePointCollection',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
def update(self, resource_group_name: str, resource_name: str,
private_endpoint_connection_name: str,
parameters: "_models.PrivateEndpointConnection",
**kwargs: Any) -> "_models.PrivateEndpointConnection":
"""Updates a private endpoint connection.
Updates a private endpoint connection in the specified managed cluster.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param resource_name: The name of the managed cluster resource.
:type resource_name: str
:param private_endpoint_connection_name: The name of the private endpoint connection.
:type private_endpoint_connection_name: str
:param parameters: Parameters supplied to the Update a private endpoint connection operation.
:type parameters: ~azure.mgmt.containerservice.v2020_09_01.models.PrivateEndpointConnection
:keyword callable cls: A custom type or function that will be passed the direct response
:return: PrivateEndpointConnection, or the result of cls(response)
:rtype: ~azure.mgmt.containerservice.v2020_09_01.models.PrivateEndpointConnection
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop(
'cls', None) # type: ClsType["_models.PrivateEndpointConnection"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
content_type = kwargs.pop('content_type',
"application/json") # type: Optional[str]
_json = self._serialize.body(parameters, 'PrivateEndpointConnection')
request = build_update_request(
subscription_id=self._config.subscription_id,
resource_group_name=resource_group_name,
resource_name=resource_name,
private_endpoint_connection_name=private_endpoint_connection_name,
content_type=content_type,
json=_json,
template_url=self.update.metadata['url'],
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
pipeline_response = self._client._pipeline.run(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('PrivateEndpointConnection',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
async def get(self,
resource_group_name: str,
network_security_group_name: str,
expand: Optional[str] = None,
**kwargs: Any) -> "_models.NetworkSecurityGroup":
"""Gets the specified network security group.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param network_security_group_name: The name of the network security group.
:type network_security_group_name: str
:param expand: Expands referenced resources.
:type expand: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: NetworkSecurityGroup, or the result of cls(response)
:rtype: ~azure.mgmt.network.v2019_02_01.models.NetworkSecurityGroup
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls',
None) # type: ClsType["_models.NetworkSecurityGroup"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2019-02-01"
accept = "application/json"
# Construct URL
url = self.get.metadata['url'] # type: ignore
path_format_arguments = {
'resourceGroupName':
self._serialize.url("resource_group_name", resource_group_name,
'str'),
'networkSecurityGroupName':
self._serialize.url("network_security_group_name",
network_security_group_name, 'str'),
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
if expand is not None:
query_parameters['$expand'] = self._serialize.query(
"expand", expand, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header(
"accept", accept, 'str')
request = self._client.get(url, query_parameters, header_parameters)
pipeline_response = await self._client._pipeline.run(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('NetworkSecurityGroup',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
def list_by_service(self, resource_group_name: str, service_name: str,
quota_counter_key: str,
**kwargs: Any) -> "_models.QuotaCounterCollection":
"""Lists a collection of current quota counter periods associated with the counter-key configured
in the policy on the specified service instance. The api does not support paging yet.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param service_name: The name of the API Management service.
:type service_name: str
:param quota_counter_key: Quota counter key identifier.This is the result of expression defined
in counter-key attribute of the quota-by-key policy.For Example, if you specify
counter-key="boo" in the policy, then it’s accessible by "boo" counter key. But if it’s defined
as counter-key="@("b"+"a")" then it will be accessible by "ba" key.
:type quota_counter_key: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: QuotaCounterCollection, or the result of cls(response)
:rtype: ~api_management_client.models.QuotaCounterCollection
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop(
'cls', None) # type: ClsType["_models.QuotaCounterCollection"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
request = build_list_by_service_request(
resource_group_name=resource_group_name,
service_name=service_name,
quota_counter_key=quota_counter_key,
subscription_id=self._config.subscription_id,
template_url=self.list_by_service.metadata['url'],
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
pipeline_response = self._client._pipeline.run(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('QuotaCounterCollection',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
async def update_planner(
self,
user_id: str,
id: Optional[str] = None,
favorite_plan_references: Optional[Dict[str, object]] = None,
recent_plan_references: Optional[Dict[str, object]] = None,
all: Optional[List["models.MicrosoftGraphPlannerDelta"]] = None,
favorite_plans: Optional[List["models.MicrosoftGraphPlannerPlan"]] = None,
plans: Optional[List["models.MicrosoftGraphPlannerPlan"]] = None,
recent_plans: Optional[List["models.MicrosoftGraphPlannerPlan"]] = None,
tasks: Optional[List["models.MicrosoftGraphPlannerTask"]] = None,
**kwargs
) -> None:
"""Update the navigation property planner in users.
Update the navigation property planner in users.
:param user_id: key: id of user.
:type user_id: str
:param id: Read-only.
:type id: str
:param favorite_plan_references: plannerFavoritePlanReferenceCollection.
:type favorite_plan_references: dict[str, object]
:param recent_plan_references: plannerRecentPlanReferenceCollection.
:type recent_plan_references: dict[str, object]
:param all:
:type all: list[~planner.models.MicrosoftGraphPlannerDelta]
:param favorite_plans:
:type favorite_plans: list[~planner.models.MicrosoftGraphPlannerPlan]
:param plans: Read-only. Nullable. Returns the plannerTasks assigned to the user.
:type plans: list[~planner.models.MicrosoftGraphPlannerPlan]
:param recent_plans:
:type recent_plans: list[~planner.models.MicrosoftGraphPlannerPlan]
:param tasks: Read-only. Nullable. Returns the plannerPlans shared with the user.
:type tasks: list[~planner.models.MicrosoftGraphPlannerTask]
: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
"""
cls = kwargs.pop('cls', None) # type: ClsType[None]
error_map = {404: ResourceNotFoundError, 409: ResourceExistsError}
error_map.update(kwargs.pop('error_map', {}))
_body = models.MicrosoftGraphPlannerUser(id=id, favorite_plan_references=favorite_plan_references, recent_plan_references=recent_plan_references, all=all, favorite_plans=favorite_plans, plans=plans, recent_plans=recent_plans, tasks=tasks)
content_type = kwargs.pop("content_type", "application/json")
accept = "application/json"
# Construct URL
url = self.update_planner.metadata['url'] # type: ignore
path_format_arguments = {
'user-id': self._serialize.url("user_id", user_id, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str')
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
body_content_kwargs = {} # type: Dict[str, Any]
body_content = self._serialize.body(_body, 'MicrosoftGraphPlannerUser')
body_content_kwargs['content'] = body_content
request = self._client.patch(url, query_parameters, header_parameters, **body_content_kwargs)
pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs)
response = pipeline_response.http_response
if response.status_code not in [204]:
map_error(status_code=response.status_code, response=response, error_map=error_map)
error = self._deserialize(models.OdataError, response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
if cls:
return cls(pipeline_response, None, {})
def _update_tags_initial(
self,
resource_group_name, # type: str
route_table_name, # type: str
parameters, # type: "models.TagsObject"
**kwargs # type: Any
):
# type: (...) -> "models.RouteTable"
cls = kwargs.pop('cls', None) # type: ClsType["models.RouteTable"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2019-07-01"
content_type = kwargs.pop("content_type", "application/json")
accept = "application/json"
# Construct URL
url = self._update_tags_initial.metadata['url'] # type: ignore
path_format_arguments = {
'resourceGroupName':
self._serialize.url("resource_group_name", resource_group_name,
'str'),
'routeTableName':
self._serialize.url("route_table_name", route_table_name, 'str'),
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Content-Type'] = self._serialize.header(
"content_type", content_type, 'str')
header_parameters['Accept'] = self._serialize.header(
"accept", accept, 'str')
body_content_kwargs = {} # type: Dict[str, Any]
body_content = self._serialize.body(parameters, 'TagsObject')
body_content_kwargs['content'] = body_content
request = self._client.patch(url, query_parameters, header_parameters,
**body_content_kwargs)
pipeline_response = self._client._pipeline.run(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('RouteTable', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
async def update_tags(
self,
resource_group_name: str,
firewall_policy_name: str,
firewall_policy_parameters: "models.TagsObject",
**kwargs
) -> "models.FirewallPolicy":
"""Updates a Firewall Policy Tags.
:param resource_group_name: The resource group name of the Firewall Policy.
:type resource_group_name: str
:param firewall_policy_name: The name of the Firewall Policy being updated.
:type firewall_policy_name: str
:param firewall_policy_parameters: Parameters supplied to Update Firewall Policy tags.
:type firewall_policy_parameters: ~azure.mgmt.network.v2019_07_01.models.TagsObject
:keyword callable cls: A custom type or function that will be passed the direct response
:return: FirewallPolicy, or the result of cls(response)
:rtype: ~azure.mgmt.network.v2019_07_01.models.FirewallPolicy
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["models.FirewallPolicy"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2019-07-01"
content_type = kwargs.pop("content_type", "application/json")
accept = "application/json"
# Construct URL
url = self.update_tags.metadata['url'] # type: ignore
path_format_arguments = {
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
'firewallPolicyName': self._serialize.url("firewall_policy_name", firewall_policy_name, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str')
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
body_content_kwargs = {} # type: Dict[str, Any]
body_content = self._serialize.body(firewall_policy_parameters, 'TagsObject')
body_content_kwargs['content'] = body_content
request = self._client.patch(url, query_parameters, header_parameters, **body_content_kwargs)
pipeline_response = await self._client._pipeline.run(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(models.Error, response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
deserialized = self._deserialize('FirewallPolicy', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
async def get(self, resource_group_name: str, server_name: str,
database_name: str, workload_group_name: str,
workload_classifier_name: str,
**kwargs) -> "models.WorkloadClassifier":
"""Gets a workload classifier.
:param resource_group_name: The name of the resource group that contains the resource. You can
obtain this value from the Azure Resource Manager API or the portal.
:type resource_group_name: str
:param server_name: The name of the server.
:type server_name: str
:param database_name: The name of the database.
:type database_name: str
:param workload_group_name: The name of the workload group from which to receive the classifier
from.
:type workload_group_name: str
:param workload_classifier_name: The name of the workload classifier.
:type workload_classifier_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: WorkloadClassifier, or the result of cls(response)
:rtype: ~azure.mgmt.sql.models.WorkloadClassifier
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls',
None) # type: ClsType["models.WorkloadClassifier"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2019-06-01-preview"
accept = "application/json"
# Construct URL
url = self.get.metadata['url'] # type: ignore
path_format_arguments = {
'resourceGroupName':
self._serialize.url("resource_group_name", resource_group_name,
'str'),
'serverName':
self._serialize.url("server_name", server_name, 'str'),
'databaseName':
self._serialize.url("database_name", database_name, 'str'),
'workloadGroupName':
self._serialize.url("workload_group_name", workload_group_name,
'str'),
'workloadClassifierName':
self._serialize.url("workload_classifier_name",
workload_classifier_name, 'str'),
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header(
"accept", accept, 'str')
request = self._client.get(url, query_parameters, header_parameters)
pipeline_response = await self._client._pipeline.run(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('WorkloadClassifier',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
def _list_initial(
self,
resource_group_name, # type: str
virtual_wan_name, # type: str
**kwargs # type: Any
):
# type: (...) -> Optional["_models.VpnServerConfigurationsResponse"]
cls = kwargs.pop(
'cls', None
) # type: ClsType[Optional["_models.VpnServerConfigurationsResponse"]]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2021-05-01"
accept = "application/json"
# Construct URL
url = self._list_initial.metadata['url'] # type: ignore
path_format_arguments = {
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
'resourceGroupName':
self._serialize.url("resource_group_name", resource_group_name,
'str'),
'virtualWANName':
self._serialize.url("virtual_wan_name", virtual_wan_name, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header(
"accept", accept, 'str')
request = self._client.post(url, query_parameters, header_parameters)
pipeline_response = self._client._pipeline.run(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,
error_format=ARMErrorFormat)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('VpnServerConfigurationsResponse',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
async def delete(self, vault_base_url: str, scope: str,
role_definition_name: str,
**kwargs: Any) -> "_models.RoleDefinition":
"""Deletes a custom role definition.
:param vault_base_url: The vault name, for example https://myvault.vault.azure.net.
:type vault_base_url: str
:param scope: The scope of the role definition to delete. Managed HSM only supports '/'.
:type scope: str
:param role_definition_name: The name (GUID) of the role definition to delete.
:type role_definition_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: RoleDefinition, or the result of cls(response)
:rtype: ~azure.keyvault.v7_3.models.RoleDefinition
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls',
None) # type: ClsType["_models.RoleDefinition"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = kwargs.pop('api_version', "7.3") # type: str
request = build_delete_request(
scope=scope,
role_definition_name=role_definition_name,
api_version=api_version,
template_url=self.delete.metadata['url'],
)
request = _convert_request(request)
path_format_arguments = {
"vaultBaseUrl":
self._serialize.url("vault_base_url",
vault_base_url,
'str',
skip_quote=True),
}
request.url = self._client.format_url(request.url,
**path_format_arguments)
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.KeyVaultError, pipeline_response)
raise HttpResponseError(response=response, model=error)
deserialized = self._deserialize('RoleDefinition', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
async def _unprepare_network_policies_initial(
self, resource_group_name: str, virtual_network_name: str,
subnet_name: str, unprepare_network_policies_request_parameters:
"_models.UnprepareNetworkPoliciesRequest", **kwargs) -> None:
cls = kwargs.pop('cls', None) # type: ClsType[None]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2020-06-01"
content_type = kwargs.pop("content_type", "application/json")
accept = "application/json"
# Construct URL
url = self._unprepare_network_policies_initial.metadata[
'url'] # type: ignore
path_format_arguments = {
'resourceGroupName':
self._serialize.url("resource_group_name", resource_group_name,
'str'),
'virtualNetworkName':
self._serialize.url("virtual_network_name", virtual_network_name,
'str'),
'subnetName':
self._serialize.url("subnet_name", subnet_name, 'str'),
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Content-Type'] = self._serialize.header(
"content_type", content_type, 'str')
header_parameters['Accept'] = self._serialize.header(
"accept", accept, 'str')
body_content_kwargs = {} # type: Dict[str, Any]
body_content = self._serialize.body(
unprepare_network_policies_request_parameters,
'UnprepareNetworkPoliciesRequest')
body_content_kwargs['content'] = body_content
request = self._client.post(url, query_parameters, header_parameters,
**body_content_kwargs)
pipeline_response = await self._client._pipeline.run(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,
error_format=ARMErrorFormat)
if cls:
return cls(pipeline_response, None, {})
async def get(
self,
vault_name: str,
resource_group_name: str,
backup_engine_name: str,
filter: Optional[str] = None,
skip_token: Optional[str] = None,
**kwargs: Any
) -> "_models.BackupEngineBaseResource":
"""Returns backup management server registered to Recovery Services Vault.
:param vault_name: The name of the recovery services vault.
:type vault_name: str
:param resource_group_name: The name of the resource group where the recovery services vault is
present.
:type resource_group_name: str
:param backup_engine_name: Name of the backup management server.
:type backup_engine_name: str
:param filter: OData filter options.
:type filter: str
:param skip_token: skipToken Filter.
:type skip_token: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: BackupEngineBaseResource, or the result of cls(response)
:rtype: ~azure.mgmt.recoveryservicesbackup.models.BackupEngineBaseResource
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.BackupEngineBaseResource"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2021-08-01"
accept = "application/json"
# Construct URL
url = self.get.metadata['url'] # type: ignore
path_format_arguments = {
'vaultName': self._serialize.url("vault_name", vault_name, 'str'),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
'backupEngineName': self._serialize.url("backup_engine_name", backup_engine_name, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
if filter is not None:
query_parameters['$filter'] = self._serialize.query("filter", filter, 'str')
if skip_token is not None:
query_parameters['$skipToken'] = self._serialize.query("skip_token", skip_token, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
request = self._client.get(url, query_parameters, header_parameters)
pipeline_response = await self._client._pipeline.run(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('BackupEngineBaseResource', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
def get_notebook(self,
notebook_name: str,
if_none_match: Optional[str] = None,
**kwargs: Any) -> Optional["_models.NotebookResource"]:
"""Gets a Note Book.
:param notebook_name: The notebook name.
:type notebook_name: str
:param if_none_match: ETag of the Notebook entity. Should only be specified for get. If the
ETag matches the existing entity tag, or if * was provided, then no content will be returned.
:type if_none_match: str
:keyword api_version: Api Version. The default value is "2020-12-01". Note that overriding this
default value may result in unsupported behavior.
:paramtype api_version: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: NotebookResource, or the result of cls(response)
:rtype: ~azure.synapse.artifacts.models.NotebookResource or None
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop(
'cls', None) # type: ClsType[Optional["_models.NotebookResource"]]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = kwargs.pop('api_version', "2020-12-01") # type: str
request = build_get_notebook_request(
notebook_name=notebook_name,
api_version=api_version,
if_none_match=if_none_match,
template_url=self.get_notebook.metadata['url'],
)
request = _convert_request(request)
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)
pipeline_response = self._client._pipeline.run(request,
stream=False,
**kwargs)
response = pipeline_response.http_response
if response.status_code not in [200, 304]:
map_error(status_code=response.status_code,
response=response,
error_map=error_map)
error = self._deserialize.failsafe_deserialize(
_models.CloudErrorAutoGenerated, pipeline_response)
raise HttpResponseError(response=response, model=error)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('NotebookResource',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
def _create_or_update_notebook_initial(
self,
notebook_name: str,
notebook: "_models.NotebookResource",
if_match: Optional[str] = None,
**kwargs: Any) -> Optional["_models.NotebookResource"]:
cls = kwargs.pop(
'cls', None) # type: ClsType[Optional["_models.NotebookResource"]]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = kwargs.pop('api_version', "2020-12-01") # type: str
content_type = kwargs.pop('content_type',
"application/json") # type: Optional[str]
_json = self._serialize.body(notebook, 'NotebookResource')
request = build_create_or_update_notebook_request_initial(
notebook_name=notebook_name,
api_version=api_version,
content_type=content_type,
json=_json,
if_match=if_match,
template_url=self._create_or_update_notebook_initial.
metadata['url'],
)
request = _convert_request(request)
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)
pipeline_response = self._client._pipeline.run(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
if response.status_code == 200:
deserialized = self._deserialize('NotebookResource',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
async def create_or_replace(
self,
resource_group_name: str,
job_name: str,
function_name: str,
function: "models.Function",
if_match: Optional[str] = None,
if_none_match: Optional[str] = None,
**kwargs
) -> "models.Function":
"""Creates a function or replaces an already existing function under an existing streaming job.
:param resource_group_name: The name of the resource group. The name is case insensitive.
:type resource_group_name: str
:param job_name: The name of the streaming job.
:type job_name: str
:param function_name: The name of the function.
:type function_name: str
:param function: The definition of the function that will be used to create a new function or
replace the existing one under the streaming job.
:type function: ~stream_analytics_management_client.models.Function
:param if_match: The ETag of the function. Omit this value to always overwrite the current
function. Specify the last-seen ETag value to prevent accidentally overwriting concurrent
changes.
:type if_match: str
:param if_none_match: Set to '*' to allow a new function to be created, but to prevent updating
an existing function. Other values will result in a 412 Pre-condition Failed response.
:type if_none_match: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: Function, or the result of cls(response)
:rtype: ~stream_analytics_management_client.models.Function
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["models.Function"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2020-03-01"
content_type = kwargs.pop("content_type", "application/json")
accept = "application/json"
# Construct URL
url = self.create_or_replace.metadata['url'] # type: ignore
path_format_arguments = {
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str', min_length=1),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
'jobName': self._serialize.url("job_name", job_name, 'str'),
'functionName': self._serialize.url("function_name", function_name, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
if if_match is not None:
header_parameters['If-Match'] = self._serialize.header("if_match", if_match, 'str')
if if_none_match is not None:
header_parameters['If-None-Match'] = self._serialize.header("if_none_match", if_none_match, 'str')
header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str')
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
body_content_kwargs = {} # type: Dict[str, Any]
body_content = self._serialize.body(function, 'Function')
body_content_kwargs['content'] = body_content
request = self._client.put(url, query_parameters, header_parameters, **body_content_kwargs)
pipeline_response = await self._client._pipeline.run(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)
error = self._deserialize(models.Error, response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
response_headers = {}
if response.status_code == 200:
response_headers['ETag']=self._deserialize('str', response.headers.get('ETag'))
deserialized = self._deserialize('Function', pipeline_response)
if response.status_code == 201:
response_headers['ETag']=self._deserialize('str', response.headers.get('ETag'))
deserialized = self._deserialize('Function', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, response_headers)
return deserialized
def get(
self,
resource_group_name, # type: str
scope_name, # type: str
group_name, # type: str
**kwargs # type: Any
):
# type: (...) -> "models.PrivateLinkResource"
"""Gets the private link resources that need to be created for a Azure Monitor PrivateLinkScope.
:param resource_group_name: The name of the resource group. The name is case insensitive.
:type resource_group_name: str
:param scope_name: The name of the Azure Arc PrivateLinkScope resource.
:type scope_name: str
:param group_name: The name of the private link resource.
:type group_name: str
: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.hybridcompute.models.PrivateLinkResource
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["models.PrivateLinkResource"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2022-03-10"
accept = "application/json"
# Construct URL
url = self.get.metadata['url'] # type: ignore
path_format_arguments = {
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str', min_length=1),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1),
'scopeName': self._serialize.url("scope_name", scope_name, 'str'),
'groupName': self._serialize.url("group_name", group_name, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
request = self._client.get(url, query_parameters, header_parameters)
pipeline_response = self._client._pipeline.run(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(models.ErrorResponse, response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
deserialized = self._deserialize('PrivateLinkResource', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
async def retrieve_default_definition(
self,
resource_group_name: str,
job_name: str,
function_name: str,
function_retrieve_default_definition_parameters: Optional["models.FunctionRetrieveDefaultDefinitionParameters"] = None,
**kwargs
) -> "models.Function":
"""Retrieves the default definition of a function based on the parameters specified.
:param resource_group_name: The name of the resource group. The name is case insensitive.
:type resource_group_name: str
:param job_name: The name of the streaming job.
:type job_name: str
:param function_name: The name of the function.
:type function_name: str
:param function_retrieve_default_definition_parameters: Parameters used to specify the type of
function to retrieve the default definition for.
:type function_retrieve_default_definition_parameters: ~stream_analytics_management_client.models.FunctionRetrieveDefaultDefinitionParameters
:keyword callable cls: A custom type or function that will be passed the direct response
:return: Function, or the result of cls(response)
:rtype: ~stream_analytics_management_client.models.Function
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["models.Function"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2020-03-01"
content_type = kwargs.pop("content_type", "application/json")
accept = "application/json"
# Construct URL
url = self.retrieve_default_definition.metadata['url'] # type: ignore
path_format_arguments = {
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str', min_length=1),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
'jobName': self._serialize.url("job_name", job_name, 'str'),
'functionName': self._serialize.url("function_name", function_name, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str')
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
body_content_kwargs = {} # type: Dict[str, Any]
if function_retrieve_default_definition_parameters is not None:
body_content = self._serialize.body(function_retrieve_default_definition_parameters, 'FunctionRetrieveDefaultDefinitionParameters')
else:
body_content = None
body_content_kwargs['content'] = body_content
request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs)
pipeline_response = await self._client._pipeline.run(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(models.Error, response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
deserialized = self._deserialize('Function', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
def regenerate_test_key(
self,
resource_group_name, # type: str
service_name, # type: str
regenerate_test_key_request, # type: "_models.RegenerateTestKeyRequestPayload"
**kwargs # type: Any
):
# type: (...) -> "_models.TestKeys"
"""Regenerate a test key for a Service.
:param resource_group_name: The name of the resource group that contains the resource. You can
obtain this value from the Azure Resource Manager API or the portal.
:type resource_group_name: str
:param service_name: The name of the Service resource.
:type service_name: str
:param regenerate_test_key_request: Parameters for the operation.
:type regenerate_test_key_request: ~azure.mgmt.appplatform.v2020_11_01_preview.models.RegenerateTestKeyRequestPayload
:keyword callable cls: A custom type or function that will be passed the direct response
:return: TestKeys, or the result of cls(response)
:rtype: ~azure.mgmt.appplatform.v2020_11_01_preview.models.TestKeys
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.TestKeys"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2020-11-01-preview"
content_type = kwargs.pop("content_type", "application/json")
accept = "application/json"
# Construct URL
url = self.regenerate_test_key.metadata['url'] # type: ignore
path_format_arguments = {
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
'serviceName': self._serialize.url("service_name", service_name, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str')
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
body_content_kwargs = {} # type: Dict[str, Any]
body_content = self._serialize.body(regenerate_test_key_request, 'RegenerateTestKeyRequestPayload')
body_content_kwargs['content'] = body_content
request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs)
pipeline_response = self._client._pipeline.run(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('TestKeys', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
async def get(self, resource_group_name: str, virtual_hub_name: str,
**kwargs) -> "models.VirtualHub":
"""Retrieves the details of a VirtualHub.
:param resource_group_name: The resource group name of the VirtualHub.
:type resource_group_name: str
:param virtual_hub_name: The name of the VirtualHub.
:type virtual_hub_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: VirtualHub, or the result of cls(response)
:rtype: ~azure.mgmt.network.v2020_03_01.models.VirtualHub
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["models.VirtualHub"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2020-03-01"
accept = "application/json"
# Construct URL
url = self.get.metadata['url'] # type: ignore
path_format_arguments = {
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
'resourceGroupName':
self._serialize.url("resource_group_name", resource_group_name,
'str'),
'virtualHubName':
self._serialize.url("virtual_hub_name", virtual_hub_name, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header(
"accept", accept, 'str')
request = self._client.get(url, query_parameters, header_parameters)
pipeline_response = await self._client._pipeline.run(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('VirtualHub', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
def check_name_availability(
self,
location, # type: str
availability_parameters, # type: "_models.NameAvailabilityParameters"
**kwargs # type: Any
):
# type: (...) -> "_models.NameAvailability"
"""Checks that the resource name is valid and is not already in use.
:param location: the region.
:type location: str
:param availability_parameters: Parameters supplied to the operation.
:type availability_parameters: ~azure.mgmt.appplatform.v2020_11_01_preview.models.NameAvailabilityParameters
:keyword callable cls: A custom type or function that will be passed the direct response
:return: NameAvailability, or the result of cls(response)
:rtype: ~azure.mgmt.appplatform.v2020_11_01_preview.models.NameAvailability
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.NameAvailability"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2020-11-01-preview"
content_type = kwargs.pop("content_type", "application/json")
accept = "application/json"
# Construct URL
url = self.check_name_availability.metadata['url'] # type: ignore
path_format_arguments = {
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
'location': self._serialize.url("location", location, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str')
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
body_content_kwargs = {} # type: Dict[str, Any]
body_content = self._serialize.body(availability_parameters, 'NameAvailabilityParameters')
body_content_kwargs['content'] = body_content
request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs)
pipeline_response = self._client._pipeline.run(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('NameAvailability', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
def get(
self,
resource_group_name, # type: str
circuit_name, # type: str
peering_name, # type: str
connection_name, # type: str
**kwargs # type: Any
):
# type: (...) -> "models.ExpressRouteCircuitConnection"
"""Gets the specified Express Route Circuit Connection from the specified express route circuit.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param circuit_name: The name of the express route circuit.
:type circuit_name: str
:param peering_name: The name of the peering.
:type peering_name: str
:param connection_name: The name of the express route circuit connection.
:type connection_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: ExpressRouteCircuitConnection, or the result of cls(response)
:rtype: ~azure.mgmt.network.v2019_09_01.models.ExpressRouteCircuitConnection
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["models.ExpressRouteCircuitConnection"]
error_map = {404: ResourceNotFoundError, 409: ResourceExistsError}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2019-09-01"
# Construct URL
url = self.get.metadata['url'] # type: ignore
path_format_arguments = {
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
'circuitName': self._serialize.url("circuit_name", circuit_name, 'str'),
'peeringName': self._serialize.url("peering_name", peering_name, 'str'),
'connectionName': self._serialize.url("connection_name", connection_name, 'str'),
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = 'application/json'
# Construct and send request
request = self._client.get(url, query_parameters, header_parameters)
pipeline_response = self._client._pipeline.run(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('ExpressRouteCircuitConnection', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
async def create(
self,
resource_group_name: str,
search_service_name: str,
name: str,
search_management_request_options: Optional["_models.SearchManagementRequestOptions"] = None,
**kwargs
) -> "_models.QueryKey":
"""Generates a new query key for the specified search service. You can create up to 50 query keys
per service.
:param resource_group_name: The name of the resource group within the current subscription. You
can obtain this value from the Azure Resource Manager API or the portal.
:type resource_group_name: str
:param search_service_name: The name of the Azure Cognitive Search service associated with the
specified resource group.
:type search_service_name: str
:param name: The name of the new query API key.
:type name: str
:param search_management_request_options: Parameter group.
:type search_management_request_options: ~azure.mgmt.search.models.SearchManagementRequestOptions
:keyword callable cls: A custom type or function that will be passed the direct response
:return: QueryKey, or the result of cls(response)
:rtype: ~azure.mgmt.search.models.QueryKey
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.QueryKey"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
_client_request_id = None
if search_management_request_options is not None:
_client_request_id = search_management_request_options.client_request_id
api_version = "2020-08-01"
accept = "application/json"
# Construct URL
url = self.create.metadata['url'] # type: ignore
path_format_arguments = {
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
'searchServiceName': self._serialize.url("search_service_name", search_service_name, 'str'),
'name': self._serialize.url("name", name, 'str'),
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
if _client_request_id is not None:
header_parameters['x-ms-client-request-id'] = self._serialize.header("client_request_id", _client_request_id, 'str')
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
request = self._client.post(url, query_parameters, header_parameters)
pipeline_response = await self._client._pipeline.run(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('QueryKey', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
def update(self, resource_group_name: str, service_name: str,
quota_counter_key: str,
parameters: "_models.QuotaCounterValueUpdateContract",
**kwargs: Any) -> "_models.QuotaCounterCollection":
"""Updates all the quota counter values specified with the existing quota counter key to a value
in the specified service instance. This should be used for reset of the quota counter values.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param service_name: The name of the API Management service.
:type service_name: str
:param quota_counter_key: Quota counter key identifier.This is the result of expression defined
in counter-key attribute of the quota-by-key policy.For Example, if you specify
counter-key="boo" in the policy, then it’s accessible by "boo" counter key. But if it’s defined
as counter-key="@("b"+"a")" then it will be accessible by "ba" key.
:type quota_counter_key: str
:param parameters: The value of the quota counter to be applied to all quota counter periods.
:type parameters: ~api_management_client.models.QuotaCounterValueUpdateContract
:keyword callable cls: A custom type or function that will be passed the direct response
:return: QuotaCounterCollection, or the result of cls(response)
:rtype: ~api_management_client.models.QuotaCounterCollection
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop(
'cls', None) # type: ClsType["_models.QuotaCounterCollection"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
content_type = kwargs.pop('content_type',
"application/json") # type: Optional[str]
_json = self._serialize.body(parameters,
'QuotaCounterValueUpdateContract')
request = build_update_request(
resource_group_name=resource_group_name,
service_name=service_name,
quota_counter_key=quota_counter_key,
subscription_id=self._config.subscription_id,
content_type=content_type,
json=_json,
template_url=self.update.metadata['url'],
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
pipeline_response = self._client._pipeline.run(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('QuotaCounterCollection',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
def create_or_update(self, resource_group_name: str, workspace_name: str,
sql_pool_name: str, data_masking_rule_name: str,
parameters: "_models.DataMaskingRule",
**kwargs: Any) -> "_models.DataMaskingRule":
"""Creates or updates a Sql pool data masking rule.
:param resource_group_name: The name of the resource group. The name is case insensitive.
:type resource_group_name: str
:param workspace_name: The name of the workspace.
:type workspace_name: str
:param sql_pool_name: SQL pool name.
:type sql_pool_name: str
:param data_masking_rule_name: The name of the data masking rule.
:type data_masking_rule_name: str
:param parameters: The required parameters for creating or updating a data masking rule.
:type parameters: ~azure.mgmt.synapse.models.DataMaskingRule
:keyword callable cls: A custom type or function that will be passed the direct response
:return: DataMaskingRule, or the result of cls(response)
:rtype: ~azure.mgmt.synapse.models.DataMaskingRule
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls',
None) # type: ClsType["_models.DataMaskingRule"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
content_type = kwargs.pop('content_type',
"application/json") # type: Optional[str]
_json = self._serialize.body(parameters, 'DataMaskingRule')
request = build_create_or_update_request(
subscription_id=self._config.subscription_id,
resource_group_name=resource_group_name,
workspace_name=workspace_name,
sql_pool_name=sql_pool_name,
data_masking_rule_name=data_masking_rule_name,
content_type=content_type,
json=_json,
template_url=self.create_or_update.metadata['url'],
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
pipeline_response = self._client._pipeline.run(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)
error = self._deserialize.failsafe_deserialize(
_models.ErrorResponse, pipeline_response)
raise HttpResponseError(response=response,
model=error,
error_format=ARMErrorFormat)
if response.status_code == 200:
deserialized = self._deserialize('DataMaskingRule',
pipeline_response)
if response.status_code == 201:
deserialized = self._deserialize('DataMaskingRule',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
async def get_planner(
self,
user_id: str,
select: Optional[List[Union[str, "models.Enum86"]]] = None,
expand: Optional[List[Union[str, "models.Enum87"]]] = None,
**kwargs
) -> "models.MicrosoftGraphPlannerUser":
"""Get planner from users.
Get planner from users.
:param user_id: key: id of user.
:type user_id: str
:param select: Select properties to be returned.
:type select: list[str or ~planner.models.Enum86]
:param expand: Expand related entities.
:type expand: list[str or ~planner.models.Enum87]
:keyword callable cls: A custom type or function that will be passed the direct response
:return: MicrosoftGraphPlannerUser, or the result of cls(response)
:rtype: ~planner.models.MicrosoftGraphPlannerUser
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["models.MicrosoftGraphPlannerUser"]
error_map = {404: ResourceNotFoundError, 409: ResourceExistsError}
error_map.update(kwargs.pop('error_map', {}))
accept = "application/json"
# Construct URL
url = self.get_planner.metadata['url'] # type: ignore
path_format_arguments = {
'user-id': self._serialize.url("user_id", user_id, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
if select is not None:
query_parameters['$select'] = self._serialize.query("select", select, '[str]', div=',')
if expand is not None:
query_parameters['$expand'] = self._serialize.query("expand", expand, '[str]', div=',')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
header_parameters['Accept'] = 'application/json'
request = self._client.get(url, query_parameters, header_parameters)
pipeline_response = await self._client._pipeline.run(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(models.OdataError, response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
deserialized = self._deserialize('MicrosoftGraphPlannerUser', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
async def get(
self,
resource_group_name: str,
solution_name: str,
iot_recommendation_type_name: str,
**kwargs
) -> "_models.IotRecommendationType":
"""Get IoT recommendation type.
:param resource_group_name: The name of the resource group within the user's subscription. The
name is case insensitive.
:type resource_group_name: str
:param solution_name: The name of the IoT Security solution.
:type solution_name: str
:param iot_recommendation_type_name: Name of the recommendation type.
:type iot_recommendation_type_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: IotRecommendationType, or the result of cls(response)
:rtype: ~azure.mgmt.security.models.IotRecommendationType
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.IotRecommendationType"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2019-08-01"
accept = "application/json"
# Construct URL
url = self.get.metadata['url'] # type: ignore
path_format_arguments = {
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str', pattern=r'^[0-9A-Fa-f]{8}-([0-9A-Fa-f]{4}-){3}[0-9A-Fa-f]{12}$'),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
'solutionName': self._serialize.url("solution_name", solution_name, 'str'),
'iotRecommendationTypeName': self._serialize.url("iot_recommendation_type_name", iot_recommendation_type_name, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
request = self._client.get(url, query_parameters, header_parameters)
pipeline_response = await self._client._pipeline.run(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('IotRecommendationType', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
async def get(self, resource_group_name: str, load_balancer_name: str,
backend_address_pool_name: str,
**kwargs) -> "_models.BackendAddressPool":
"""Gets load balancer backend address pool.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param load_balancer_name: The name of the load balancer.
:type load_balancer_name: str
:param backend_address_pool_name: The name of the backend address pool.
:type backend_address_pool_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: BackendAddressPool, or the result of cls(response)
:rtype: ~azure.mgmt.network.v2018_10_01.models.BackendAddressPool
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls',
None) # type: ClsType["_models.BackendAddressPool"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2018-10-01"
accept = "application/json"
# Construct URL
url = self.get.metadata['url'] # type: ignore
path_format_arguments = {
'resourceGroupName':
self._serialize.url("resource_group_name", resource_group_name,
'str'),
'loadBalancerName':
self._serialize.url("load_balancer_name", load_balancer_name,
'str'),
'backendAddressPoolName':
self._serialize.url("backend_address_pool_name",
backend_address_pool_name, 'str'),
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header(
"accept", accept, 'str')
request = self._client.get(url, query_parameters, header_parameters)
pipeline_response = await self._client._pipeline.run(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('BackendAddressPool',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
async def get(
self,
resource_group_name: str,
job_name: str,
function_name: str,
**kwargs
) -> "models.Function":
"""Gets details about the specified function.
:param resource_group_name: The name of the resource group. The name is case insensitive.
:type resource_group_name: str
:param job_name: The name of the streaming job.
:type job_name: str
:param function_name: The name of the function.
:type function_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: Function, or the result of cls(response)
:rtype: ~stream_analytics_management_client.models.Function
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["models.Function"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2020-03-01"
accept = "application/json"
# Construct URL
url = self.get.metadata['url'] # type: ignore
path_format_arguments = {
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str', min_length=1),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
'jobName': self._serialize.url("job_name", job_name, 'str'),
'functionName': self._serialize.url("function_name", function_name, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
request = self._client.get(url, query_parameters, header_parameters)
pipeline_response = await self._client._pipeline.run(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(models.Error, response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
response_headers = {}
response_headers['ETag']=self._deserialize('str', response.headers.get('ETag'))
deserialized = self._deserialize('Function', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, response_headers)
return deserialized
async def _create_or_update_initial(
self, resource_group_name: str, network_security_group_name: str,
parameters: "_models.NetworkSecurityGroup",
**kwargs: Any) -> "_models.NetworkSecurityGroup":
cls = kwargs.pop('cls',
None) # type: ClsType["_models.NetworkSecurityGroup"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2019-02-01"
content_type = kwargs.pop("content_type", "application/json")
accept = "application/json"
# Construct URL
url = self._create_or_update_initial.metadata['url'] # type: ignore
path_format_arguments = {
'resourceGroupName':
self._serialize.url("resource_group_name", resource_group_name,
'str'),
'networkSecurityGroupName':
self._serialize.url("network_security_group_name",
network_security_group_name, 'str'),
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Content-Type'] = self._serialize.header(
"content_type", content_type, 'str')
header_parameters['Accept'] = self._serialize.header(
"accept", accept, 'str')
body_content_kwargs = {} # type: Dict[str, Any]
body_content = self._serialize.body(parameters, 'NetworkSecurityGroup')
body_content_kwargs['content'] = body_content
request = self._client.put(url, query_parameters, header_parameters,
**body_content_kwargs)
pipeline_response = await self._client._pipeline.run(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('NetworkSecurityGroup',
pipeline_response)
if response.status_code == 201:
deserialized = self._deserialize('NetworkSecurityGroup',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
async def create_by_id(
self,
policy_assignment_id: str,
parameters: "_models.PolicyAssignment",
**kwargs: Any
) -> "_models.PolicyAssignment":
"""Creates or updates a policy assignment.
This operation creates or updates the policy assignment with the given ID. Policy assignments
made on a scope apply to all resources contained in that scope. For example, when you assign a
policy to a resource group that policy applies to all resources in the group. Policy assignment
IDs have this format:
'{scope}/providers/Microsoft.Authorization/policyAssignments/{policyAssignmentName}'. Valid
scopes are: management group (format:
'/providers/Microsoft.Management/managementGroups/{managementGroup}'), subscription (format:
'/subscriptions/{subscriptionId}'), resource group (format:
'/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}', or resource (format:
'/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/[{parentResourcePath}/]{resourceType}/{resourceName}'.
:param policy_assignment_id: The ID of the policy assignment to create. Use the format
'{scope}/providers/Microsoft.Authorization/policyAssignments/{policyAssignmentName}'.
:type policy_assignment_id: str
:param parameters: Parameters for policy assignment.
:type parameters: ~azure.mgmt.resource.policy.v2018_05_01.models.PolicyAssignment
:keyword callable cls: A custom type or function that will be passed the direct response
:return: PolicyAssignment, or the result of cls(response)
:rtype: ~azure.mgmt.resource.policy.v2018_05_01.models.PolicyAssignment
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.PolicyAssignment"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
content_type = kwargs.pop('content_type', "application/json") # type: Optional[str]
_json = self._serialize.body(parameters, 'PolicyAssignment')
request = build_create_by_id_request(
policy_assignment_id=policy_assignment_id,
content_type=content_type,
json=_json,
template_url=self.create_by_id.metadata['url'],
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
pipeline_response = await self._client._pipeline.run(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)
error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
deserialized = self._deserialize('PolicyAssignment', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
