def test_get_program(client_constructor):
grpc_client = setup_mock_(client_constructor)
result = qtypes.QuantumProgram(name='projects/proj/programs/prog')
grpc_client.get_quantum_program.return_value = result
client = EngineClient()
assert client.get_program('proj', 'prog', False) == result
assert grpc_client.get_quantum_program.call_args[0] == (
'projects/proj/programs/prog', False)
assert client.get_program('proj', 'prog', True) == result
assert grpc_client.get_quantum_program.call_args[0] == (
'projects/proj/programs/prog', True)
def test_remove_program_labels(client_constructor):
grpc_client = setup_mock_(client_constructor)
existing = qtypes.QuantumProgram(labels={
'color': 'red',
'weather': 'sun',
'run': '1'
},
label_fingerprint='hash')
grpc_client.get_quantum_program.return_value = existing
result = qtypes.QuantumProgram(name='projects/proj/programs/prog')
grpc_client.update_quantum_program.return_value = result
client = EngineClient()
assert client.remove_program_labels('proj', 'prog', ['other']) == existing
assert grpc_client.update_quantum_program.call_count == 0
assert client.remove_program_labels('proj', 'prog',
['hello', 'weather']) == result
assert grpc_client.update_quantum_program.call_args[0] == (
'projects/proj/programs/prog',
qtypes.QuantumProgram(name='projects/proj/programs/prog',
labels={
'color': 'red',
'run': '1',
},
label_fingerprint='hash'),
qtypes.field_mask_pb2.FieldMask(paths=['labels']))
assert client.remove_program_labels('proj', 'prog',
['color', 'weather', 'run']) == result
assert grpc_client.update_quantum_program.call_args[0] == (
'projects/proj/programs/prog',
qtypes.QuantumProgram(name='projects/proj/programs/prog',
label_fingerprint='hash'),
qtypes.field_mask_pb2.FieldMask(paths=['labels']))
def test_create_program(client_constructor):
grpc_client = setup_mock_(client_constructor)
result = qtypes.QuantumProgram(name='projects/proj/programs/prog')
grpc_client.create_quantum_program.return_value = result
code = qtypes.any_pb2.Any()
labels = {'hello': 'world'}
client = EngineClient()
assert client.create_program('proj', 'prog', code, 'A program',
labels) == ('prog', result)
assert grpc_client.create_quantum_program.call_args[0] == (
'projects/proj',
qtypes.QuantumProgram(name='projects/proj/programs/prog',
code=code,
description='A program',
labels=labels),
False,
)
assert client.create_program('proj', 'prog', code,
'A program') == ('prog', result)
assert grpc_client.create_quantum_program.call_args[0] == (
'projects/proj',
qtypes.QuantumProgram(name='projects/proj/programs/prog',
code=code,
description='A program'),
False,
)
assert client.create_program('proj', 'prog', code,
labels=labels) == ('prog', result)
assert grpc_client.create_quantum_program.call_args[0] == (
'projects/proj',
qtypes.QuantumProgram(name='projects/proj/programs/prog',
code=code,
labels=labels),
False,
)
assert client.create_program('proj', 'prog', code) == ('prog', result)
assert grpc_client.create_quantum_program.call_args[0] == (
'projects/proj',
qtypes.QuantumProgram(name='projects/proj/programs/prog', code=code),
False,
)
assert client.create_program('proj', program_id=None,
code=code) == ('prog', result)
assert grpc_client.create_quantum_program.call_args[0] == (
'projects/proj',
qtypes.QuantumProgram(code=code),
False,
)
def test_run_calibration(client):
client().create_program.return_value = (
'prog',
qtypes.QuantumProgram(name='projects/proj/programs/prog'),
)
client().create_job.return_value = (
'job-id',
qtypes.QuantumJob(name='projects/proj/programs/prog/jobs/job-id',
execution_status={'state': 'READY'}),
)
client().get_job.return_value = qtypes.QuantumJob(
execution_status={'state': 'SUCCESS'})
client().get_job_results.return_value = qtypes.QuantumResult(
result=_CALIBRATION_RESULTS_V2)
q1 = cirq.GridQubit(2, 3)
q2 = cirq.GridQubit(2, 4)
layer1 = cg.CalibrationLayer('xeb', cirq.Circuit(cirq.CZ(q1, q2)),
{'num_layers': 42})
layer2 = cg.CalibrationLayer('readout', cirq.Circuit(cirq.measure(q1, q2)),
{'num_samples': 4242})
processor = cg.EngineProcessor('proj', 'mysim', EngineContext())
job = processor.run_calibration(gate_set=cg.FSIM_GATESET,
layers=[layer1, layer2],
job_id='job-id')
results = job.calibration_results()
assert len(results) == 2
assert results[0].code == v2.calibration_pb2.SUCCESS
assert results[0].error_message == 'First success'
assert results[0].token == 'abc123'
assert len(results[0].metrics) == 1
assert len(results[0].metrics['fidelity']) == 1
assert results[0].metrics['fidelity'][(q1, q2)] == [0.75]
assert results[1].code == v2.calibration_pb2.SUCCESS
assert results[1].error_message == 'Second success'
# assert label is correct
client().create_job.assert_called_once_with(
project_id='proj',
program_id='prog',
job_id='job-id',
processor_ids=['mysim'],
run_context=_to_any(v2.run_context_pb2.RunContext()),
description=None,
labels={'calibration': ''},
)
def test_run_batch_no_sweeps(create_job):
# Running with no sweeps is fine. Uses program's batch size to create
# proper empty sweeps.
create_job.return_value = ('kittens', qtypes.QuantumJob())
program = cg.EngineProgram(
'my-meow',
'my-meow',
_program=qtypes.QuantumProgram(code=_BATCH_PROGRAM_V2),
context=EngineContext(),
result_type=ResultType.Batch,
)
job = program.run_batch(job_id='steve',
repetitions=10,
processor_ids=['lazykitty'])
assert job._job == qtypes.QuantumJob()
batch_run_context = v2.batch_pb2.BatchRunContext()
create_job.call_args[1]['run_context'].Unpack(batch_run_context)
assert len(batch_run_context.run_contexts) == 1
def test_run_batch(client):
client().create_program.return_value = (
'prog',
qtypes.QuantumProgram(name='projects/proj/programs/prog'),
)
client().create_job.return_value = (
'job-id',
qtypes.QuantumJob(name='projects/proj/programs/prog/jobs/job-id',
execution_status={'state': 'READY'}),
)
client().get_job.return_value = qtypes.QuantumJob(
execution_status={'state': 'SUCCESS'})
client().get_job_results.return_value = qtypes.QuantumResult(
result=_BATCH_RESULTS_V2)
processor = cg.EngineProcessor('a', 'p', EngineContext())
job = processor.run_batch(
gate_set=cg.XMON,
programs=[_CIRCUIT, _CIRCUIT],
job_id='job-id',
params_list=[cirq.Points('a', [1, 2]),
cirq.Points('a', [3, 4])],
)
results = job.results()
assert len(results) == 4
for i, v in enumerate([1, 2, 3, 4]):
assert results[i].repetitions == 1
assert results[i].params.param_dict == {'a': v}
assert results[i].measurements == {'q': np.array([[0]], dtype='uint8')}
client().create_program.assert_called_once()
client().create_job.assert_called_once()
run_context = v2.batch_pb2.BatchRunContext()
client().create_job.call_args[1]['run_context'].Unpack(run_context)
assert len(run_context.run_contexts) == 2
for idx, rc in enumerate(run_context.run_contexts):
sweeps = rc.parameter_sweeps
assert len(sweeps) == 1
assert sweeps[0].repetitions == 1
if idx == 0:
assert sweeps[0].sweep.single_sweep.points.points == [1.0, 2.0]
if idx == 1:
assert sweeps[0].sweep.single_sweep.points.points == [3.0, 4.0]
client().get_job.assert_called_once()
client().get_job_results.assert_called_once()
def test_run_sweep_params(client):
client().create_program.return_value = (
'prog',
qtypes.QuantumProgram(name='projects/proj/programs/prog'),
)
client().create_job.return_value = (
'job-id',
qtypes.QuantumJob(name='projects/proj/programs/prog/jobs/job-id',
execution_status={'state': 'READY'}),
)
client().get_job.return_value = qtypes.QuantumJob(
execution_status={'state': 'SUCCESS'})
client().get_job_results.return_value = qtypes.QuantumResult(
result=_to_any(_RESULTS_V2))
processor = cg.EngineProcessor('a', 'p', EngineContext())
job = processor.run_sweep(
program=_CIRCUIT,
params=[cirq.ParamResolver({'a': 1}),
cirq.ParamResolver({'a': 2})],
gate_set=cg.XMON,
)
results = job.results()
assert len(results) == 2
for i, v in enumerate([1, 2]):
assert results[i].repetitions == 1
assert results[i].params.param_dict == {'a': v}
assert results[i].measurements == {'q': np.array([[0]], dtype='uint8')}
client().create_program.assert_called_once()
client().create_job.assert_called_once()
run_context = v2.run_context_pb2.RunContext()
client().create_job.call_args[1]['run_context'].Unpack(run_context)
sweeps = run_context.parameter_sweeps
assert len(sweeps) == 2
for i, v in enumerate([1.0, 2.0]):
assert sweeps[i].repetitions == 1
assert sweeps[i].sweep.sweep_function.sweeps[
0].single_sweep.points.points == [v]
client().get_job.assert_called_once()
client().get_job_results.assert_called_once()
def test_run_circuit_timeout(patched_time_sleep, client):
client().create_program.return_value = (
'prog',
qtypes.QuantumProgram(name='projects/proj/programs/prog'),
)
client().create_job.return_value = (
'job-id',
qtypes.QuantumJob(name='projects/proj/programs/prog/jobs/job-id',
execution_status={'state': 'READY'}),
)
client().get_job.return_value = qtypes.QuantumJob(
name='projects/proj/programs/prog/jobs/job-id',
execution_status={
'state': 'RUNNING',
},
)
engine = cg.Engine(project_id='project-id', timeout=600)
with pytest.raises(RuntimeError, match='Timed out'):
engine.run(program=_CIRCUIT, gate_set=cg.XMON)
def test_run_circuit_cancelled(client):
client().create_program.return_value = (
'prog',
qtypes.QuantumProgram(name='projects/proj/programs/prog'),
)
client().create_job.return_value = (
'job-id',
qtypes.QuantumJob(name='projects/proj/programs/prog/jobs/job-id',
execution_status={'state': 'READY'}),
)
client().get_job.return_value = qtypes.QuantumJob(
name='projects/proj/programs/prog/jobs/job-id',
execution_status={
'state': 'CANCELLED',
},
)
engine = cg.Engine(project_id='proj')
with pytest.raises(
RuntimeError,
match=
'Job projects/proj/programs/prog/jobs/job-id failed in state CANCELLED.',
):
engine.run(program=_CIRCUIT, gate_set=cg.XMON)
def test_update_time(get_program):
program = cg.EngineProgram('a', 'b', EngineContext())
get_program.return_value = qtypes.QuantumProgram(
update_time=qtypes.timestamp_pb2.Timestamp(seconds=1581515101))
assert program.update_time() == datetime.datetime(2020, 2, 12, 13, 45, 1)
get_program.assert_called_once_with('a', 'b', False)
def test_create_program(client):
client().create_program.return_value = ('prog', qtypes.QuantumProgram())
result = cg.Engine(project_id='proj').create_program(_CIRCUIT, 'prog')
client().create_program.assert_called_once()
assert result.program_id == 'prog'
