create_quantum_task async ¶

async def create_quantum_task(
    self,
    client_token: "capo_braket.types.string64.String64",
    device_arn: "capo_braket.types.device_arn.DeviceArn",
    shots: int,
    output_s3_bucket: str,
    output_s3_key_prefix: str,
    action: "capo_braket.types.json_value.JsonValue",
    *,
    config_overrides: Optional[AsyncBraketClientConfig] = None,
    device_parameters: Optional["capo_braket.types.json_value.JsonValue"] = None,
    tags: Optional["capo_braket.types.tags_map.TagsMap"] = None,
    job_token: Optional["capo_braket.types.job_token.JobToken"] = None,
    associations: Optional["capo_braket.types.associations.Associations"] = None,
    experimental_capabilities: Optional[
        "capo_braket.types.experimental_capabilities.ExperimentalCapabilities"
    ] = None,
) -> "capo_braket.types.create_quantum_task_response.CreateQuantumTaskResponse":
    """<p>Creates a quantum task.</p>

    Args:
        client_token: <p>The client token associated with the request.</p>
        device_arn: <p>The ARN of the device to run the quantum task on.</p>
        device_parameters: <p>The parameters for the device to run the quantum task on.</p>
        shots: <p>The number of shots to use for the quantum task.</p>
        output_s3_bucket: <p>The S3 bucket to store quantum task result files in.</p>
        output_s3_key_prefix: <p>The key prefix for the location in the S3 bucket to store quantum task results in.</p>
        action: <p>The action associated with the quantum task.</p>
        tags: <p>Tags to be added to the quantum task you're creating.</p>
        job_token: <p>The token for an Amazon Braket hybrid job that associates it with the quantum task.</p>
        associations: <p>The list of Amazon Braket resources associated with the quantum task.</p>
        experimental_capabilities: <p>Enable experimental capabilities for the quantum task.</p>

    Raises:
        capo_braket.errors.access_denied_exception.AccessDeniedException: <p>You do not have sufficient permissions to perform this action.</p>
        capo_braket.errors.device_offline_exception.DeviceOfflineException: <p>The specified device is currently offline.</p>
        capo_braket.errors.device_retired_exception.DeviceRetiredException: <p>The specified device has been retired.</p>
        capo_braket.errors.internal_service_exception.InternalServiceException: <p>The request failed because of an unknown error.</p>
        capo_braket.errors.service_quota_exceeded_exception.ServiceQuotaExceededException: <p>The request failed because a service quota is exceeded.</p>
        capo_braket.errors.throttling_exception.ThrottlingException: <p>The API throttling rate limit is exceeded.</p>
        capo_braket.errors.validation_exception.ValidationException: <p>The input request failed to satisfy constraints expected by Amazon Braket.</p>
        capo_braket.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_braket.types.create_quantum_task_request.CreateQuantumTaskRequest]",
    ) -> AsyncOperationResponse[
        "capo_braket.types.create_quantum_task_response.CreateQuantumTaskResponse"
    ]:
        import capo_braket._operations.braket.create_quantum_task

        (
            output,
            http_response,
        ) = await capo_braket._operations.braket.create_quantum_task.async_create_quantum_task(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    interceptors_, options_ = self.operation_options(
        config_overrides, OperationLogging("CreateQuantumTask")
    )
    input_: capo_braket.types.create_quantum_task_request.CreateQuantumTaskRequest = {
        "client_token": client_token,
        "device_arn": device_arn,
        "shots": shots,
        "output_s3_bucket": output_s3_bucket,
        "output_s3_key_prefix": output_s3_key_prefix,
        "action": action,
    }
    if device_parameters is not None:
        input_["device_parameters"] = device_parameters
    if tags is not None:
        input_["tags"] = tags
    if job_token is not None:
        input_["job_token"] = job_token
    if associations is not None:
        input_["associations"] = associations
    if experimental_capabilities is not None:
        input_["experimental_capabilities"] = experimental_capabilities

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