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))