def cancel(self, handle: ResultHandle) -> None:
if self._device_type == _DeviceType.LOCAL:
raise NotImplementedError(
"Circuits on local device cannot be cancelled")
task_id = handle[0]
task = AwsQuantumTask(task_id)
task.cancel()
def _create_task(
remaining,
aws_session,
device_arn,
task_specification,
s3_destination_folder,
shots,
poll_interval_seconds,
*args,
**kwargs,
):
task = AwsQuantumTask.create(
aws_session,
device_arn,
task_specification,
s3_destination_folder,
shots,
poll_interval_seconds=poll_interval_seconds,
*args,
**kwargs,
)
remaining.pop()
# If the task hits a terminal state before all tasks have been created,
# it can be returned immediately
while remaining:
if task.state() in AwsQuantumTask.TERMINAL_STATES:
break
time.sleep(poll_interval_seconds)
return task
def _create_task(
remaining: List[int],
aws_session: AwsSession,
device_arn: str,
task_specifications: List[Union[Circuit, Problem, OpenQasmProgram,
BlackbirdProgram]],
s3_destination_folder: AwsSession.S3DestinationFolder,
shots: int,
poll_interval_seconds: float = AwsQuantumTask.
DEFAULT_RESULTS_POLL_INTERVAL,
*args,
**kwargs,
) -> AwsQuantumTask:
task = AwsQuantumTask.create(
aws_session,
device_arn,
task_specifications,
s3_destination_folder,
shots,
poll_interval_seconds=poll_interval_seconds,
*args,
**kwargs,
)
remaining.pop()
# If the task hits a terminal state before all tasks have been created,
# it can be returned immediately
while remaining:
if task.state() in AwsQuantumTask.TERMINAL_STATES:
break
time.sleep(poll_interval_seconds)
return task
def circuit_status(self, handle: ResultHandle) -> CircuitStatus:
if self._device_type == _DeviceType.LOCAL:
return CircuitStatus(StatusEnum.COMPLETED)
task_id, want_state = handle
task = AwsQuantumTask(task_id)
state = task.state()
if state == "FAILED":
result = task.result()
return CircuitStatus(StatusEnum.ERROR,
result.task_metadata.failureReason)
elif state == "CANCELLED":
return CircuitStatus(StatusEnum.CANCELLED)
elif state == "COMPLETED":
self._cache[handle].update(_get_result(task, want_state))
return CircuitStatus(StatusEnum.COMPLETED)
elif state == "QUEUED" or state == "CREATED":
return CircuitStatus(StatusEnum.QUEUED)
elif state == "RUNNING":
return CircuitStatus(StatusEnum.RUNNING)
else:
return CircuitStatus(StatusEnum.ERROR,
f"Unrecognized state '{state}'")
def run(
self,
task_specification: Union[Circuit, Problem],
s3_destination_folder: AwsSession.S3DestinationFolder,
shots: Optional[int] = None,
poll_timeout_seconds: float = AwsQuantumTask.
DEFAULT_RESULTS_POLL_TIMEOUT,
poll_interval_seconds: float = AwsQuantumTask.
DEFAULT_RESULTS_POLL_INTERVAL,
*aws_quantum_task_args,
**aws_quantum_task_kwargs,
) -> AwsQuantumTask:
"""
Run a quantum task specification on this device. A task can be a circuit or an
annealing problem.
Args:
task_specification (Union[Circuit, Problem]): Specification of task
(circuit or annealing problem) to run on device.
s3_destination_folder: The S3 location to save the task's results to.
shots (int, optional): The number of times to run the circuit or annealing problem.
Default is 1000 for QPUs and 0 for simulators.
poll_timeout_seconds (float): The polling timeout for `AwsQuantumTask.result()`,
in seconds. Default: 5 days.
poll_interval_seconds (float): The polling interval for `AwsQuantumTask.result()`,
in seconds. Default: 1 second.
*aws_quantum_task_args: Variable length positional arguments for
`braket.aws.aws_quantum_task.AwsQuantumTask.create()`.
**aws_quantum_task_kwargs: Variable length keyword arguments for
`braket.aws.aws_quantum_task.AwsQuantumTask.create()`.
Returns:
AwsQuantumTask: An AwsQuantumTask that tracks the execution on the device.
Examples:
>>> circuit = Circuit().h(0).cnot(0, 1)
>>> device = AwsDevice("arn1")
>>> device.run(circuit, ("bucket-foo", "key-bar"))
>>> circuit = Circuit().h(0).cnot(0, 1)
>>> device = AwsDevice("arn2")
>>> device.run(task_specification=circuit,
>>> s3_destination_folder=("bucket-foo", "key-bar"))
>>> circuit = Circuit().h(0).cnot(0, 1)
>>> device = AwsDevice("arn3")
>>> device.run(task_specification=circuit,
>>> s3_destination_folder=("bucket-foo", "key-bar"), disable_qubit_rewiring=True)
>>> problem = Problem(
>>> ProblemType.ISING,
>>> linear={1: 3.14},
>>> quadratic={(1, 2): 10.08},
>>> )
>>> device = AwsDevice("arn4")
>>> device.run(problem, ("bucket-foo", "key-bar"),
>>> device_parameters={
>>> "providerLevelParameters": {"postprocessingType": "SAMPLING"}}
>>> )
See Also:
`braket.aws.aws_quantum_task.AwsQuantumTask.create()`
"""
return AwsQuantumTask.create(
self._aws_session,
self._arn,
task_specification,
s3_destination_folder,
shots if shots is not None else self._default_shots,
poll_timeout_seconds=poll_timeout_seconds,
poll_interval_seconds=poll_interval_seconds,
*aws_quantum_task_args,
**aws_quantum_task_kwargs,
)
def run(
self,
task_specification: Union[Circuit, Problem, OpenQasmProgram, BlackbirdProgram],
s3_destination_folder: Optional[AwsSession.S3DestinationFolder] = None,
shots: Optional[int] = None,
poll_timeout_seconds: float = AwsQuantumTask.DEFAULT_RESULTS_POLL_TIMEOUT,
poll_interval_seconds: float = AwsQuantumTask.DEFAULT_RESULTS_POLL_INTERVAL,
*aws_quantum_task_args,
**aws_quantum_task_kwargs,
) -> AwsQuantumTask:
"""
Run a quantum task specification on this device. A task can be a circuit or an
annealing problem.
Args:
task_specification (Union[Circuit, Problem, OpenQasmProgram, BlackbirdProgram]):
Specification of task (circuit or annealing problem or program) to run on device.
s3_destination_folder (Optional[S3DestinationFolder]): The S3 location to
save the task's results to. Default is `<default_bucket>/tasks` if evoked
outside of a Braket Job, `<Job Bucket>/jobs/<job name>/tasks` if evoked inside of
a Braket Job.
shots (Optional[int]): The number of times to run the circuit or annealing problem.
Default is 1000 for QPUs and 0 for simulators.
poll_timeout_seconds (float): The polling timeout for `AwsQuantumTask.result()`,
in seconds. Default: 5 days.
poll_interval_seconds (float): The polling interval for `AwsQuantumTask.result()`,
in seconds. Default: 1 second.
Returns:
AwsQuantumTask: An AwsQuantumTask that tracks the execution on the device.
Examples:
>>> circuit = Circuit().h(0).cnot(0, 1)
>>> device = AwsDevice("arn1")
>>> device.run(circuit, ("bucket-foo", "key-bar"))
>>> circuit = Circuit().h(0).cnot(0, 1)
>>> device = AwsDevice("arn2")
>>> device.run(task_specification=circuit,
>>> s3_destination_folder=("bucket-foo", "key-bar"))
>>> circuit = Circuit().h(0).cnot(0, 1)
>>> device = AwsDevice("arn3")
>>> device.run(task_specification=circuit,
>>> s3_destination_folder=("bucket-foo", "key-bar"), disable_qubit_rewiring=True)
>>> problem = Problem(
>>> ProblemType.ISING,
>>> linear={1: 3.14},
>>> quadratic={(1, 2): 10.08},
>>> )
>>> device = AwsDevice("arn4")
>>> device.run(problem, ("bucket-foo", "key-bar"),
>>> device_parameters={
>>> "providerLevelParameters": {"postprocessingType": "SAMPLING"}}
>>> )
See Also:
`braket.aws.aws_quantum_task.AwsQuantumTask.create()`
"""
return AwsQuantumTask.create(
self._aws_session,
self._arn,
task_specification,
s3_destination_folder
or (
AwsSession.parse_s3_uri(os.environ.get("AMZN_BRAKET_TASK_RESULTS_S3_URI"))
if "AMZN_BRAKET_TASK_RESULTS_S3_URI" in os.environ
else None
)
or (self._aws_session.default_bucket(), "tasks"),
shots if shots is not None else self._default_shots,
poll_timeout_seconds=poll_timeout_seconds,
poll_interval_seconds=poll_interval_seconds,
*aws_quantum_task_args,
**aws_quantum_task_kwargs,
)