def begin_download_invoice(
self,
billing_account_name, # type: str
invoice_name, # type: str
download_token, # type: str
**kwargs # type: Any
):
# type: (...) -> LROPoller["_models.DownloadUrl"]
"""Gets a URL to download an invoice. The operation is supported for billing accounts with
agreement type Microsoft Partner Agreement or Microsoft Customer Agreement.
:param billing_account_name: The ID that uniquely identifies a billing account.
:type billing_account_name: str
:param invoice_name: The ID that uniquely identifies an invoice.
:type invoice_name: str
:param download_token: Download token with document source and document ID.
:type download_token: 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: Pass in True if you'd like the ARMPolling polling method,
False for no polling, or 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 DownloadUrl or the result of cls(response)
:rtype: ~azure.core.polling.LROPoller[~azure.mgmt.billing.models.DownloadUrl]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["_models.DownloadUrl"]
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._download_invoice_initial(
billing_account_name=billing_account_name,
invoice_name=invoice_name,
download_token=download_token,
cls=lambda x,y,z: x,
**kwargs
)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('DownloadUrl', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
path_format_arguments = {
'billingAccountName': self._serialize.url("billing_account_name", billing_account_name, 'str'),
'invoiceName': self._serialize.url("invoice_name", invoice_name, 'str'),
}
if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'final-state-via': 'location'}, path_format_arguments=path_format_arguments, **kwargs)
elif polling is False: polling_method = 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
)
else:
return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
def begin_delete(
self,
resource_group_name, # type: str
disk_encryption_set_name, # type: str
**kwargs # type: Any
):
# type: (...) -> LROPoller[None]
"""Deletes a disk encryption set.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param disk_encryption_set_name: The name of the disk encryption set that is being created. The
name can't be changed after the disk encryption set is created. Supported characters for the
name are a-z, A-Z, 0-9 and _. The maximum name length is 80 characters.
:type disk_encryption_set_name: 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:
"""
polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType[None]
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(
resource_group_name=resource_group_name,
disk_encryption_set_name=disk_encryption_set_name,
cls=lambda x,y,z: x,
**kwargs
)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
if cls:
return cls(pipeline_response, None, {})
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'),
'diskEncryptionSetName': self._serialize.url("disk_encryption_set_name", disk_encryption_set_name, 'str'),
}
if polling is True: polling_method = ARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs)
elif polling is False: polling_method = 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
)
else:
return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
def begin_create_or_update(
self,
resource_group_name, # type: str
network_security_group_name, # type: str
security_rule_name, # type: str
security_rule_parameters, # type: "models.SecurityRule"
**kwargs # type: Any
):
# type: (...) -> LROPoller["models.SecurityRule"]
"""Creates or updates a security rule in 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 security_rule_name: The name of the security rule.
:type security_rule_name: str
:param security_rule_parameters: Parameters supplied to the create or update network security
rule operation.
:type security_rule_parameters: ~azure.mgmt.network.v2020_03_01.models.SecurityRule
: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: True for ARMPolling, False for no polling, or a
polling object for 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 SecurityRule or the result of cls(response)
:rtype: ~azure.core.polling.LROPoller[~azure.mgmt.network.v2020_03_01.models.SecurityRule]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["models.SecurityRule"]
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(
resource_group_name=resource_group_name,
network_security_group_name=network_security_group_name,
security_rule_name=security_rule_name,
security_rule_parameters=security_rule_parameters,
cls=lambda x,y,z: x,
**kwargs
)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('SecurityRule', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'final-state-via': 'azure-async-operation'}, **kwargs)
elif polling is False: polling_method = 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
)
else:
return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
def begin_update_tags(
self,
resource_group_name, # type: str
network_security_group_name, # type: str
parameters, # type: "_models.TagsObject"
**kwargs # type: Any
):
# type: (...) -> LROPoller["_models.NetworkSecurityGroup"]
"""Updates a network security group tags.
: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 parameters: Parameters supplied to update network security group tags.
:type parameters: ~azure.mgmt.network.v2018_04_01.models.TagsObject
: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 NetworkSecurityGroup or the result of cls(response)
:rtype: ~azure.core.polling.LROPoller[~azure.mgmt.network.v2018_04_01.models.NetworkSecurityGroup]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["_models.NetworkSecurityGroup"]
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._update_tags_initial(
resource_group_name=resource_group_name,
network_security_group_name=network_security_group_name,
parameters=parameters,
cls=lambda x,y,z: x,
**kwargs
)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('NetworkSecurityGroup', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
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'),
}
if polling is True: polling_method = ARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs)
elif polling is False: polling_method = 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
)
else:
return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
def begin_update_tags(
self,
resource_group_name, # type: str
public_ip_prefix_name, # type: str
parameters, # type: "models.TagsObject"
**kwargs # type: Any
):
# type: (...) -> LROPoller["models.PublicIPPrefix"]
"""Updates public IP prefix tags.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param public_ip_prefix_name: The name of the public IP prefix.
:type public_ip_prefix_name: str
:param parameters: Parameters supplied to update public IP prefix tags.
:type parameters: ~azure.mgmt.network.v2019_04_01.models.TagsObject
: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: True for ARMPolling, False for no polling, or a
polling object for 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 PublicIPPrefix or the result of cls(response)
:rtype: ~azure.core.polling.LROPoller[~azure.mgmt.network.v2019_04_01.models.PublicIPPrefix]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["models.PublicIPPrefix"]
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._update_tags_initial(
resource_group_name=resource_group_name,
public_ip_prefix_name=public_ip_prefix_name,
parameters=parameters,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('PublicIPPrefix',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
if polling is True: polling_method = ARMPolling(lro_delay, **kwargs)
elif polling is False: polling_method = 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)
else:
return LROPoller(self._client, raw_result, get_long_running_output,
polling_method)
def begin_delete(
self,
resource_group_name, # type: str
workspace_name, # type: str
**kwargs # type: Any
):
# type: (...) -> LROPoller[Any]
"""Deletes a workspace.
: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
: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 any or the result of cls(response)
:rtype: ~azure.core.polling.LROPoller[any]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType[Any]
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(
resource_group_name=resource_group_name,
workspace_name=workspace_name,
cls=lambda x,y,z: x,
**kwargs
)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('object', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
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),
'workspaceName': self._serialize.url("workspace_name", workspace_name, 'str'),
}
if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'final-state-via': 'location'}, path_format_arguments=path_format_arguments, **kwargs)
elif polling is False: polling_method = 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
)
else:
return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
def begin_delete(
self,
resource_group_name, # type: str
vault_name, # type: str
private_endpoint_connection_name, # type: str
**kwargs # type: Any
):
# type: (...) -> LROPoller["_models.PrivateEndpointConnection"]
"""Deletes the specified private endpoint connection associated with the key vault.
:param resource_group_name: Name of the resource group that contains the key vault.
:type resource_group_name: str
:param vault_name: The name of the key vault.
:type vault_name: str
:param private_endpoint_connection_name: Name of the private endpoint connection associated
with the key vault.
:type private_endpoint_connection_name: 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 PrivateEndpointConnection or the result of cls(response)
:rtype: ~azure.core.polling.LROPoller[~azure.mgmt.keyvault.v2019_09_01.models.PrivateEndpointConnection]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, PollingMethod]
cls = kwargs.pop(
'cls', None) # type: ClsType["_models.PrivateEndpointConnection"]
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(
resource_group_name=resource_group_name,
vault_name=vault_name,
private_endpoint_connection_name=
private_endpoint_connection_name,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('PrivateEndpointConnection',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
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'),
'vaultName':
self._serialize.url("vault_name",
vault_name,
'str',
pattern=r'^[a-zA-Z0-9-]{3,24}$'),
'privateEndpointConnectionName':
self._serialize.url("private_endpoint_connection_name",
private_endpoint_connection_name, 'str'),
}
if polling is True:
polling_method = ARMPolling(
lro_delay,
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return LROPoller(self._client, raw_result, get_long_running_output,
polling_method)
def begin_update(
self,
resource_group_name, # type: str
account_name, # type: str
backup_policy_name, # type: str
body, # type: "_models.BackupPolicyPatch"
**kwargs # type: Any
):
# type: (...) -> LROPoller["_models.BackupPolicy"]
"""Patch a backup policy.
Patch a backup policy for Netapp Account.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param account_name: The name of the NetApp account.
:type account_name: str
:param backup_policy_name: Backup policy Name which uniquely identify backup policy.
:type backup_policy_name: str
:param body: Backup policy object supplied in the body of the operation.
:type body: ~azure.mgmt.netapp.models.BackupPolicyPatch
: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 BackupPolicy or the result of cls(response)
:rtype: ~azure.core.polling.LROPoller[~azure.mgmt.netapp.models.BackupPolicy]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["_models.BackupPolicy"]
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._update_initial(
resource_group_name=resource_group_name,
account_name=account_name,
backup_policy_name=backup_policy_name,
body=body,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('BackupPolicy', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
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',
max_length=90,
min_length=1,
pattern=r'^[-\w\._\(\)]+$'),
'accountName':
self._serialize.url("account_name", account_name, 'str'),
'backupPolicyName':
self._serialize.url("backup_policy_name", backup_policy_name,
'str'),
}
if polling is True:
polling_method = ARMPolling(
lro_delay,
lro_options={'final-state-via': 'azure-async-operation'},
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return LROPoller(self._client, raw_result, get_long_running_output,
polling_method)
def begin_update(self, resource_group_name: str, instance_pool_name: str,
parameters: "_models.InstancePoolUpdate",
**kwargs: Any) -> LROPoller["_models.InstancePool"]:
"""Updates an instance pool.
: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 instance_pool_name: The name of the instance pool to be updated.
:type instance_pool_name: str
:param parameters: The requested instance pool resource state.
:type parameters: ~azure.mgmt.sql.models.InstancePoolUpdate
: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 InstancePool or the result of
cls(response)
:rtype: ~azure.core.polling.LROPoller[~azure.mgmt.sql.models.InstancePool]
:raises: ~azure.core.exceptions.HttpResponseError
"""
content_type = kwargs.pop('content_type',
"application/json") # type: Optional[str]
polling = kwargs.pop(
'polling',
True) # type: Union[bool, azure.core.polling.PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["_models.InstancePool"]
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._update_initial(
resource_group_name=resource_group_name,
instance_pool_name=instance_pool_name,
parameters=parameters,
content_type=content_type,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
def get_long_running_output(pipeline_response):
response = pipeline_response.http_response
deserialized = self._deserialize('InstancePool', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
if polling is True: polling_method = ARMPolling(lro_delay, **kwargs)
elif polling is False: polling_method = 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)
else:
return LROPoller(self._client, raw_result, get_long_running_output,
polling_method)
def begin_grant_access(
self,
resource_group_name, # type: str
snapshot_name, # type: str
grant_access_data, # type: "models.GrantAccessData"
**kwargs # type: Any
):
# type: (...) -> LROPoller["models.AccessUri"]
"""Grants access to a snapshot.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param snapshot_name: The name of the snapshot that is being created. The name can't be changed
after the snapshot is created. Supported characters for the name are a-z, A-Z, 0-9 and _. The
max name length is 80 characters.
:type snapshot_name: str
:param grant_access_data: Access data object supplied in the body of the get snapshot access
operation.
:type grant_access_data: ~azure.mgmt.compute.v2017_03_30.models.GrantAccessData
: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: True for ARMPolling, False for no polling, or a
polling object for 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 AccessUri or the result of cls(response)
:rtype: ~azure.core.polling.LROPoller[~azure.mgmt.compute.v2017_03_30.models.AccessUri]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["models.AccessUri"]
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._grant_access_initial(
resource_group_name=resource_group_name,
snapshot_name=snapshot_name,
grant_access_data=grant_access_data,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('AccessUri', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
if polling is True: polling_method = ARMPolling(lro_delay, **kwargs)
elif polling is False: polling_method = 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)
else:
return LROPoller(self._client, raw_result, get_long_running_output,
polling_method)
def begin_revoke_access(
self,
resource_group_name, # type: str
disk_name, # type: str
**kwargs # type: Any
):
# type: (...) -> LROPoller[None]
"""Revokes access to a disk.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param disk_name: The name of the managed disk that is being created. The name can't be changed
after the disk is created. Supported characters for the name are a-z, A-Z, 0-9 and _. The
maximum name length is 80 characters.
:type disk_name: 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: True for ARMPolling, False for no polling, or a
polling object for 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:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType[None]
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._revoke_access_initial(
resource_group_name=resource_group_name,
disk_name=disk_name,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
if cls:
return cls(pipeline_response, None, {})
if polling is True:
polling_method = ARMPolling(
lro_delay,
lro_options={'final-state-via': 'location'},
**kwargs)
elif polling is False:
polling_method = 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)
else:
return LROPoller(self._client, raw_result, get_long_running_output,
polling_method)
def begin_create_or_update(
self,
resource_group_name, # type: str
gallery_name, # type: str
gallery_application_name, # type: str
gallery_application_version_name, # type: str
gallery_application_version, # type: "_models.GalleryApplicationVersion"
**kwargs # type: Any
):
# type: (...) -> LROPoller["_models.GalleryApplicationVersion"]
"""Create or update a gallery Application Version.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param gallery_name: The name of the Shared Application Gallery in which the Application
Definition resides.
:type gallery_name: str
:param gallery_application_name: The name of the gallery Application Definition in which the
Application Version is to be created.
:type gallery_application_name: str
:param gallery_application_version_name: The name of the gallery Application Version to be
created. Needs to follow semantic version name pattern: The allowed characters are digit and
period. Digits must be within the range of a 32-bit integer. Format:
:code:`<MajorVersion>`.:code:`<MinorVersion>`.:code:`<Patch>`.
:type gallery_application_version_name: str
:param gallery_application_version: Parameters supplied to the create or update gallery
Application Version operation.
:type gallery_application_version: ~azure.mgmt.compute.v2019_12_01.models.GalleryApplicationVersion
: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: True for ARMPolling, False for no polling, or a
polling object for 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 GalleryApplicationVersion or the result of cls(response)
:rtype: ~azure.core.polling.LROPoller[~azure.mgmt.compute.v2019_12_01.models.GalleryApplicationVersion]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, PollingMethod]
cls = kwargs.pop(
'cls', None) # type: ClsType["_models.GalleryApplicationVersion"]
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(
resource_group_name=resource_group_name,
gallery_name=gallery_name,
gallery_application_name=gallery_application_name,
gallery_application_version_name=
gallery_application_version_name,
gallery_application_version=gallery_application_version,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('GalleryApplicationVersion',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
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'),
'galleryName':
self._serialize.url("gallery_name", gallery_name, 'str'),
'galleryApplicationName':
self._serialize.url("gallery_application_name",
gallery_application_name, 'str'),
'galleryApplicationVersionName':
self._serialize.url("gallery_application_version_name",
gallery_application_version_name, 'str'),
}
if polling is True:
polling_method = ARMPolling(
lro_delay,
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return LROPoller(self._client, raw_result, get_long_running_output,
polling_method)
def begin_grant_access(
self,
resource_group_name, # type: str
disk_name, # type: str
grant_access_data, # type: "_models.GrantAccessData"
**kwargs # type: Any
):
# type: (...) -> LROPoller["_models.AccessUri"]
"""Grants access to a disk.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param disk_name: The name of the managed disk that is being created. The name can't be changed
after the disk is created. Supported characters for the name are a-z, A-Z, 0-9 and _. The
maximum name length is 80 characters.
:type disk_name: str
:param grant_access_data: Access data object supplied in the body of the get disk access
operation.
:type grant_access_data: ~azure.mgmt.compute.v2018_06_01.models.GrantAccessData
: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: Pass in True if you'd like the ARMPolling polling method,
False for no polling, or 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 AccessUri or the result of cls(response)
:rtype: ~azure.core.polling.LROPoller[~azure.mgmt.compute.v2018_06_01.models.AccessUri]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["_models.AccessUri"]
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._grant_access_initial(
resource_group_name=resource_group_name,
disk_name=disk_name,
grant_access_data=grant_access_data,
cls=lambda x,y,z: x,
**kwargs
)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('AccessUri', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
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'),
'diskName': self._serialize.url("disk_name", disk_name, 'str'),
}
if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'final-state-via': 'location'}, path_format_arguments=path_format_arguments, **kwargs)
elif polling is False: polling_method = 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
)
else:
return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
def begin_download_multiple_billing_subscription_invoices(
self,
download_urls, # type: List[str]
**kwargs # type: Any
):
# type: (...) -> LROPoller["_models.DownloadUrl"]
"""Gets a URL to download multiple invoice documents (invoice pdf, tax receipts, credit notes) as
a zip file.
:param download_urls: An array of download urls for individual documents.
:type download_urls: list[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: Pass in True if you'd like the ARMPolling polling method,
False for no polling, or 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 DownloadUrl or the result of cls(response)
:rtype: ~azure.core.polling.LROPoller[~azure.mgmt.billing.models.DownloadUrl]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["_models.DownloadUrl"]
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._download_multiple_billing_subscription_invoices_initial(
download_urls=download_urls,
cls=lambda x,y,z: x,
**kwargs
)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('DownloadUrl', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
path_format_arguments = {
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
}
if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'final-state-via': 'location'}, path_format_arguments=path_format_arguments, **kwargs)
elif polling is False: polling_method = 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
)
else:
return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
def begin_list_advertised_routes(
self,
resource_group_name, # type: str
hub_name, # type: str
connection_name, # type: str
**kwargs # type: Any
):
# type: (...) -> LROPoller["_models.PeerRouteList"]
"""Retrieves a list of routes the virtual hub bgp connection is advertising to the specified peer.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param hub_name: The name of the virtual hub.
:type hub_name: str
:param connection_name: The name of the virtual hub bgp connection.
:type connection_name: 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: True for ARMPolling, False for no polling, or a
polling object for 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 PeerRouteList or the result of cls(response)
:rtype: ~azure.core.polling.LROPoller[~azure.mgmt.network.v2020_07_01.models.PeerRouteList]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["_models.PeerRouteList"]
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._list_advertised_routes_initial(
resource_group_name=resource_group_name,
hub_name=hub_name,
connection_name=connection_name,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('PeerRouteList',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
path_format_arguments = {
'resourceGroupName':
self._serialize.url("resource_group_name", resource_group_name,
'str'),
'hubName':
self._serialize.url("hub_name", hub_name, 'str'),
'connectionName':
self._serialize.url("connection_name", connection_name, 'str'),
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
}
if polling is True:
polling_method = ARMPolling(
lro_delay,
lro_options={'final-state-via': 'location'},
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return LROPoller(self._client, raw_result, get_long_running_output,
polling_method)
def begin_create_or_update(
self,
device_name, # type: str
name, # type: str
resource_group_name, # type: str
role, # type: "_models.Role"
**kwargs # type: Any
):
# type: (...) -> LROPoller["_models.Role"]
"""Create or update a role.
:param device_name: The device name.
:type device_name: str
:param name: The role name.
:type name: str
:param resource_group_name: The resource group name.
:type resource_group_name: str
:param role: The role properties.
:type role: ~azure.mgmt.databoxedge.models.Role
: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: True for ARMPolling, False for no polling, or a
polling object for 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 Role or the result of cls(response)
:rtype: ~azure.core.polling.LROPoller[~azure.mgmt.databoxedge.models.Role]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["_models.Role"]
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(
device_name=device_name,
name=name,
resource_group_name=resource_group_name,
role=role,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('Role', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
path_format_arguments = {
'deviceName':
self._serialize.url("device_name", device_name, 'str'),
'name':
self._serialize.url("name", name, 'str'),
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
'resourceGroupName':
self._serialize.url("resource_group_name", resource_group_name,
'str'),
}
if polling is True:
polling_method = ARMPolling(
lro_delay,
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return LROPoller(self._client, raw_result, get_long_running_output,
polling_method)
def begin_create_or_update(
self,
resource_group_name, # type: str
cluster_name, # type: str
database_name, # type: str
principal_assignment_name, # type: str
parameters, # type: "models.DatabasePrincipalAssignment"
**kwargs # type: Any
):
# type: (...) -> LROPoller["models.DatabasePrincipalAssignment"]
"""Creates a Kusto cluster database principalAssignment.
:param resource_group_name: The name of the resource group containing the Kusto cluster.
:type resource_group_name: str
:param cluster_name: The name of the Kusto cluster.
:type cluster_name: str
:param database_name: The name of the database in the Kusto cluster.
:type database_name: str
:param principal_assignment_name: The name of the Kusto principalAssignment.
:type principal_assignment_name: str
:param parameters: The Kusto principalAssignments parameters supplied for the operation.
:type parameters: ~kusto_management_client.models.DatabasePrincipalAssignment
: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: True for ARMPolling, False for no polling, or a
polling object for 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 DatabasePrincipalAssignment or the result of cls(response)
:rtype: ~azure.core.polling.LROPoller[~kusto_management_client.models.DatabasePrincipalAssignment]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, PollingMethod]
cls = kwargs.pop(
'cls', None) # type: ClsType["models.DatabasePrincipalAssignment"]
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(
resource_group_name=resource_group_name,
cluster_name=cluster_name,
database_name=database_name,
principal_assignment_name=principal_assignment_name,
parameters=parameters,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('DatabasePrincipalAssignment',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
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'),
'clusterName':
self._serialize.url("cluster_name", cluster_name, 'str'),
'databaseName':
self._serialize.url("database_name", database_name, 'str'),
'principalAssignmentName':
self._serialize.url("principal_assignment_name",
principal_assignment_name, 'str'),
}
if polling is True:
polling_method = ARMPolling(
lro_delay,
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return LROPoller(self._client, raw_result, get_long_running_output,
polling_method)
def begin_delete(
self,
vault_name, # type: str
resource_group_name, # type: str
policy_name, # type: str
**kwargs # type: Any
):
# type: (...) -> LROPoller[None]
"""Deletes specified backup policy from your Recovery Services Vault. This is an asynchronous
operation. Status of the
operation can be fetched using GetProtectionPolicyOperationResult API.
: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 policy_name: Backup policy to be deleted.
:type policy_name: 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: Pass in True if you'd like the ARMPolling polling method,
False for no polling, or 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:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType[None]
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(
vault_name=vault_name,
resource_group_name=resource_group_name,
policy_name=policy_name,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
if cls:
return cls(pipeline_response, None, {})
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'),
'policyName':
self._serialize.url("policy_name", policy_name, 'str'),
}
if polling is True:
polling_method = ARMPolling(
lro_delay,
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return LROPoller(self._client, raw_result, get_long_running_output,
polling_method)
def begin_create_or_update(
self,
resource_group_name, # type: str
circuit_name, # type: str
peering_name, # type: str
peering_parameters, # type: "_models.ExpressRouteCircuitPeering"
**kwargs # type: Any
):
# type: (...) -> LROPoller["_models.ExpressRouteCircuitPeering"]
"""Creates or updates a peering in the specified express route circuits.
: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 peering_parameters: Parameters supplied to the create or update express route circuit
peering operation.
:type peering_parameters: ~azure.mgmt.network.v2018_04_01.models.ExpressRouteCircuitPeering
: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: True for ARMPolling, False for no polling, or a
polling object for 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 ExpressRouteCircuitPeering or the result of cls(response)
:rtype: ~azure.core.polling.LROPoller[~azure.mgmt.network.v2018_04_01.models.ExpressRouteCircuitPeering]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["_models.ExpressRouteCircuitPeering"]
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(
resource_group_name=resource_group_name,
circuit_name=circuit_name,
peering_name=peering_name,
peering_parameters=peering_parameters,
cls=lambda x,y,z: x,
**kwargs
)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('ExpressRouteCircuitPeering', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
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'),
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
}
if polling is True: polling_method = ARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs)
elif polling is False: polling_method = 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
)
else:
return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
def begin_update(
self,
resource_group_name, # type: str
snapshot_name, # type: str
snapshot, # type: "_models.SnapshotUpdate"
**kwargs # type: Any
):
# type: (...) -> LROPoller["_models.Snapshot"]
"""Updates (patches) a snapshot.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param snapshot_name: The name of the snapshot that is being created. The name can't be changed
after the snapshot is created. Supported characters for the name are a-z, A-Z, 0-9 and _. The
max name length is 80 characters.
:type snapshot_name: str
:param snapshot: Snapshot object supplied in the body of the Patch snapshot operation.
:type snapshot: ~azure.mgmt.compute.v2020_09_30.models.SnapshotUpdate
: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: True for ARMPolling, False for no polling, or a
polling object for 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 Snapshot or the result of cls(response)
:rtype: ~azure.core.polling.LROPoller[~azure.mgmt.compute.v2020_09_30.models.Snapshot]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["_models.Snapshot"]
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._update_initial(
resource_group_name=resource_group_name,
snapshot_name=snapshot_name,
snapshot=snapshot,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('Snapshot', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
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'),
'snapshotName':
self._serialize.url("snapshot_name", snapshot_name, 'str'),
}
if polling is True:
polling_method = ARMPolling(
lro_delay,
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return LROPoller(self._client, raw_result, get_long_running_output,
polling_method)
def begin_create(
self,
resource_group_name, # type: str
virtual_machine_name, # type: str
name, # type: str
body=None, # type: Optional["_models.GuestAgent"]
**kwargs # type: Any
):
# type: (...) -> LROPoller["_models.GuestAgent"]
"""Implements GuestAgent PUT method.
Create Or Update GuestAgent.
:param resource_group_name: The Resource Group Name.
:type resource_group_name: str
:param virtual_machine_name: Name of the vm.
:type virtual_machine_name: str
:param name: Name of the guestAgents.
:type name: str
:param body: Request payload.
:type body: ~azure.mgmt.connectedvmware.models.GuestAgent
: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 GuestAgent or the result of cls(response)
:rtype: ~azure.core.polling.LROPoller[~azure.mgmt.connectedvmware.models.GuestAgent]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["_models.GuestAgent"]
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_initial(
resource_group_name=resource_group_name,
virtual_machine_name=virtual_machine_name,
name=name,
body=body,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('GuestAgent', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
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'),
'virtualMachineName':
self._serialize.url("virtual_machine_name", virtual_machine_name,
'str'),
'name':
self._serialize.url("name", name, 'str'),
}
if polling is True:
polling_method = ARMPolling(
lro_delay,
lro_options={'final-state-via': 'azure-async-operation'},
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return LROPoller(self._client, raw_result, get_long_running_output,
polling_method)
def begin_grant_access(
self,
resource_group_name, # type: str
snapshot_name, # type: str
grant_access_data, # type: "_models.GrantAccessData"
**kwargs # type: Any
):
# type: (...) -> LROPoller["_models.AccessUri"]
"""Grants access to a snapshot.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param snapshot_name: The name of the snapshot within the given subscription and resource
group.
:type snapshot_name: str
:param grant_access_data: Access data object supplied in the body of the get snapshot access
operation.
:type grant_access_data: ~azure.mgmt.compute.v2016_04_30_preview.models.GrantAccessData
: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 AccessUri or the result of cls(response)
:rtype: ~azure.core.polling.LROPoller[~azure.mgmt.compute.v2016_04_30_preview.models.AccessUri]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["_models.AccessUri"]
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._grant_access_initial(
resource_group_name=resource_group_name,
snapshot_name=snapshot_name,
grant_access_data=grant_access_data,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('AccessUri', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
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'),
'snapshotName':
self._serialize.url("snapshot_name", snapshot_name, 'str'),
}
if polling is True:
polling_method = ARMPolling(
lro_delay,
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return LROPoller(self._client, raw_result, get_long_running_output,
polling_method)
def begin_upgrade_node_image_version(
self, resource_group_name: str, resource_name: str,
agent_pool_name: str,
**kwargs: Any) -> LROPoller["_models.AgentPool"]:
"""Upgrade node image version of an agent pool to the latest.
Upgrade node image version of an agent pool to the latest.
: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 agent_pool_name: The name of the agent pool.
:type agent_pool_name: 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 AgentPool or the result of cls(response)
:rtype:
~azure.core.polling.LROPoller[~azure.mgmt.containerservice.v2020_12_01.models.AgentPool]
:raises: ~azure.core.exceptions.HttpResponseError
"""
polling = kwargs.pop(
'polling',
True) # type: Union[bool, azure.core.polling.PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["_models.AgentPool"]
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._upgrade_node_image_version_initial(
resource_group_name=resource_group_name,
resource_name=resource_name,
agent_pool_name=agent_pool_name,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
def get_long_running_output(pipeline_response):
response = pipeline_response.http_response
deserialized = self._deserialize('AgentPool', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
if polling is True: polling_method = ARMPolling(lro_delay, **kwargs)
elif polling is False: polling_method = 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)
else:
return LROPoller(self._client, raw_result, get_long_running_output,
polling_method)
def begin_update(
self,
resource_group_name, # type: str
gallery_name, # type: str
gallery_image_name, # type: str
gallery_image, # type: "_models.GalleryImageUpdate"
**kwargs # type: Any
):
# type: (...) -> LROPoller["_models.GalleryImage"]
"""Update a gallery Image Definition.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param gallery_name: The name of the Shared Image Gallery in which the Image Definition is to
be updated.
:type gallery_name: str
:param gallery_image_name: The name of the gallery Image Definition to be updated. The allowed
characters are alphabets and numbers with dots, dashes, and periods allowed in the middle. The
maximum length is 80 characters.
:type gallery_image_name: str
:param gallery_image: Parameters supplied to the update gallery image operation.
:type gallery_image: ~azure.mgmt.compute.v2019_07_01.models.GalleryImageUpdate
: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: True for ARMPolling, False for no polling, or a
polling object for 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 GalleryImage or the result of cls(response)
:rtype: ~azure.core.polling.LROPoller[~azure.mgmt.compute.v2019_07_01.models.GalleryImage]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["_models.GalleryImage"]
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._update_initial(
resource_group_name=resource_group_name,
gallery_name=gallery_name,
gallery_image_name=gallery_image_name,
gallery_image=gallery_image,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('GalleryImage', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
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'),
'galleryName':
self._serialize.url("gallery_name", gallery_name, 'str'),
'galleryImageName':
self._serialize.url("gallery_image_name", gallery_image_name,
'str'),
}
if polling is True:
polling_method = ARMPolling(
lro_delay,
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return LROPoller(self._client, raw_result, get_long_running_output,
polling_method)
def begin_delete( # pylint: disable=inconsistent-return-statements
self,
resource_group_name: str,
service_name: str,
service_registry_name: str,
**kwargs: Any
) -> LROPoller[None]:
"""Disable the default Service Registry.
: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 service_registry_name: The name of Service Registry.
:type service_registry_name: 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
"""
api_version = kwargs.pop('api_version', "2022-03-01-preview") # type: str
polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType[None]
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(
resource_group_name=resource_group_name,
service_name=service_name,
service_registry_name=service_registry_name,
api_version=api_version,
cls=lambda x,y,z: x,
**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 = ARMPolling(lro_delay, lro_options={'final-state-via': 'azure-async-operation'}, **kwargs)
elif polling is False: polling_method = 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_create(
self,
resource_group_name: str,
restore_point_collection_name: str,
restore_point_name: str,
parameters: "_models.RestorePoint",
**kwargs: Any
) -> LROPoller["_models.RestorePoint"]:
"""The operation to create the restore point. Updating properties of an existing restore point is
not allowed.
: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 restore_point_name: The name of the restore point.
:type restore_point_name: str
:param parameters: Parameters supplied to the Create restore point operation.
:type parameters: ~azure.mgmt.compute.v2021_11_01.models.RestorePoint
: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 RestorePoint or the result of
cls(response)
:rtype: ~azure.core.polling.LROPoller[~azure.mgmt.compute.v2021_11_01.models.RestorePoint]
:raises: ~azure.core.exceptions.HttpResponseError
"""
api_version = kwargs.pop('api_version', "2021-11-01") # type: str
content_type = kwargs.pop('content_type', "application/json") # type: Optional[str]
polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["_models.RestorePoint"]
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_initial(
resource_group_name=resource_group_name,
restore_point_collection_name=restore_point_collection_name,
restore_point_name=restore_point_name,
parameters=parameters,
api_version=api_version,
content_type=content_type,
cls=lambda x,y,z: x,
**kwargs
)
kwargs.pop('error_map', None)
def get_long_running_output(pipeline_response):
response = pipeline_response.http_response
deserialized = self._deserialize('RestorePoint', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
if polling is True: polling_method = ARMPolling(lro_delay, **kwargs)
elif polling is False: polling_method = 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_create_or_update(
self,
resource_group_name, # type: str
ip_allocation_name, # type: str
parameters, # type: "_models.IpAllocation"
**kwargs # type: Any
):
# type: (...) -> LROPoller["_models.IpAllocation"]
"""Creates or updates an IpAllocation in the specified resource group.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param ip_allocation_name: The name of the IpAllocation.
:type ip_allocation_name: str
:param parameters: Parameters supplied to the create or update virtual network operation.
:type parameters: ~azure.mgmt.network.v2020_05_01.models.IpAllocation
: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: Pass in True if you'd like the ARMPolling polling method,
False for no polling, or 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 IpAllocation or the result of cls(response)
:rtype: ~azure.core.polling.LROPoller[~azure.mgmt.network.v2020_05_01.models.IpAllocation]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["_models.IpAllocation"]
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(
resource_group_name=resource_group_name,
ip_allocation_name=ip_allocation_name,
parameters=parameters,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('IpAllocation', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
path_format_arguments = {
'resourceGroupName':
self._serialize.url("resource_group_name", resource_group_name,
'str'),
'ipAllocationName':
self._serialize.url("ip_allocation_name", ip_allocation_name,
'str'),
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
}
if polling is True:
polling_method = ARMPolling(
lro_delay,
lro_options={'final-state-via': 'azure-async-operation'},
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return LROPoller(self._client, raw_result, get_long_running_output,
polling_method)
def begin_create_or_update(
self,
provider_namespace, # type: str
resource_type, # type: str
routing_type, # type: "models.RoutingType"
regionality, # type: "models.Regionality"
endpoints, # type: list["models.ResourceTypeEndpoint"]
resource_creation_begin, # type: "models.ExtensionOptions"
resource_patch_begin, # type: "models.ExtensionOptions"
marketplace_type, # type: "models.ResourceTypeRegistrationPropertiesMarketplaceType"
swagger_specifications, # type: list["models.SwaggerSpecification"]
allowed_unauthorized_actions, # type: list[str]
# type: list["models.AuthorizationActionMapping"]
authorization_action_mappings,
linked_access_checks, # type: list["models.LinkedAccessCheck"]
default_api_version, # type: str
logging_rules, # type: list["models.LoggingRule"]
throttling_rules, # type: list["models.ThrottlingRule"]
required_features, # type: list[str]
enable_async_operation, # type: bool
enable_third_party_s2s, # type: bool
is_pure_proxy, # type: bool
identity_management, # type: "models.IdentityManagementProperties"
# type: "models.CheckNameAvailabilitySpecifications"
check_name_availability_specifications,
disallowed_action_verbs, # type: list[str]
service_tree_infos, # type: list["models.ServiceTreeInfo"]
subscription_state_rules, # type: list["models.SubscriptionStateRule"]
template_deployment_options, # type: "models.TemplateDeploymentOptions"
extended_locations, # type: list["models.ExtendedLocationOptions"]
resource_move_policy, # type: "models.ResourceMovePolicy"
resource_deletion_policy, # type: "models.ResourceDeletionPolicy"
opt_in_headers, # type: "models.OptInHeaderType"
required_features_policy, # type: "models.FeaturesPolicy"
**kwargs # type: Any
):
# type: (...) -> LROPoller["models.ResourceTypeRegistration"]
"""Creates or updates a resource type.
:param provider_namespace: The name of the resource provider hosted within ProviderHub.
:type provider_namespace: str
:param resource_type: The resource type.
:type resource_type: str
:param properties: The resource type registration parameters supplied to the CreateOrUpdate operation.
:type properties: ~providerhub.models.ResourceTypeRegistration
: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: True for ARMPolling, False for no polling, or a
polling object for 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 ResourceTypeRegistration or the result of cls(response)
:rtype: ~azure.core.polling.LROPoller[~providerhub.models.ResourceTypeRegistration]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, PollingMethod]
# type: ClsType["models.ResourceTypeRegistration"]
cls = kwargs.pop('cls', None)
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(
provider_namespace=provider_namespace,
resource_type=resource_type,
routing_type=routing_type,
regionality=regionality,
resource_creation_begin=resource_creation_begin,
resource_patch_begin=resource_patch_begin,
endpoints=endpoints,
marketplace_type=marketplace_type,
swagger_specifications=swagger_specifications,
allowed_unauthorized_actions=allowed_unauthorized_actions,
authorization_action_mappings=authorization_action_mappings,
linked_access_checks=linked_access_checks,
default_api_version=default_api_version,
logging_rules=logging_rules,
throttling_rules=throttling_rules,
required_features=required_features,
enable_async_operation=enable_async_operation,
enable_third_party_s2s=enable_third_party_s2s,
is_pure_proxy=is_pure_proxy,
identity_management=identity_management,
check_name_availability_specifications=
check_name_availability_specifications,
disallowed_action_verbs=disallowed_action_verbs,
service_tree_infos=service_tree_infos,
subscription_state_rules=subscription_state_rules,
template_deployment_options=template_deployment_options,
extended_locations=extended_locations,
resource_move_policy=resource_move_policy,
resource_deletion_policy=resource_deletion_policy,
opt_in_headers=opt_in_headers,
required_features_policy=required_features_policy,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('ResourceTypeRegistration',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
path_format_arguments = {
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id,
'str',
min_length=1),
'providerNamespace':
self._serialize.url("provider_namespace", provider_namespace,
'str'),
'resourceType':
self._serialize.url("resource_type", resource_type, 'str'),
}
if polling is True:
polling_method = ARMPolling(
lro_delay,
lro_options={'final-state-via': 'azure-async-operation'},
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return LROPoller(self._client, raw_result, get_long_running_output,
polling_method)
def begin_delete(
self,
resource_group_name, # type: str
network_security_group_name, # type: str
**kwargs # type: Any
):
# type: (...) -> LROPoller[None]
"""Deletes 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
: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: True for ARMPolling, False for no polling, or a
polling object for 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:
"""
polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType[None]
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(
resource_group_name=resource_group_name,
network_security_group_name=network_security_group_name,
cls=lambda x,y,z: x,
**kwargs
)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
if cls:
return cls(pipeline_response, None, {})
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'),
}
if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'final-state-via': 'location'}, path_format_arguments=path_format_arguments, **kwargs)
elif polling is False: polling_method = 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
)
else:
return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
def begin_export_throttled_requests(
self,
location, # type: str
parameters, # type: "models.LogAnalyticsInputBase"
**kwargs # type: Any
):
# type: (...) -> LROPoller["models.LogAnalyticsOperationResult"]
"""Export logs that show total throttled Api requests for this subscription in the given time
window.
:param location: The location upon which virtual-machine-sizes is queried.
:type location: str
:param parameters: Parameters supplied to the LogAnalytics getThrottledRequests Api.
:type parameters: ~azure.mgmt.compute.v2019_07_01.models.LogAnalyticsInputBase
: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: True for ARMPolling, False for no polling, or a
polling object for 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 LogAnalyticsOperationResult or the result of cls(response)
:rtype: ~azure.core.polling.LROPoller[~azure.mgmt.compute.v2019_07_01.models.LogAnalyticsOperationResult]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling', True) # type: Union[bool, PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["models.LogAnalyticsOperationResult"]
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._export_throttled_requests_initial(
location=location,
parameters=parameters,
cls=lambda x,y,z: x,
**kwargs
)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('LogAnalyticsOperationResult', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'final-state-via': 'azure-async-operation'}, **kwargs)
elif polling is False: polling_method = 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
)
else:
return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
