describe_applications async ¶

async def describe_applications(
    self,
    *,
    config_overrides: Optional[AsyncWorkSpacesClientConfig] = None,
    application_ids: Optional[
        "capo_workspaces.types.work_space_application_id_list.WorkSpaceApplicationIdList"
    ] = None,
    compute_type_names: Optional[
        "capo_workspaces.types.compute_list.ComputeList"
    ] = None,
    license_type: Optional[
        "capo_workspaces.types.work_space_application_license_type.WorkSpaceApplicationLicenseType"
    ] = None,
    operating_system_names: Optional[
        "capo_workspaces.types.operating_system_name_list.OperatingSystemNameList"
    ] = None,
    owner: Optional[
        "capo_workspaces.types.work_space_application_owner.WorkSpaceApplicationOwner"
    ] = None,
    max_results: Optional["capo_workspaces.types.limit.Limit"] = None,
    next_token: Optional[
        "capo_workspaces.types.pagination_token.PaginationToken"
    ] = None,
) -> (
    "capo_workspaces.types.describe_applications_result.DescribeApplicationsResult"
):
    """<p>Describes the specified applications by filtering based on their compute types, license availability, operating systems, and owners.</p>

    Args:
        application_ids: <p>The identifiers of one or more applications.</p>
        compute_type_names: <p>The compute types supported by the applications.</p>
        license_type: <p>The license availability for the applications.</p>
        operating_system_names: <p>The operating systems supported by the applications.</p>
        owner: <p>The owner of the applications.</p>
        max_results: <p>The maximum number of applications to return.</p>
        next_token: <p>If you received a <code>NextToken</code> from a previous call that was paginated, provide this token to receive the next set of results.</p>

    Raises:
        capo_workspaces.errors.access_denied_exception.AccessDeniedException: <p>The user is not authorized to access a resource.</p>
        capo_workspaces.errors.invalid_parameter_values_exception.InvalidParameterValuesException: <p>One or more parameter values are not valid.</p>
        capo_workspaces.errors.operation_not_supported_exception.OperationNotSupportedException: <p>This operation is not supported.</p>
        capo_workspaces.errors.resource_not_found_exception.ResourceNotFoundException: <p>The resource could not be found.</p>
        capo_workspaces.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_workspaces.types.describe_applications_request.DescribeApplicationsRequest]",
    ) -> AsyncOperationResponse[
        "capo_workspaces.types.describe_applications_result.DescribeApplicationsResult"
    ]:
        import capo_workspaces._operations.workspaces_service.describe_applications

        (
            output,
            http_response,
        ) = await capo_workspaces._operations.workspaces_service.describe_applications.async_describe_applications(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    interceptors_, options_ = self.operation_options(
        config_overrides, OperationLogging("DescribeApplications")
    )
    input_: capo_workspaces.types.describe_applications_request.DescribeApplicationsRequest = {}
    if application_ids is not None:
        input_["application_ids"] = application_ids
    if compute_type_names is not None:
        input_["compute_type_names"] = compute_type_names
    if license_type is not None:
        input_["license_type"] = license_type
    if operating_system_names is not None:
        input_["operating_system_names"] = operating_system_names
    if owner is not None:
        input_["owner"] = owner
    if max_results is not None:
        input_["max_results"] = max_results
    if next_token is not None:
        input_["next_token"] = next_token

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