def test_from_circuit_with_verbatim(device_arn, device_parameters_class,
disable_qubit_rewiring, aws_session):
circ = Circuit().add_verbatim_box(Circuit().h(0))
mocked_task_arn = "task-arn-1"
aws_session.create_quantum_task.return_value = mocked_task_arn
shots = 1337
task = AwsQuantumTask.create(
aws_session,
device_arn,
circ,
S3_TARGET,
shots,
disable_qubit_rewiring=disable_qubit_rewiring,
)
assert task == AwsQuantumTask(mocked_task_arn, aws_session)
serialization_properties = OpenQASMSerializationProperties(
qubit_reference_type=QubitReferenceType.PHYSICAL)
_assert_create_quantum_task_called_with(
aws_session,
device_arn,
circ.to_ir(
ir_type=IRType.OPENQASM,
serialization_properties=serialization_properties,
).json(),
S3_TARGET,
shots,
device_parameters_class(paradigmParameters=GateModelParameters(
qubitCount=circ.qubit_count,
disableQubitRewiring=disable_qubit_rewiring)),
)
def test_create_with_tags(device_arn, device_parameters_class, aws_session,
circuit):
mocked_task_arn = "task-arn-tags"
aws_session.create_quantum_task.return_value = mocked_task_arn
shots = 53
tags = {"state": "washington"}
task = AwsQuantumTask.create(aws_session,
device_arn,
circuit,
S3_TARGET,
shots,
tags=tags)
assert task == AwsQuantumTask(mocked_task_arn, aws_session,
GateModelQuantumTaskResult.from_string)
_assert_create_quantum_task_called_with(
aws_session,
device_arn,
circuit,
S3_TARGET,
shots,
device_parameters_class(paradigmParameters=GateModelParameters(
qubitCount=circuit.qubit_count)),
tags,
)
def test_from_circuit_with_disabled_rewiring(device_arn,
device_parameters_class,
aws_session, circuit):
mocked_task_arn = "task-arn-1"
aws_session.create_quantum_task.return_value = mocked_task_arn
shots = 53
task = AwsQuantumTask.create(aws_session,
device_arn,
circuit,
S3_TARGET,
shots,
disable_qubit_rewiring=True)
assert task == AwsQuantumTask(mocked_task_arn, aws_session)
_assert_create_quantum_task_called_with(
aws_session,
device_arn,
circuit.to_ir(
ir_type=IRType.OPENQASM,
serialization_properties=OpenQASMSerializationProperties(
QubitReferenceType.PHYSICAL),
).json(),
S3_TARGET,
shots,
device_parameters_class(paradigmParameters=GateModelParameters(
qubitCount=circuit.qubit_count, disableQubitRewiring=True)),
)
def test_from_circuit_with_disabled_rewiring(device_arn,
device_parameters_class,
aws_session, circuit):
mocked_task_arn = "task-arn-1"
aws_session.create_quantum_task.return_value = mocked_task_arn
shots = 53
task = AwsQuantumTask.create(aws_session,
device_arn,
circuit,
S3_TARGET,
shots,
disable_qubit_rewiring=True)
assert task == AwsQuantumTask(mocked_task_arn, aws_session,
GateModelQuantumTaskResult.from_string)
_assert_create_quantum_task_called_with(
aws_session,
device_arn,
circuit,
S3_TARGET,
shots,
device_parameters_class(paradigmParameters=GateModelParameters(
qubitCount=circuit.qubit_count, disableQubitRewiring=True)),
)
def test_from_circuit_with_verbatim(device_arn, device_parameters_class,
aws_session):
circ = Circuit().add_verbatim_box(Circuit().h(0))
mocked_task_arn = "task-arn-1"
aws_session.create_quantum_task.return_value = mocked_task_arn
shots = 1337
task = AwsQuantumTask.create(
aws_session,
device_arn,
circ,
S3_TARGET,
shots,
disable_qubit_rewiring=True,
)
assert task == AwsQuantumTask(mocked_task_arn, aws_session)
_assert_create_quantum_task_called_with(
aws_session,
device_arn,
circ,
S3_TARGET,
shots,
device_parameters_class(paradigmParameters=GateModelParameters(
qubitCount=circ.qubit_count, disableQubitRewiring=True)),
)
def thaw(self):
"""
No thawing necessary.
The real promise should probably have this method in the frozen instance class.
"""
from braket.aws import AwsQuantumTask
if isinstance(self.task, str):
self.task = AwsQuantumTask(arn=self.task)
return self
def test_equality(arn, aws_session):
quantum_task_1 = AwsQuantumTask(arn, aws_session)
quantum_task_2 = AwsQuantumTask(arn, aws_session)
other_quantum_task = AwsQuantumTask("different:arn", aws_session)
non_quantum_task = quantum_task_1.id
assert quantum_task_1 == quantum_task_2
assert quantum_task_1 is not quantum_task_2
assert quantum_task_1 != other_quantum_task
assert quantum_task_1 != non_quantum_task
def test_timeout_no_result_terminal_state(aws_session):
_mock_metadata(aws_session, "RUNNING")
_mock_s3(aws_session, MockS3.MOCK_S3_RESULT_GATE_MODEL)
# Setup the poll timing such that the timeout will occur after one API poll
quantum_task = AwsQuantumTask(
"foo:bar:arn", aws_session, poll_timeout_seconds=0.5, poll_interval_seconds=1
)
assert quantum_task.result() is None
_mock_metadata(aws_session, "FAILED")
assert quantum_task.result() is None
def test_create_blackbird_program(aws_session, arn, blackbird_program):
aws_session.create_quantum_task.return_value = arn
shots = 21
AwsQuantumTask.create(aws_session, XANADU_ARN, blackbird_program,
S3_TARGET, shots)
_assert_create_quantum_task_called_with(
aws_session,
XANADU_ARN,
blackbird_program.json(),
S3_TARGET,
shots,
)
def test_create_openqasm_program(aws_session, arn, openqasm_program):
aws_session.create_quantum_task.return_value = arn
shots = 21
AwsQuantumTask.create(aws_session, SIMULATOR_ARN, openqasm_program,
S3_TARGET, shots)
_assert_create_quantum_task_called_with(
aws_session,
SIMULATOR_ARN,
openqasm_program.json(),
S3_TARGET,
shots,
)
def test_timeout_completed(aws_session):
_mock_metadata(aws_session, "RUNNING")
_mock_s3(aws_session, MockS3.MOCK_S3_RESULT_GATE_MODEL)
# Setup the poll timing such that the timeout will occur after one API poll
quantum_task = AwsQuantumTask(
"foo:bar:arn", aws_session, poll_timeout_seconds=0.5, poll_interval_seconds=1
)
assert quantum_task.result() is None
_mock_metadata(aws_session, "COMPLETED")
assert quantum_task.state() == "COMPLETED"
assert quantum_task.result() == GateModelQuantumTaskResult.from_string(
MockS3.MOCK_S3_RESULT_GATE_MODEL
)
def test_no_program_inputs(aws_session):
openqasm_program = OpenQasmProgram(
source="""
qubit q;
h q;
""",
inputs={"x": 1},
)
aws_session.create_quantum_task.return_value = arn
shots = 21
only_for_local_sim = (
"OpenQASM Program inputs are only currently supported in the LocalSimulator."
)
with pytest.raises(ValueError, match=only_for_local_sim):
AwsQuantumTask.create(aws_session, SIMULATOR_ARN, openqasm_program,
S3_TARGET, shots)
def test_from_annealing(device_parameters, aws_session, arn, problem):
mocked_task_arn = "task-arn-1"
aws_session.create_quantum_task.return_value = mocked_task_arn
task = AwsQuantumTask.create(
aws_session, arn, problem, S3_TARGET, 1000, device_parameters=device_parameters
)
assert task == AwsQuantumTask(
mocked_task_arn, aws_session, AnnealingQuantumTaskResult.from_string
)
_assert_create_quantum_task_called_with(
aws_session,
arn,
problem,
S3_TARGET,
1000,
DwaveDeviceParameters.parse_obj(device_parameters),
)
def test_aws_session_for_task_arn(mock_session):
region = "us-west-2"
arn = f"arn:aws:aqx:{region}:account_id:quantum-task:task_id"
mock_boto_session = Mock()
mock_session.return_value = mock_boto_session
mock_boto_session.region_name = region
aws_session = AwsQuantumTask._aws_session_for_task_arn(arn)
mock_session.assert_called_with(region_name=region)
assert aws_session.boto_session == mock_boto_session
def test_from_circuit_with_shots(device_arn, device_parameters_class,
aws_session, circuit):
mocked_task_arn = "task-arn-1"
aws_session.create_quantum_task.return_value = mocked_task_arn
shots = 53
task = AwsQuantumTask.create(aws_session, device_arn, circuit, S3_TARGET,
shots)
assert task == AwsQuantumTask(mocked_task_arn, aws_session)
_assert_create_quantum_task_called_with(
aws_session,
device_arn,
circuit.to_ir(ir_type=IRType.OPENQASM).json(),
S3_TARGET,
shots,
device_parameters_class(paradigmParameters=GateModelParameters(
qubitCount=circuit.qubit_count, disableQubitRewiring=False)),
)
def parameterized_quantum_task(aws_session, s3_destination_folder):
theta = FreeParameter("theta")
circ = Circuit().ry(angle=theta, target=0)
return AwsQuantumTask.create(
device_arn="arn:aws:braket:::device/quantum-simulator/amazon/sv1",
aws_session=aws_session,
poll_timeout_seconds=2,
task_specification=circ,
shots=10,
s3_destination_folder=s3_destination_folder,
)
def retrieve_job(self, job_id: str, s3_bucket: Optional[str] = None) -> 'awsjob.AWSJob':
qobj, extra_data = self._load_job_data_s3(job_id=job_id, s3_bucket=s3_bucket)
arns = self._load_job_task_arns(job_id=job_id, s3_bucket=s3_bucket)
tasks = [AwsQuantumTask(arn=arn) for arn in arns]
job = awsjob.AWSJob(
job_id=job_id,
qobj=qobj,
tasks=tasks,
extra_data=extra_data,
s3_bucket=s3_bucket,
backend=self
)
return job
def test_from_annealing(device_parameters, aws_session, arn, problem):
mocked_task_arn = "task-arn-1"
aws_session.create_quantum_task.return_value = mocked_task_arn
task = AwsQuantumTask.create(
aws_session,
arn,
problem,
S3_TARGET,
1000,
device_parameters=device_parameters,
)
assert task == AwsQuantumTask(mocked_task_arn, aws_session)
annealing_parameters = _create_annealing_device_params(device_parameters,
device_arn=arn)
validate(json.loads(annealing_parameters.json(exclude_none=True)),
annealing_parameters.schema())
_assert_create_quantum_task_called_with(
aws_session,
arn,
problem.to_ir().json(),
S3_TARGET,
1000,
annealing_parameters,
)
def test_timeout_completed(aws_session):
_mock_metadata(aws_session, "RUNNING")
_mock_s3(aws_session, MockS3.MOCK_S3_RESULT_GATE_MODEL)
# Setup the poll timing such that the timeout will occur after one API poll
quantum_task = AwsQuantumTask(
"foo:bar:arn",
aws_session,
poll_timeout_seconds=0.5,
poll_interval_seconds=1,
poll_outside_execution_window=True,
)
assert quantum_task.result() is None
_mock_metadata(aws_session, "COMPLETED")
assert quantum_task.state() == "COMPLETED"
assert quantum_task.result() == GateModelQuantumTaskResult.from_string(
MockS3.MOCK_S3_RESULT_GATE_MODEL)
# Cached status is still COMPLETED, so result should be fetched
_mock_metadata(aws_session, "RUNNING")
quantum_task._result = None
assert quantum_task.result() == GateModelQuantumTaskResult.from_string(
MockS3.MOCK_S3_RESULT_GATE_MODEL)
def photonic_model_task(aws_session):
return AwsQuantumTask("foo:bar:arn", aws_session, poll_timeout_seconds=2)
def annealing_task(aws_session):
return AwsQuantumTask("foo:bar:arn", aws_session, poll_timeout_seconds=2)
def _init_and_add_to_list(aws_session, arn, task_list):
task_list.append(
AwsQuantumTask(arn, aws_session,
GateModelQuantumTaskResult.from_string))
class AmazonCloudPromise(AmazonPromiseBase):
"""
AWS Cloud Promise
"""
try:
S3_BUCKET = (open(
os.path.join(os.path.dirname(__file__), "../../s3_location.txt"),
"r").read().strip())
except FileNotFoundError:
S3_BUCKET = None
def __init__(self,
circuit: braket.circuits.Circuit,
device,
num_shots: int,
*,
s3_bucket: str = S3_BUCKET,
s3_bucket_folder: str = "benchmarks"):
super().__init__()
self.s3_path = (s3_bucket, s3_bucket_folder)
self.task = device.run(circuit,
self.s3_path,
shots=num_shots,
poll_timeout_seconds=5 * 24 * 60 * 60)
def job_id(self):
"""
Return a job id.
"""
return self.task.id
def status(self):
"""
Return the status.
"""
state = self.task.state()
if state == "COMPLETED":
return "DONE"
elif state == "CREATED" or state == "QUEUED" or state == "RUNNING":
return "PENDING"
else:
return "FAILURE"
def freeze(self):
"""
Since promises that resolve immediately will never be pickled, we can just pass self.
The real promise can return a separate frozen instance if necessary.
"""
if not isinstance(self.task, str):
self.task = self.job_id()
return self
def thaw(self):
"""
No thawing necessary.
The real promise should probably have this method in the frozen instance class.
"""
from braket.aws import AwsQuantumTask
if isinstance(self.task, str):
self.task = AwsQuantumTask(arn=self.task)
return self
def result(self):
if self.status() == "DONE":
return self.task.result()
else:
return None
def circuit_task(aws_session):
return AwsQuantumTask("foo:bar:arn", aws_session, poll_timeout_seconds=2)
def test_from_circuit_with_shots_value_error(aws_session, arn, circuit):
mocked_task_arn = "task-arn-1"
aws_session.create_quantum_task.return_value = mocked_task_arn
AwsQuantumTask.create(aws_session, arn, circuit, S3_TARGET, 0)
def annealing_task(aws_session):
return AwsQuantumTask("foo:bar:arn",
aws_session,
poll_timeout_seconds=2,
poll_outside_execution_window=True)
def test_create_invalid_task_specification(aws_session, arn):
mocked_task_arn = "task-arn-1"
aws_session.create_quantum_task.return_value = mocked_task_arn
AwsQuantumTask.create(aws_session, arn, "foo", S3_TARGET, 1000)
def test_create_invalid_s3_folder(aws_session, arn, circuit):
AwsQuantumTask.create(aws_session, arn, circuit, ("bucket", ), 1000)
def test_id_getter(arn, aws_session):
quantum_task = AwsQuantumTask(arn, aws_session)
assert quantum_task.id == arn
def _init_and_add_to_list(aws_session, arn, task_list):
task_list.append(AwsQuantumTask(arn, aws_session))
