create_device_pool `async` ¶

create_device_pool(
    project_arn: AmazonResourceName,
    name: Name,
    rules: Rules,
    *,
    config_overrides: Optional[AsyncDeviceFarmClientConfig] = None,
    description: Optional[Message] = None,
    max_devices: Optional[Integer] = None,
) -> CreateDevicePoolResult

Creates a device pool.

Parameters:

project_arn (AmazonResourceName) –

The ARN of the project for the device pool.
name (Name) –

The device pool's name.
description (Optional[Message], default: None ) –

The device pool's description.
rules (Rules) –

The device pool's rules.
max_devices (Optional[Integer], default: None ) –

The number of devices that Device Farm can add to your device pool. Device Farm adds devices that are available and meet the criteria that you assign for the rules parameter. Depending on how many devices meet these constraints, your device pool might contain fewer devices than the value for this parameter.

By specifying the maximum number of devices, you can control the costs that you incur by running tests.

Raises:

ArgumentException –

An invalid argument was specified.
LimitExceededException –

A limit was exceeded.
NotFoundException –

The specified entity was not found.
ServiceAccountException –

There was a problem with the service account.
UnknownServiceError –

The service returned an error code this client does not model.

Examples:

To create a new device pool The following example creates a new device pool named MyDevicePool inside an existing project.

>>> await client.create_device_pool(project_arn='arn:aws:devicefarm:us-west-2:123456789101:project:EXAMPLE-GUID-123-456', name='MyDevicePool', description='My Android devices', rules=[])

Source code in docs_src/capo_device_farm/_services/async_device_farm.py

async def create_device_pool(
    self,
    project_arn: "capo_device_farm.types.amazon_resource_name.AmazonResourceName",
    name: "capo_device_farm.types.name.Name",
    rules: "capo_device_farm.types.rules.Rules",
    *,
    config_overrides: Optional[AsyncDeviceFarmClientConfig] = None,
    description: Optional["capo_device_farm.types.message.Message"] = None,
    max_devices: Optional["capo_device_farm.types.integer.Integer"] = None,
) -> "capo_device_farm.types.create_device_pool_result.CreateDevicePoolResult":
    """<p>Creates a device pool.</p>

    Args:
        project_arn: <p>The ARN of the project for the device pool.</p>
        name: <p>The device pool's name.</p>
        description: <p>The device pool's description.</p>
        rules: <p>The device pool's rules.</p>
        max_devices: <p>The number of devices that Device Farm can add to your device pool. Device Farm adds devices that are available and meet the criteria that you assign for the <code>rules</code> parameter. Depending on how many devices meet these constraints, your device pool might contain fewer devices than the value for this parameter.</p> <p>By specifying the maximum number of devices, you can control the costs that you incur by running tests.</p>

    Raises:
        capo_device_farm.errors.argument_exception.ArgumentException: <p>An invalid argument was specified.</p>
        capo_device_farm.errors.limit_exceeded_exception.LimitExceededException: <p>A limit was exceeded.</p>
        capo_device_farm.errors.not_found_exception.NotFoundException: <p>The specified entity was not found.</p>
        capo_device_farm.errors.service_account_exception.ServiceAccountException: <p>There was a problem with the service account.</p>
        capo_device_farm.errors.UnknownServiceError: The service returned an error code this client does not model.

    Examples:
        To create a new device pool
        The following example creates a new device pool named MyDevicePool inside an existing project.

        >>> await client.create_device_pool(project_arn='arn:aws:devicefarm:us-west-2:123456789101:project:EXAMPLE-GUID-123-456', name='MyDevicePool', description='My Android devices', rules=[])
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_device_farm.types.create_device_pool_request.CreateDevicePoolRequest]",
    ) -> AsyncOperationResponse[
        "capo_device_farm.types.create_device_pool_result.CreateDevicePoolResult"
    ]:
        import capo_device_farm._operations.device_farm_20150623.create_device_pool

        (
            output,
            http_response,
        ) = await capo_device_farm._operations.device_farm_20150623.create_device_pool.async_create_device_pool(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    interceptors_, options_ = self.operation_options(
        config_overrides, OperationLogging("CreateDevicePool")
    )
    input_: capo_device_farm.types.create_device_pool_request.CreateDevicePoolRequest = {
        "project_arn": project_arn,
        "name": name,
        "rules": rules,
    }
    if description is not None:
        input_["description"] = description
    if max_devices is not None:
        input_["max_devices"] = max_devices

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

create_device_pool async ¶

create_device_pool `async` ¶