def METHOD_NAME(
    self,
    resource_group_name: str,
    account_name: str,
    region: str,
    database_rid: str,
    collection_rid: str,
    partition_key_range_id: str,
    filter: str,
    **kwargs: Any
) -> AsyncIterable["_models.PartitionMetric"]:
    """Retrieves the metrics determined by the given filter for the given partition key range id and
    region.
    :param resource_group_name: The name of the resource group. The name is case insensitive.
     Required.
    :type resource_group_name: str
    :param account_name: Cosmos DB database account name. Required.
    :type account_name: str
    :param region: Cosmos DB region, with spaces between words and each word capitalized. Required.
    :type region: str
    :param database_rid: Cosmos DB database rid. Required.
    :type database_rid: str
    :param collection_rid: Cosmos DB collection rid. Required.
    :type collection_rid: str
    :param partition_key_range_id: Partition Key Range Id for which to get data. Required.
    :type partition_key_range_id: str
    :param filter: An OData filter expression that describes a subset of metrics to return. The
     parameters that can be filtered are name.value (name of the metric, can have an or of multiple
     names), startTime, endTime, and timeGrain. The supported operator is eq. Required.
    :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 PartitionMetric or the result of cls(response)
    :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.cosmosdb.models.PartitionMetric]
    :raises ~azure.core.exceptions.HttpResponseError:
    """
    _headers = kwargs.pop("headers", {}) or {}
    _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
    api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
    cls: ClsType[_models.PartitionMetricListResult] = kwargs.pop("cls", None)
    error_map = {
        401: ClientAuthenticationError,
        404: ResourceNotFoundError,
        409: ResourceExistsError,
        304: ResourceNotModifiedError,
    }
    error_map.update(kwargs.pop("error_map", {}) or {})
    def prepare_request(next_link=None):
        if not next_link:
            request = build_list_metrics_request(
                resource_group_name=resource_group_name,
                account_name=account_name,
                region=region,
                database_rid=database_rid,
                collection_rid=collection_rid,
                partition_key_range_id=partition_key_range_id,
                subscription_id=self._config.subscription_id,
                filter=filter,
                api_version=api_version,
                template_url=self.METHOD_NAME.metadata["url"],
                headers=_headers,
                params=_params,
            )
            request = _convert_request(request)
            request.url = self._client.format_url(request.url)
        else:
            # make call to next link with the client's api-version
            _parsed_next_link = urllib.parse.urlparse(next_link)
            _next_request_params = case_insensitive_dict(
                {
                    key: [urllib.parse.quote(v) for v in value]
                    for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items()
                }
            )
            _next_request_params["api-version"] = self._config.api_version
            request = HttpRequest(
                "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
            )
            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("PartitionMetricListResult", pipeline_response)
        list_of_elem = deserialized.value
        if cls:
            list_of_elem = cls(list_of_elem)  # type: ignore
        return None, AsyncList(list_of_elem)
    async def get_next(next_link=None):
        request = prepare_request(next_link)
        _stream = False
        pipeline_response: PipelineResponse = await self._client._pipeline.run(  # pylint: disable=protected-access
            request, stream=_stream, **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)