def list_available_sizes(
self, resource_group_name: str, availability_set_name: str,
**kwargs) -> AsyncIterable["_models.VirtualMachineSizeListResult"]:
"""Lists all available virtual machine sizes that can be used to create a new virtual machine in
an existing availability set.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param availability_set_name: The name of the availability set.
:type availability_set_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either VirtualMachineSizeListResult or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.compute.v2019_03_01.models.VirtualMachineSizeListResult]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop(
'cls',
None) # type: ClsType["_models.VirtualMachineSizeListResult"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2019-03-01"
accept = "application/json"
def prepare_request(next_link=None):
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header(
"accept", accept, 'str')
if not next_link:
# Construct URL
url = self.list_available_sizes.metadata['url'] # type: ignore
path_format_arguments = {
'resourceGroupName':
self._serialize.url("resource_group_name",
resource_group_name, 'str'),
'availabilitySetName':
self._serialize.url("availability_set_name",
availability_set_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')
request = self._client.get(url, query_parameters,
header_parameters)
else:
url = next_link
query_parameters = {} # type: Dict[str, Any]
request = self._client.get(url, query_parameters,
header_parameters)
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize('VirtualMachineSizeListResult',
pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
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)
return pipeline_response
return AsyncItemPaged(get_next, extract_data)
def list(
self,
location: str,
no_address_prefixes: Optional[bool] = None,
tag_name: Optional[str] = None,
**kwargs: Any
) -> AsyncIterable["_models.ServiceTagInformationListResult"]:
"""Gets a list of service tag information resources with pagination.
:param location: The location that will be used as a reference for cloud (not as a filter based
on location, you will get the list of service tags with prefix details across all regions but
limited to the cloud that your subscription belongs to).
:type location: str
:param no_address_prefixes: Do not return address prefixes for the tag(s).
:type no_address_prefixes: bool
:param tag_name: Return tag information for a particular tag.
:type tag_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either ServiceTagInformationListResult or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.network.v2021_05_01.models.ServiceTagInformationListResult]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.ServiceTagInformationListResult"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2021-05-01"
accept = "application/json"
def prepare_request(next_link=None):
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
if not next_link:
# Construct URL
url = self.list.metadata['url'] # type: ignore
path_format_arguments = {
'location': self._serialize.url("location", location, '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 no_address_prefixes is not None:
query_parameters['noAddressPrefixes'] = self._serialize.query("no_address_prefixes", no_address_prefixes, 'bool')
if tag_name is not None:
query_parameters['tagName'] = self._serialize.query("tag_name", tag_name, 'str')
request = self._client.get(url, query_parameters, header_parameters)
else:
url = next_link
query_parameters = {} # type: Dict[str, Any]
request = self._client.get(url, query_parameters, header_parameters)
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize('ServiceTagInformationListResult', pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(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)
return pipeline_response
return AsyncItemPaged(
get_next, extract_data
)
def list(
self, **kwargs
) -> AsyncIterable["_models.ListVpnServerConfigurationsResult"]:
"""Lists all the VpnServerConfigurations in a subscription.
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either ListVpnServerConfigurationsResult or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.network.v2019_12_01.models.ListVpnServerConfigurationsResult]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop(
'cls',
None) # type: ClsType["_models.ListVpnServerConfigurationsResult"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2019-12-01"
accept = "application/json"
def prepare_request(next_link=None):
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header(
"accept", accept, 'str')
if not next_link:
# Construct URL
url = self.list.metadata['url'] # type: ignore
path_format_arguments = {
'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')
request = self._client.get(url, query_parameters,
header_parameters)
else:
url = next_link
query_parameters = {} # type: Dict[str, Any]
request = self._client.get(url, query_parameters,
header_parameters)
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize(
'ListVpnServerConfigurationsResult', pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(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)
return pipeline_response
return AsyncItemPaged(get_next, extract_data)
def list(self, group_name: str, service_name: str, project_name: str,
**kwargs) -> AsyncIterable["_models.FileList"]:
"""Get files in a project.
The project resource is a nested resource representing a stored migration project. This method
returns a list of files owned by a project resource.
:param group_name: Name of the resource group.
:type group_name: str
:param service_name: Name of the service.
:type service_name: str
:param project_name: Name of the project.
:type project_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either FileList or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.datamigration.models.FileList]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.FileList"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2018-07-15-preview"
accept = "application/json"
def prepare_request(next_link=None):
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header(
"accept", accept, 'str')
if not next_link:
# Construct URL
url = self.list.metadata['url'] # type: ignore
path_format_arguments = {
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
'groupName':
self._serialize.url("group_name", group_name, 'str'),
'serviceName':
self._serialize.url("service_name", service_name, 'str'),
'projectName':
self._serialize.url("project_name", project_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')
request = self._client.get(url, query_parameters,
header_parameters)
else:
url = next_link
query_parameters = {} # type: Dict[str, Any]
request = self._client.get(url, query_parameters,
header_parameters)
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize('FileList', pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(request,
stream=False,
**kwargs)
response = pipeline_response.http_response
if response.status_code not in [200]:
error = self._deserialize(_models.ApiError, response)
map_error(status_code=response.status_code,
response=response,
error_map=error_map)
raise HttpResponseError(response=response,
model=error,
error_format=ARMErrorFormat)
return pipeline_response
return AsyncItemPaged(get_next, extract_data)
def list_by_database(
self, resource_group_name: str, cluster_name: str,
database_name: str,
**kwargs) -> AsyncIterable["models.DataConnectionListResult"]:
"""Returns the list of data connections of the given Kusto database.
: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
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either DataConnectionListResult or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~kusto_management_client.models.DataConnectionListResult]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop(
'cls', None) # type: ClsType["models.DataConnectionListResult"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2021-01-01"
accept = "application/json"
def prepare_request(next_link=None):
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header(
"accept", accept, 'str')
if not next_link:
# Construct URL
url = self.list_by_database.metadata['url'] # type: ignore
path_format_arguments = {
'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'),
'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')
request = self._client.get(url, query_parameters,
header_parameters)
else:
url = next_link
query_parameters = {} # type: Dict[str, Any]
request = self._client.get(url, query_parameters,
header_parameters)
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize('DataConnectionListResult',
pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
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)
return pipeline_response
return AsyncItemPaged(get_next, extract_data)
def list_followed_site(
self,
user_id: str,
orderby: Optional[List[Union[str, "models.Enum229"]]] = None,
select: Optional[List[Union[str, "models.Enum230"]]] = None,
expand: Optional[List[Union[str, "models.Enum231"]]] = None,
**kwargs) -> AsyncIterable["models.CollectionOfSite2"]:
"""Get followedSites from users.
Get followedSites from users.
:param user_id: key: id of user.
:type user_id: str
:param orderby: Order items by property values.
:type orderby: list[str or ~sites.models.Enum229]
:param select: Select properties to be returned.
:type select: list[str or ~sites.models.Enum230]
:param expand: Expand related entities.
:type expand: list[str or ~sites.models.Enum231]
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either CollectionOfSite2 or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~sites.models.CollectionOfSite2]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls',
None) # type: ClsType["models.CollectionOfSite2"]
error_map = {404: ResourceNotFoundError, 409: ResourceExistsError}
error_map.update(kwargs.pop('error_map', {}))
accept = "application/json"
def prepare_request(next_link=None):
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header(
"accept", accept, 'str')
header_parameters['Accept'] = 'application/json'
if not next_link:
# Construct URL
url = self.list_followed_site.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 self._config.top is not None:
query_parameters['$top'] = self._serialize.query(
"self._config.top", self._config.top, 'int', minimum=0)
if self._config.skip is not None:
query_parameters['$skip'] = self._serialize.query(
"self._config.skip",
self._config.skip,
'int',
minimum=0)
if self._config.search is not None:
query_parameters['$search'] = self._serialize.query(
"self._config.search", self._config.search, 'str')
if self._config.filter is not None:
query_parameters['$filter'] = self._serialize.query(
"self._config.filter", self._config.filter, 'str')
if self._config.count is not None:
query_parameters['$count'] = self._serialize.query(
"self._config.count", self._config.count, 'bool')
if orderby is not None:
query_parameters['$orderby'] = self._serialize.query(
"orderby", orderby, '[str]', div=',')
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=',')
request = self._client.get(url, query_parameters,
header_parameters)
else:
url = next_link
query_parameters = {} # type: Dict[str, Any]
request = self._client.get(url, query_parameters,
header_parameters)
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize('CollectionOfSite2',
pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.odata_next_link or None, AsyncList(
list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(request,
stream=False,
**kwargs)
response = pipeline_response.http_response
if response.status_code not in [200]:
error = self._deserialize(models.OdataError, response)
map_error(status_code=response.status_code,
response=response,
error_map=error_map)
raise HttpResponseError(response=response,
model=error,
error_format=ARMErrorFormat)
return pipeline_response
return AsyncItemPaged(get_next, extract_data)
def list(
self,
location: str,
**kwargs: Any
) -> AsyncIterable["_models.VirtualMachineSizeListResult"]:
"""Lists all available virtual machine sizes for a subscription in a location.
:param location: The location upon which virtual-machine-sizes is queried.
:type location: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either VirtualMachineSizeListResult or the result of
cls(response)
:rtype:
~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.compute.v2015_06_15.models.VirtualMachineSizeListResult]
:raises: ~azure.core.exceptions.HttpResponseError
"""
api_version = kwargs.pop('api_version', "2015-06-15") # type: str
cls = kwargs.pop('cls', None) # type: ClsType["_models.VirtualMachineSizeListResult"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
def prepare_request(next_link=None):
if not next_link:
request = build_list_request(
location=location,
subscription_id=self._config.subscription_id,
api_version=api_version,
template_url=self.list.metadata['url'],
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
else:
request = build_list_request(
location=location,
subscription_id=self._config.subscription_id,
api_version=api_version,
template_url=next_link,
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
request.method = "GET"
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize("VirtualMachineSizeListResult", pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access
request,
stream=False,
**kwargs
)
response = pipeline_response.http_response
if response.status_code not in [200]:
map_error(status_code=response.status_code, response=response, error_map=error_map)
raise HttpResponseError(response=response, error_format=ARMErrorFormat)
return pipeline_response
return AsyncItemPaged(
get_next, extract_data
)
def list(self, **kwargs) -> AsyncIterable["models.OperationList"]:
"""Gets a list of possible operations.
Gets a list of possible operations.
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either OperationList or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~workload_monitor_api.models.OperationList]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["models.OperationList"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2020-01-13-preview"
accept = "application/json"
def prepare_request(next_link=None):
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header(
"accept", accept, 'str')
if not next_link:
# Construct URL
url = self.list.metadata['url'] # type: ignore
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
request = self._client.get(url, query_parameters,
header_parameters)
else:
url = next_link
query_parameters = {} # type: Dict[str, Any]
request = self._client.get(url, query_parameters,
header_parameters)
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize('OperationList',
pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(request,
stream=False,
**kwargs)
response = pipeline_response.http_response
if response.status_code not in [200]:
error = self._deserialize(models.DefaultError, response)
map_error(status_code=response.status_code,
response=response,
error_map=error_map)
raise HttpResponseError(response=response,
model=error,
error_format=ARMErrorFormat)
return pipeline_response
return AsyncItemPaged(get_next, extract_data)
def list_by_cache(
self, resource_group_name: str, cache_name: str,
**kwargs: Any) -> AsyncIterable["_models.StorageTargetsResult"]:
"""Returns a list of Storage Targets for the specified Cache.
:param resource_group_name: Target resource group.
:type resource_group_name: str
:param cache_name: Name of Cache. Length of name must not be greater than 80 and chars must be
from the [-0-9a-zA-Z_] char class.
:type cache_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either StorageTargetsResult or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~storage_cache_management_client.models.StorageTargetsResult]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls',
None) # type: ClsType["_models.StorageTargetsResult"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2021-09-01"
accept = "application/json"
def prepare_request(next_link=None):
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header(
"accept", accept, 'str')
if not next_link:
# Construct URL
url = self.list_by_cache.metadata['url'] # type: ignore
path_format_arguments = {
'resourceGroupName':
self._serialize.url("resource_group_name",
resource_group_name, 'str'),
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
'cacheName':
self._serialize.url("cache_name",
cache_name,
'str',
pattern=r'^[-0-9a-zA-Z_]{1,80}$'),
}
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')
request = self._client.get(url, query_parameters,
header_parameters)
else:
url = next_link
query_parameters = {} # type: Dict[str, Any]
request = self._client.get(url, query_parameters,
header_parameters)
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize('StorageTargetsResult',
pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(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)
return pipeline_response
return AsyncItemPaged(get_next, extract_data)
def list_by_gallery_image(
self,
resource_group_name: str,
gallery_name: str,
gallery_image_name: str,
**kwargs: Any
) -> AsyncIterable["_models.GalleryImageVersionList"]:
"""List gallery image versions in 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
resides.
:type gallery_name: str
:param gallery_image_name: The name of the Shared Image Gallery Image Definition from which the
Image Versions are to be listed.
:type gallery_image_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either GalleryImageVersionList or the result of
cls(response)
:rtype:
~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.compute.v2021_10_01.models.GalleryImageVersionList]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.GalleryImageVersionList"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
def prepare_request(next_link=None):
if not next_link:
request = build_list_by_gallery_image_request(
subscription_id=self._config.subscription_id,
resource_group_name=resource_group_name,
gallery_name=gallery_name,
gallery_image_name=gallery_image_name,
template_url=self.list_by_gallery_image.metadata['url'],
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
else:
request = build_list_by_gallery_image_request(
subscription_id=self._config.subscription_id,
resource_group_name=resource_group_name,
gallery_name=gallery_name,
gallery_image_name=gallery_image_name,
template_url=next_link,
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
request.method = "GET"
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize("GalleryImageVersionList", pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(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)
return pipeline_response
return AsyncItemPaged(
get_next, extract_data
)
def list(
self,
resource_group_name: str,
deployment_name: str,
top: Optional[int] = None,
**kwargs
) -> AsyncIterable["models.DeploymentOperationsListResult"]:
"""Gets a list of deployments operations.
:param resource_group_name: The name of the resource group. The name is case insensitive.
:type resource_group_name: str
:param deployment_name: The name of the deployment.
:type deployment_name: str
:param top: Query parameters.
:type top: int
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either DeploymentOperationsListResult or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.resource.resources.v2016_02_01.models.DeploymentOperationsListResult]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop(
'cls',
None) # type: ClsType["models.DeploymentOperationsListResult"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2016-02-01"
accept = "application/json"
def prepare_request(next_link=None):
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header(
"accept", accept, 'str')
if not next_link:
# Construct URL
url = self.list.metadata['url'] # type: ignore
path_format_arguments = {
'resourceGroupName':
self._serialize.url("resource_group_name",
resource_group_name,
'str',
max_length=90,
min_length=1,
pattern=r'^[-\w\._\(\)]+$'),
'deploymentName':
self._serialize.url("deployment_name", deployment_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]
if top is not None:
query_parameters['$top'] = self._serialize.query(
"top", top, 'int')
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
request = self._client.get(url, query_parameters,
header_parameters)
else:
url = next_link
query_parameters = {} # type: Dict[str, Any]
request = self._client.get(url, query_parameters,
header_parameters)
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize('DeploymentOperationsListResult',
pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(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)
return pipeline_response
return AsyncItemPaged(get_next, extract_data)
def list_by_sql_pool(
self,
resource_group_name: str,
workspace_name: str,
sql_pool_name: str,
**kwargs: Any
) -> AsyncIterable["_models.SqlPoolBlobAuditingPolicyListResult"]:
"""Lists auditing settings of a Sql pool.
: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
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either SqlPoolBlobAuditingPolicyListResult or the result
of cls(response)
:rtype:
~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.synapse.models.SqlPoolBlobAuditingPolicyListResult]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.SqlPoolBlobAuditingPolicyListResult"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
def prepare_request(next_link=None):
if not next_link:
request = build_list_by_sql_pool_request(
subscription_id=self._config.subscription_id,
resource_group_name=resource_group_name,
workspace_name=workspace_name,
sql_pool_name=sql_pool_name,
template_url=self.list_by_sql_pool.metadata['url'],
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
else:
request = build_list_by_sql_pool_request(
subscription_id=self._config.subscription_id,
resource_group_name=resource_group_name,
workspace_name=workspace_name,
sql_pool_name=sql_pool_name,
template_url=next_link,
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
request.method = "GET"
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize("SqlPoolBlobAuditingPolicyListResult", pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(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)
return pipeline_response
return AsyncItemPaged(
get_next, extract_data
)
def list(
self, resource_group_name: str, circuit_name: str, peering_name: str,
**kwargs: Any
) -> AsyncIterable["_models.ExpressRouteCircuitConnectionListResult"]:
"""Gets all global reach connections associated with a private peering in an 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 circuit.
:type circuit_name: str
:param peering_name: The name of the peering.
:type peering_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either ExpressRouteCircuitConnectionListResult or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.network.v2020_03_01.models.ExpressRouteCircuitConnectionListResult]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop(
'cls', None
) # type: ClsType["_models.ExpressRouteCircuitConnectionListResult"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2020-03-01"
accept = "application/json"
def prepare_request(next_link=None):
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header(
"accept", accept, 'str')
if not next_link:
# Construct URL
url = self.list.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'),
'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')
request = self._client.get(url, query_parameters,
header_parameters)
else:
url = next_link
query_parameters = {} # type: Dict[str, Any]
request = self._client.get(url, query_parameters,
header_parameters)
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize(
'ExpressRouteCircuitConnectionListResult', pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(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)
return pipeline_response
return AsyncItemPaged(get_next, extract_data)
def get_sql_scripts_by_workspace(
self,
**kwargs: Any) -> AsyncIterable["_models.SqlScriptsListResponse"]:
"""Lists sql scripts.
: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: An iterator like instance of either SqlScriptsListResponse or the result of
cls(response)
:rtype:
~azure.core.async_paging.AsyncItemPaged[~azure.synapse.artifacts.models.SqlScriptsListResponse]
:raises: ~azure.core.exceptions.HttpResponseError
"""
api_version = kwargs.pop('api_version', "2020-12-01") # type: str
cls = kwargs.pop(
'cls', None) # type: ClsType["_models.SqlScriptsListResponse"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
def prepare_request(next_link=None):
if not next_link:
request = build_get_sql_scripts_by_workspace_request(
api_version=api_version,
template_url=self.get_sql_scripts_by_workspace.
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)
else:
request = build_get_sql_scripts_by_workspace_request(
api_version=api_version,
template_url=next_link,
)
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)
path_format_arguments = {
"endpoint":
self._serialize.url("self._config.endpoint",
self._config.endpoint,
'str',
skip_quote=True),
}
request.method = "GET"
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize("SqlScriptsListResponse",
pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(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.CloudErrorAutoGenerated, pipeline_response)
raise HttpResponseError(response=response, model=error)
return pipeline_response
return AsyncItemPaged(get_next, extract_data)
def list_query_results_for_management_group(
self,
management_group_name: str,
query_options: Optional["_models.QueryOptions"] = None,
**kwargs: Any
) -> AsyncIterable["_models.PolicyTrackedResourcesQueryResults"]:
"""Queries policy tracked resources under the management group.
:param management_group_name: Management group name.
:type management_group_name: str
:param query_options: Parameter group.
:type query_options: ~azure.mgmt.policyinsights.models.QueryOptions
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either PolicyTrackedResourcesQueryResults or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.policyinsights.models.PolicyTrackedResourcesQueryResults]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop(
'cls', None
) # type: ClsType["_models.PolicyTrackedResourcesQueryResults"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
_top = None
_filter = None
if query_options is not None:
_top = query_options.top
_filter = query_options.filter
management_groups_namespace = "Microsoft.Management"
policy_tracked_resources_resource = "default"
api_version = "2018-07-01-preview"
accept = "application/json"
def prepare_request(next_link=None):
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header(
"accept", accept, 'str')
if not next_link:
# Construct URL
url = self.list_query_results_for_management_group.metadata[
'url'] # type: ignore
path_format_arguments = {
'managementGroupsNamespace':
self._serialize.url("management_groups_namespace",
management_groups_namespace, 'str'),
'managementGroupName':
self._serialize.url("management_group_name",
management_group_name, 'str'),
'policyTrackedResourcesResource':
self._serialize.url("policy_tracked_resources_resource",
policy_tracked_resources_resource,
'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
if _top is not None:
query_parameters['$top'] = self._serialize.query("top",
_top,
'int',
minimum=0)
if _filter is not None:
query_parameters['$filter'] = self._serialize.query(
"filter", _filter, 'str')
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
request = self._client.post(url, query_parameters,
header_parameters)
else:
url = next_link
query_parameters = {} # type: Dict[str, Any]
request = self._client.get(url, query_parameters,
header_parameters)
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize(
'PolicyTrackedResourcesQueryResults', pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(request,
stream=False,
**kwargs)
response = pipeline_response.http_response
if response.status_code not in [200]:
error = self._deserialize.failsafe_deserialize(
_models.QueryFailure, response)
map_error(status_code=response.status_code,
response=response,
error_map=error_map)
raise HttpResponseError(response=response,
model=error,
error_format=ARMErrorFormat)
return pipeline_response
return AsyncItemPaged(get_next, extract_data)
def list(self,
resource_group_name: str,
account_name: str,
maxpagesize: Optional[str] = None,
filter: Optional[str] = None,
**kwargs) -> AsyncIterable["_models.ListQueueResource"]:
"""Gets a list of all the queues under the specified storage account.
: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 account_name: The name of the storage account within the specified resource group.
Storage account names must be between 3 and 24 characters in length and use numbers and
lower-case letters only.
:type account_name: str
:param maxpagesize: Optional, a maximum number of queues that should be included in a list
queue response.
:type maxpagesize: str
:param filter: Optional, When specified, only the queues with a name starting with the given
filter will be listed.
:type filter: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either ListQueueResource or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.storage.v2020_08_01_preview.models.ListQueueResource]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls',
None) # type: ClsType["_models.ListQueueResource"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2020-08-01-preview"
accept = "application/json"
def prepare_request(next_link=None):
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header(
"accept", accept, 'str')
if not next_link:
# Construct URL
url = self.list.metadata['url'] # type: ignore
path_format_arguments = {
'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',
max_length=24,
min_length=3),
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id,
'str',
min_length=1),
}
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 maxpagesize is not None:
query_parameters['$maxpagesize'] = self._serialize.query(
"maxpagesize", maxpagesize, 'str')
if filter is not None:
query_parameters['$filter'] = self._serialize.query(
"filter", filter, 'str')
request = self._client.get(url, query_parameters,
header_parameters)
else:
url = next_link
query_parameters = {} # type: Dict[str, Any]
request = self._client.get(url, query_parameters,
header_parameters)
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize('ListQueueResource',
pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(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)
return pipeline_response
return AsyncItemPaged(get_next, extract_data)
def list_events(
self,
resource_group_name: str,
registry_name: str,
webhook_name: str,
**kwargs
) -> AsyncIterable["models.EventListResult"]:
"""Lists recent events for the specified webhook.
:param resource_group_name: The name of the resource group to which the container registry
belongs.
:type resource_group_name: str
:param registry_name: The name of the container registry.
:type registry_name: str
:param webhook_name: The name of the webhook.
:type webhook_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either EventListResult or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.containerregistry.v2019_05_01_preview.models.EventListResult]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["models.EventListResult"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2017-10-01"
accept = "application/json"
def prepare_request(next_link=None):
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
if not next_link:
# Construct URL
url = self.list_events.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', min_length=1),
'registryName': self._serialize.url("registry_name", registry_name, 'str', max_length=50, min_length=5, pattern=r'^[a-zA-Z0-9]*$'),
'webhookName': self._serialize.url("webhook_name", webhook_name, 'str', max_length=50, min_length=5, pattern=r'^[a-zA-Z0-9]*$'),
}
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')
request = self._client.post(url, query_parameters, header_parameters)
else:
url = next_link
query_parameters = {} # type: Dict[str, Any]
request = self._client.get(url, query_parameters, header_parameters)
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize('EventListResult', pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(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)
return pipeline_response
return AsyncItemPaged(
get_next, extract_data
)
def list_chat_threads(
self,
max_page_size: Optional[int] = None,
start_time: Optional[datetime.datetime] = None,
**kwargs
) -> AsyncIterable["_models.ChatThreadsItemCollection"]:
"""Gets the list of chat threads of a user.
Gets the list of chat threads of a user.
:param max_page_size: The maximum number of chat threads returned per page.
:type max_page_size: int
:param start_time: The earliest point in time to get chat threads up to. The timestamp should
be in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``.
:type start_time: ~datetime.datetime
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either ChatThreadsItemCollection or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.communication.chat.models.ChatThreadsItemCollection]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatThreadsItemCollection"]
error_map = {
404: ResourceNotFoundError,
409: ResourceExistsError,
401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)),
403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)),
429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)),
503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)),
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2021-03-07"
accept = "application/json"
def prepare_request(next_link=None):
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
if not next_link:
# Construct URL
url = self.list_chat_threads.metadata['url'] # type: ignore
path_format_arguments = {
'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
if max_page_size is not None:
query_parameters['maxPageSize'] = self._serialize.query("max_page_size", max_page_size, 'int')
if start_time is not None:
query_parameters['startTime'] = self._serialize.query("start_time", start_time, 'iso-8601')
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
request = self._client.get(url, query_parameters, header_parameters)
else:
url = next_link
query_parameters = {} # type: Dict[str, Any]
path_format_arguments = {
'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True),
}
url = self._client.format_url(url, **path_format_arguments)
request = self._client.get(url, query_parameters, header_parameters)
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize('ChatThreadsItemCollection', pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(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)
return pipeline_response
return AsyncItemPaged(
get_next, extract_data
)
def list(
self, resource_group_name: str, account_name: str,
**kwargs: Any) -> AsyncIterable["_models.ListBlobInventoryPolicy"]:
"""Gets the blob inventory policy associated with the specified storage account.
: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 account_name: The name of the storage account within the specified resource group.
Storage account names must be between 3 and 24 characters in length and use numbers and
lower-case letters only.
:type account_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either ListBlobInventoryPolicy or the result of
cls(response)
:rtype:
~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.storage.v2021_02_01.models.ListBlobInventoryPolicy]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop(
'cls', None) # type: ClsType["_models.ListBlobInventoryPolicy"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
def prepare_request(next_link=None):
if not next_link:
request = build_list_request(
resource_group_name=resource_group_name,
account_name=account_name,
subscription_id=self._config.subscription_id,
template_url=self.list.metadata['url'],
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
else:
request = build_list_request(
resource_group_name=resource_group_name,
account_name=account_name,
subscription_id=self._config.subscription_id,
template_url=next_link,
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
request.method = "GET"
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize("ListBlobInventoryPolicy",
pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
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.failsafe_deserialize(
_models.ErrorResponse, pipeline_response)
raise HttpResponseError(response=response,
model=error,
error_format=ARMErrorFormat)
return pipeline_response
return AsyncItemPaged(get_next, extract_data)
def list(self,
resource_group_name: str,
network_manager_name: str,
configuration_name: str,
rule_collection_name: str,
top: Optional[int] = None,
skip_token: Optional[str] = None,
**kwargs: Any) -> AsyncIterable["_models.UserRuleListResult"]:
"""Lists all user rules in a rule collection.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param network_manager_name: The name of the network manager.
:type network_manager_name: str
:param configuration_name: The name of the network manager security Configuration.
:type configuration_name: str
:param rule_collection_name: The name of the network manager security Configuration rule
collection.
:type rule_collection_name: str
:param top: An optional query parameter which specifies the maximum number of records to be
returned by the server.
:type top: int
:param skip_token: SkipToken is only used if a previous operation returned a partial result. If
a previous response contains a nextLink element, the value of the nextLink element will include
a skipToken parameter that specifies a starting point to use for subsequent calls.
:type skip_token: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either UserRuleListResult or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.network.v2021_02_01_preview.models.UserRuleListResult]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls',
None) # type: ClsType["_models.UserRuleListResult"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2021-02-01-preview"
accept = "application/json"
def prepare_request(next_link=None):
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header(
"accept", accept, 'str')
if not next_link:
# Construct URL
url = self.list.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'),
'networkManagerName':
self._serialize.url("network_manager_name",
network_manager_name, 'str'),
'configurationName':
self._serialize.url("configuration_name",
configuration_name, 'str'),
'ruleCollectionName':
self._serialize.url("rule_collection_name",
rule_collection_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 top is not None:
query_parameters['$top'] = self._serialize.query(
"top", top, 'int', maximum=20, minimum=1)
if skip_token is not None:
query_parameters['$skipToken'] = self._serialize.query(
"skip_token", skip_token, 'str')
request = self._client.get(url, query_parameters,
header_parameters)
else:
url = next_link
query_parameters = {} # type: Dict[str, Any]
request = self._client.get(url, query_parameters,
header_parameters)
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize('UserRuleListResult',
pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(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)
return pipeline_response
return AsyncItemPaged(get_next, extract_data)
def list_by_resource_group(
self,
resource_group_name: str,
max_page_size: Optional[int] = 50,
skip_token: Optional[str] = None,
**kwargs) -> AsyncIterable["_models.FarmBeatsListResponse"]:
"""Lists the FarmBeats instances for a resource group.
:param resource_group_name: The name of the resource group. The name is case insensitive.
:type resource_group_name: str
:param max_page_size: Maximum number of items needed (inclusive).
Minimum = 10, Maximum = 1000, Default value = 50.
:type max_page_size: int
:param skip_token: Continuation token for getting next set of results.
:type skip_token: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either FarmBeatsListResponse or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~azure_ag_food_platform_rp_service.models.FarmBeatsListResponse]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop(
'cls', None) # type: ClsType["_models.FarmBeatsListResponse"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2020-05-12-preview"
accept = "application/json"
def prepare_request(next_link=None):
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header(
"accept", accept, 'str')
if not next_link:
# Construct URL
url = self.list_by_resource_group.metadata[
'url'] # type: ignore
path_format_arguments = {
'resourceGroupName':
self._serialize.url("resource_group_name",
resource_group_name,
'str',
max_length=90,
min_length=1,
pattern=r'^[-\w\._\(\)]+$'),
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id,
'str',
min_length=1),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
if max_page_size is not None:
query_parameters['$maxPageSize'] = self._serialize.query(
"max_page_size",
max_page_size,
'int',
maximum=1000,
minimum=10)
if skip_token is not None:
query_parameters['$skipToken'] = self._serialize.query(
"skip_token", skip_token, 'str')
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
request = self._client.get(url, query_parameters,
header_parameters)
else:
url = next_link
query_parameters = {} # type: Dict[str, Any]
request = self._client.get(url, query_parameters,
header_parameters)
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize('FarmBeatsListResponse',
pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(request,
stream=False,
**kwargs)
response = pipeline_response.http_response
if response.status_code not in [200]:
error = self._deserialize.failsafe_deserialize(
_models.ErrorResponse, response)
map_error(status_code=response.status_code,
response=response,
error_map=error_map)
raise HttpResponseError(response=response,
model=error,
error_format=ARMErrorFormat)
return pipeline_response
return AsyncItemPaged(get_next, extract_data)
def list(
self, resource_group_name: str, load_balancer_name: str, **kwargs
) -> AsyncIterable["models.LoadBalancerLoadBalancingRuleListResult"]:
"""Gets all the load balancing rules in a load balancer.
: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
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either LoadBalancerLoadBalancingRuleListResult or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.network.v2018_04_01.models.LoadBalancerLoadBalancingRuleListResult]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop(
'cls', None
) # type: ClsType["models.LoadBalancerLoadBalancingRuleListResult"]
error_map = {404: ResourceNotFoundError, 409: ResourceExistsError}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2018-04-01"
def prepare_request(next_link=None):
if not next_link:
# Construct URL
url = self.list.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'),
'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')
else:
url = next_link
query_parameters = {} # type: Dict[str, Any]
# 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)
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize(
'LoadBalancerLoadBalancingRuleListResult', pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(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)
return pipeline_response
return AsyncItemPaged(get_next, extract_data)
def list_by_account(
self,
resource_group_name: str,
account_name: str,
skip_token: Optional[str] = None,
filter: Optional[str] = None,
orderby: Optional[str] = None,
**kwargs
) -> AsyncIterable["_models.ShareList"]:
"""List of available shares under an account.
List shares in an account.
:param resource_group_name: The resource group name.
:type resource_group_name: str
:param account_name: The name of the share account.
:type account_name: str
:param skip_token: Continuation Token.
:type skip_token: str
:param filter: Filters the results using OData syntax.
:type filter: str
:param orderby: Sorts the results using OData syntax.
:type orderby: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either ShareList or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.datashare.models.ShareList]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.ShareList"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2020-09-01"
accept = "application/json"
def prepare_request(next_link=None):
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
if not next_link:
# Construct URL
url = self.list_by_account.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'),
'accountName': self._serialize.url("account_name", account_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 skip_token is not None:
query_parameters['$skipToken'] = self._serialize.query("skip_token", skip_token, 'str')
if filter is not None:
query_parameters['$filter'] = self._serialize.query("filter", filter, 'str')
if orderby is not None:
query_parameters['$orderby'] = self._serialize.query("orderby", orderby, 'str')
request = self._client.get(url, query_parameters, header_parameters)
else:
url = next_link
query_parameters = {} # type: Dict[str, Any]
request = self._client.get(url, query_parameters, header_parameters)
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize('ShareList', pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs)
response = pipeline_response.http_response
if response.status_code not in [200]:
error = self._deserialize.failsafe_deserialize(_models.DataShareError, response)
map_error(status_code=response.status_code, response=response, error_map=error_map)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
return pipeline_response
return AsyncItemPaged(
get_next, extract_data
)
def query_indicators(
self, resource_group_name: str, workspace_name: str,
threat_intelligence_filtering_criteria:
"_models.ThreatIntelligenceFilteringCriteria", **kwargs: Any
) -> AsyncIterable["_models.ThreatIntelligenceInformationList"]:
"""Query threat intelligence indicators as per filtering criteria.
: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 threat_intelligence_filtering_criteria: Filtering criteria for querying threat
intelligence indicators.
:type threat_intelligence_filtering_criteria:
~azure.mgmt.securityinsight.models.ThreatIntelligenceFilteringCriteria
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either ThreatIntelligenceInformationList or the result of
cls(response)
:rtype:
~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.securityinsight.models.ThreatIntelligenceInformationList]
:raises: ~azure.core.exceptions.HttpResponseError
"""
content_type = kwargs.pop('content_type',
"application/json") # type: Optional[str]
cls = kwargs.pop(
'cls',
None) # type: ClsType["_models.ThreatIntelligenceInformationList"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
def prepare_request(next_link=None):
if not next_link:
_json = self._serialize.body(
threat_intelligence_filtering_criteria,
'ThreatIntelligenceFilteringCriteria')
request = build_query_indicators_request(
subscription_id=self._config.subscription_id,
resource_group_name=resource_group_name,
workspace_name=workspace_name,
content_type=content_type,
json=_json,
template_url=self.query_indicators.metadata['url'],
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
else:
_json = self._serialize.body(
threat_intelligence_filtering_criteria,
'ThreatIntelligenceFilteringCriteria')
request = build_query_indicators_request(
subscription_id=self._config.subscription_id,
resource_group_name=resource_group_name,
workspace_name=workspace_name,
content_type=content_type,
json=_json,
template_url=next_link,
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
request.method = "GET"
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize(
"ThreatIntelligenceInformationList", pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(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)
return pipeline_response
return AsyncItemPaged(get_next, extract_data)
def list_by_profile(
self, resource_group_name: str, profile_name: str,
**kwargs: Any) -> AsyncIterable["_models.RuleSetListResult"]:
"""Lists existing AzureFrontDoor rule sets within a profile.
:param resource_group_name: Name of the Resource group within the Azure subscription.
:type resource_group_name: str
:param profile_name: Name of the Azure Front Door Standard or Azure Front Door Premium profile
which is unique within the resource group.
:type profile_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either RuleSetListResult or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.cdn.models.RuleSetListResult]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls',
None) # type: ClsType["_models.RuleSetListResult"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
def prepare_request(next_link=None):
if not next_link:
request = build_list_by_profile_request(
resource_group_name=resource_group_name,
profile_name=profile_name,
subscription_id=self._config.subscription_id,
template_url=self.list_by_profile.metadata['url'],
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
else:
request = build_list_by_profile_request(
resource_group_name=resource_group_name,
profile_name=profile_name,
subscription_id=self._config.subscription_id,
template_url=next_link,
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
request.method = "GET"
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize("RuleSetListResult",
pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(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.AfdErrorResponse, pipeline_response)
raise HttpResponseError(response=response,
model=error,
error_format=ARMErrorFormat)
return pipeline_response
return AsyncItemPaged(get_next, extract_data)
def list_by_automation_account(
self,
resource_group_name: str,
automation_account_name: str,
filter: Optional[str] = None,
skip: Optional[int] = None,
top: Optional[int] = None,
inlinecount: Optional[str] = None,
**kwargs) -> AsyncIterable["_models.DscConfigurationListResult"]:
"""Retrieve a list of configurations.
:param resource_group_name: Name of an Azure Resource group.
:type resource_group_name: str
:param automation_account_name: The name of the automation account.
:type automation_account_name: str
:param filter: The filter to apply on the operation.
:type filter: str
:param skip: The number of rows to skip.
:type skip: int
:param top: The number of rows to take.
:type top: int
:param inlinecount: Return total rows.
:type inlinecount: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either DscConfigurationListResult or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.automation.models.DscConfigurationListResult]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop(
'cls', None) # type: ClsType["_models.DscConfigurationListResult"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2019-06-01"
accept = "application/json"
def prepare_request(next_link=None):
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header(
"accept", accept, 'str')
if not next_link:
# Construct URL
url = self.list_by_automation_account.metadata[
'url'] # type: ignore
path_format_arguments = {
'resourceGroupName':
self._serialize.url("resource_group_name",
resource_group_name,
'str',
max_length=90,
min_length=1,
pattern=r'^[-\w\._]+$'),
'automationAccountName':
self._serialize.url("automation_account_name",
automation_account_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 filter is not None:
query_parameters['$filter'] = self._serialize.query(
"filter", filter, 'str')
if skip is not None:
query_parameters['$skip'] = self._serialize.query(
"skip", skip, 'int')
if top is not None:
query_parameters['$top'] = self._serialize.query(
"top", top, 'int')
if inlinecount is not None:
query_parameters['$inlinecount'] = self._serialize.query(
"inlinecount", inlinecount, 'str')
request = self._client.get(url, query_parameters,
header_parameters)
else:
url = next_link
query_parameters = {} # type: Dict[str, Any]
request = self._client.get(url, query_parameters,
header_parameters)
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize('DscConfigurationListResult',
pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(request,
stream=False,
**kwargs)
response = pipeline_response.http_response
if response.status_code not in [200]:
error = self._deserialize(_models.ErrorResponse, response)
map_error(status_code=response.status_code,
response=response,
error_map=error_map)
raise HttpResponseError(response=response,
model=error,
error_format=ARMErrorFormat)
return pipeline_response
return AsyncItemPaged(get_next, extract_data)
def list(self, resource_group_name: str, registry_name: str,
**kwargs: Any) -> AsyncIterable["_models.PipelineRunListResult"]:
"""Lists all the pipeline runs for the specified container registry.
:param resource_group_name: The name of the resource group to which the container registry
belongs.
:type resource_group_name: str
:param registry_name: The name of the container registry.
:type registry_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either PipelineRunListResult or the result of
cls(response)
:rtype:
~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.containerregistry.v2019_12_01_preview.models.PipelineRunListResult]
:raises: ~azure.core.exceptions.HttpResponseError
"""
api_version = kwargs.pop('api_version',
"2019-12-01-preview") # type: str
cls = kwargs.pop(
'cls', None) # type: ClsType["_models.PipelineRunListResult"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
def prepare_request(next_link=None):
if not next_link:
request = build_list_request(
subscription_id=self._config.subscription_id,
resource_group_name=resource_group_name,
registry_name=registry_name,
api_version=api_version,
template_url=self.list.metadata['url'],
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
else:
request = build_list_request(
subscription_id=self._config.subscription_id,
resource_group_name=resource_group_name,
registry_name=registry_name,
api_version=api_version,
template_url=next_link,
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
request.method = "GET"
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize("PipelineRunListResult",
pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access
request,
stream=False,
**kwargs)
response = pipeline_response.http_response
if response.status_code not in [200]:
map_error(status_code=response.status_code,
response=response,
error_map=error_map)
raise HttpResponseError(response=response,
error_format=ARMErrorFormat)
return pipeline_response
return AsyncItemPaged(get_next, extract_data)
def list_by_resource_group(
self,
resource_group_name: str,
**kwargs: Any
) -> AsyncIterable["_models.ResourcePoolsList"]:
"""Implements GET resourcePools in a resource group.
List of resourcePools in a resource group.
:param resource_group_name: The Resource Group Name.
:type resource_group_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either ResourcePoolsList or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.connectedvmware.models.ResourcePoolsList]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.ResourcePoolsList"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2020-10-01-preview"
accept = "application/json"
def prepare_request(next_link=None):
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
if not next_link:
# Construct URL
url = self.list_by_resource_group.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'),
}
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')
request = self._client.get(url, query_parameters, header_parameters)
else:
url = next_link
query_parameters = {} # type: Dict[str, Any]
request = self._client.get(url, query_parameters, header_parameters)
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize('ResourcePoolsList', pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs)
response = pipeline_response.http_response
if response.status_code not in [200]:
error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, response)
map_error(status_code=response.status_code, response=response, error_map=error_map)
raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
return pipeline_response
return AsyncItemPaged(
get_next, extract_data
)
def list(self,
top: Optional[int] = None,
**kwargs) -> AsyncIterable["models.ResourceListResult"]:
"""The List operation gets information about the vaults associated with the subscription.
:param top: Maximum number of results to return.
:type top: int
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either ResourceListResult or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.keyvault.v2016_10_01.models.ResourceListResult]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls',
None) # type: ClsType["models.ResourceListResult"]
error_map = {404: ResourceNotFoundError, 409: ResourceExistsError}
error_map.update(kwargs.pop('error_map', {}))
filter = "resourceType eq 'Microsoft.KeyVault/vaults'"
api_version = "2015-11-01"
def prepare_request(next_link=None):
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = 'application/json'
if not next_link:
# Construct URL
url = self.list.metadata['url'] # type: ignore
path_format_arguments = {
'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['$filter'] = self._serialize.query(
"filter", filter, 'str')
if top is not None:
query_parameters['$top'] = self._serialize.query(
"top", top, 'int')
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
request = self._client.get(url, query_parameters,
header_parameters)
else:
url = next_link
query_parameters = {} # type: Dict[str, Any]
request = self._client.get(url, query_parameters,
header_parameters)
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize('ResourceListResult',
pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(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)
return pipeline_response
return AsyncItemPaged(get_next, extract_data)
def list_by_virtual_machine(
self,
resource_group_name: str,
vm_name: str,
expand: Optional[str] = None,
**kwargs: Any
) -> AsyncIterable["_models.VirtualMachineRunCommandsListResult"]:
"""The operation to get all run commands of a Virtual Machine.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param vm_name: The name of the virtual machine containing the run command.
:type vm_name: str
:param expand: The expand expression to apply on the operation. Default value is None.
:type expand: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either VirtualMachineRunCommandsListResult or the result
of cls(response)
:rtype:
~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.compute.v2020_06_01.models.VirtualMachineRunCommandsListResult]
:raises: ~azure.core.exceptions.HttpResponseError
"""
api_version = kwargs.pop('api_version', "2020-06-01") # type: str
cls = kwargs.pop(
'cls', None
) # type: ClsType["_models.VirtualMachineRunCommandsListResult"]
error_map = {
401: ClientAuthenticationError,
404: ResourceNotFoundError,
409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
def prepare_request(next_link=None):
if not next_link:
request = build_list_by_virtual_machine_request(
resource_group_name=resource_group_name,
vm_name=vm_name,
subscription_id=self._config.subscription_id,
api_version=api_version,
expand=expand,
template_url=self.list_by_virtual_machine.metadata['url'],
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
else:
request = build_list_by_virtual_machine_request(
resource_group_name=resource_group_name,
vm_name=vm_name,
subscription_id=self._config.subscription_id,
api_version=api_version,
expand=expand,
template_url=next_link,
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
request.method = "GET"
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize(
"VirtualMachineRunCommandsListResult", pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run( # pylint: disable=protected-access
request,
stream=False,
**kwargs)
response = pipeline_response.http_response
if response.status_code not in [200]:
map_error(status_code=response.status_code,
response=response,
error_map=error_map)
raise HttpResponseError(response=response,
error_format=ARMErrorFormat)
return pipeline_response
return AsyncItemPaged(get_next, extract_data)
