list_images async ¶

async def list_images(
    self,
    *,
    config_overrides: Optional[AsyncimagebuilderClientConfig] = None,
    owner: Optional["capo_imagebuilder.types.ownership.Ownership"] = None,
    filters: Optional["capo_imagebuilder.types.filter_list.FilterList"] = None,
    by_name: Optional["capo_imagebuilder.types.boolean.Boolean"] = None,
    max_results: Optional[
        "capo_imagebuilder.types.restricted_integer.RestrictedInteger"
    ] = None,
    next_token: Optional[
        "capo_imagebuilder.types.pagination_token.PaginationToken"
    ] = None,
    include_deprecated: Optional[
        "capo_imagebuilder.types.nullable_boolean.NullableBoolean"
    ] = None,
) -> "capo_imagebuilder.types.list_images_response.ListImagesResponse":
    """<p>Returns the list of images that you have access to.</p>

    Args:
        owner: <p>Filters the list to images owned by you, by Amazon, or shared with you by other accounts. By default, only your account's images are returned.</p>
        filters: <p>Use the following filters to streamline results:</p> <ul> <li> <p> <code>name</code> </p> </li> <li> <p> <code>osVersion</code> </p> </li> <li> <p> <code>platform</code> </p> </li> <li> <p> <code>type</code> </p> </li> <li> <p> <code>version</code> </p> </li> </ul>
        by_name: <p>Specifies whether to return one entry per image name, with all versions of each image aggregated. Defaults to <code>false</code>, which returns one entry per image version. You can't combine this option with the <code>version</code> filter.</p>
        max_results: <p>The maximum number of items to return in a single request.</p>
        next_token: <p>A token to specify where to start paginating. Use the <code>nextToken</code> value from a previously truncated response.</p>
        include_deprecated: <p>Specifies whether to include deprecated Amazon-managed images in the results. Deprecated images that you own are always returned. Defaults to <code>false</code>.</p>

    Raises:
        capo_imagebuilder.errors.call_rate_limit_exceeded_exception.CallRateLimitExceededException: <p>You have exceeded the permitted request rate for the Amazon EC2 APIs that Image Builder calls on your behalf. Retry with an increasing or variable delay between requests.</p>
        capo_imagebuilder.errors.client_exception.ClientException: <p>A generic client error. This error usually indicates that the request failed a validation check, such as when a downstream service rejects a configured value.</p>
        capo_imagebuilder.errors.forbidden_exception.ForbiddenException: <p>You are not authorized to perform the requested operation.</p>
        capo_imagebuilder.errors.invalid_pagination_token_exception.InvalidPaginationTokenException: <p>You have provided an invalid pagination token in your request.</p>
        capo_imagebuilder.errors.invalid_request_exception.InvalidRequestException: <p>The request is malformed or otherwise invalid. Verify the request and try again.</p>
        capo_imagebuilder.errors.service_exception.ServiceException: <p>An internal server error occurred while Image Builder processed the request. Retrying the request may succeed.</p>
        capo_imagebuilder.errors.service_unavailable_exception.ServiceUnavailableException: <p>The service is unable to process your request at this time.</p>
        capo_imagebuilder.errors.UnknownServiceError: The service returned an error code this client does not model.

    Examples:
        List images that you own
        The following example lists the image versions that you own. Setting byName to false returns each image version as its own entry, instead of grouping build versions under their image name.

        >>> await client.list_images(owner='Self', by_name=False)
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_imagebuilder.types.list_images_request.ListImagesRequest]",
    ) -> AsyncOperationResponse[
        "capo_imagebuilder.types.list_images_response.ListImagesResponse"
    ]:
        import capo_imagebuilder._operations.imagebuilder.list_images

        (
            output,
            http_response,
        ) = await capo_imagebuilder._operations.imagebuilder.list_images.async_list_images(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    interceptors_, options_ = self.operation_options(
        config_overrides, OperationLogging("ListImages")
    )
    input_: capo_imagebuilder.types.list_images_request.ListImagesRequest = {}
    if owner is not None:
        input_["owner"] = owner
    if filters is not None:
        input_["filters"] = filters
    if by_name is not None:
        input_["by_name"] = by_name
    if max_results is not None:
        input_["max_results"] = max_results
    if next_token is not None:
        input_["next_token"] = next_token
    if include_deprecated is not None:
        input_["include_deprecated"] = include_deprecated

    response = await aexecute_pipeline(
        AsyncOperationRequest(input=input_, options=options_),
        handler=_handler,
        interceptors=list(interceptors_),
    )
    await response.response.aclose()
    return response.output