def test_add_labels(add_job_labels):
job = cg.EngineJob('a',
'b',
'steve',
EngineContext(),
_job=qtypes.QuantumJob(labels={}))
assert job.labels() == {}
add_job_labels.return_value = qtypes.QuantumJob(labels={
'a': '1',
})
assert job.add_labels({'a': '1'}).labels() == {'a': '1'}
add_job_labels.assert_called_with('a', 'b', 'steve', {'a': '1'})
add_job_labels.return_value = qtypes.QuantumJob(labels={
'a': '2',
'b': '1'
})
assert job.add_labels({
'a': '2',
'b': '1'
}).labels() == {
'a': '2',
'b': '1'
}
add_job_labels.assert_called_with('a', 'b', 'steve', {'a': '2', 'b': '1'})
def test_get_schedule(list_time_slots):
results = [
qtypes.QuantumTimeSlot(
processor_name='potofgold',
start_time=Timestamp(seconds=1000020000),
end_time=Timestamp(seconds=1000040000),
slot_type=qenums.QuantumTimeSlot.TimeSlotType.MAINTENANCE,
maintenance_config=qtypes.QuantumTimeSlot.MaintenanceConfig(
title='Testing',
description='Testing some new configuration.',
),
),
qtypes.QuantumTimeSlot(
processor_name='potofgold',
start_time=Timestamp(seconds=1000010000),
end_time=Timestamp(seconds=1000020000),
slot_type=qenums.QuantumTimeSlot.TimeSlotType.RESERVATION,
reservation_config=qtypes.QuantumTimeSlot.ReservationConfig(
project_id='super_secret_quantum'),
),
]
list_time_slots.return_value = results
processor = cg.EngineProcessor('proj', 'p0', EngineContext())
assert (processor.get_schedule(
datetime.datetime.fromtimestamp(1000000000),
datetime.datetime.fromtimestamp(1000050000)) == results)
list_time_slots.assert_called_once_with(
'proj', 'p0', 'start_time < 1000050000 AND end_time > 1000000000')
def test_list_reservation(list_reservations):
name = 'projects/proj/processors/p0/reservations/rid'
results = [
quantum.QuantumReservation(
name=name,
start_time=Timestamp(seconds=1000000000),
end_time=Timestamp(seconds=1000003600),
whitelisted_users=['*****@*****.**'],
),
quantum.QuantumReservation(
name=name + '2',
start_time=Timestamp(seconds=1000003600),
end_time=Timestamp(seconds=1000007200),
whitelisted_users=['*****@*****.**'],
),
]
list_reservations.return_value = results
processor = cg.EngineProcessor('proj', 'p0', EngineContext())
assert (
processor.list_reservations(
datetime.datetime.fromtimestamp(1000000000), datetime.datetime.fromtimestamp(1000010000)
)
== results
)
list_reservations.assert_called_once_with(
'proj', 'p0', 'start_time < 1000010000 AND end_time > 1000000000'
)
def test_expected_recovery_time():
processor = cg.EngineProcessor('a',
'p',
EngineContext(),
_processor=qtypes.QuantumProcessor())
assert not processor.expected_recovery_time()
processor = cg.EngineProcessor(
'a',
'p',
EngineContext(),
_processor=qtypes.QuantumProcessor(
expected_recovery_time=qtypes.timestamp_pb2.Timestamp(
seconds=1581515101)),
)
assert processor.expected_recovery_time() == datetime.datetime(
2020, 2, 12, 13, 45, 1)
def test_timeout(patched_time_sleep, get_job):
qjob = qtypes.QuantumJob(execution_status=qtypes.ExecutionStatus(
state=qtypes.ExecutionStatus.State.RUNNING))
get_job.return_value = qjob
job = cg.EngineJob('a', 'b', 'steve', EngineContext(timeout=500))
with pytest.raises(RuntimeError, match='Timed out'):
job.results()
def test_labels():
job = cg.EngineJob('a',
'b',
'steve',
EngineContext(),
_job=quantum.QuantumJob(labels={'t': '1'}))
assert job.labels() == {'t': '1'}
def test_results_len(get_job_results):
qjob = qtypes.QuantumJob(execution_status=qtypes.ExecutionStatus(
state=qtypes.ExecutionStatus.State.SUCCESS))
get_job_results.return_value = RESULTS
job = cg.EngineJob('a', 'b', 'steve', EngineContext(), _job=qjob)
assert len(job) == 2
def test_get_missing_device():
processor = cg.EngineProcessor('a',
'p',
EngineContext(),
_processor=qtypes.QuantumProcessor())
with pytest.raises(ValueError, match='device specification'):
_ = processor.get_device(gate_sets=[_GATE_SET])
def test_add_labels(add_program_labels):
program = cg.EngineProgram('a',
'b',
EngineContext(),
_program=qtypes.QuantumProgram(labels={}))
assert program.labels() == {}
add_program_labels.return_value = qtypes.QuantumProgram(labels={
'a': '1',
})
assert program.add_labels({'a': '1'}).labels() == {'a': '1'}
add_program_labels.assert_called_with('a', 'b', {'a': '1'})
add_program_labels.return_value = qtypes.QuantumProgram(labels={
'a': '2',
'b': '1'
})
assert program.add_labels({
'a': '2',
'b': '1'
}).labels() == {
'a': '2',
'b': '1'
}
add_program_labels.assert_called_with('a', 'b', {'a': '2', 'b': '1'})
def test_get_circuit_unsupported_program_type(get_program):
program = cg.EngineProgram('a', 'b', EngineContext())
get_program.return_value = qtypes.QuantumProgram(code=qtypes.any_pb2.Any(
type_url='type.googleapis.com/unknown.proto'))
with pytest.raises(ValueError, match='unknown.proto'):
program.get_circuit()
def test_delete(delete_program):
program = cg.EngineProgram('a', 'b', EngineContext())
program.delete()
delete_program.assert_called_with('a', 'b', delete_jobs=False)
program.delete(delete_jobs=True)
delete_program.assert_called_with('a', 'b', delete_jobs=True)
def test_get_repetitions_and_sweeps_v1(get_job):
job = cg.EngineJob('a', 'b', 'steve', EngineContext())
get_job.return_value = quantum.QuantumJob(run_context=util.pack_any(
v1.program_pb2.RunContext(
parameter_sweeps=[v1.params_pb2.ParameterSweep(repetitions=10)])))
with pytest.raises(ValueError, match='v1 RunContext is not supported'):
job.get_repetitions_and_sweeps()
def test_get_schedule_filter_by_time_slot(list_time_slots):
results = [
quantum.QuantumTimeSlot(
processor_name='potofgold',
start_time=Timestamp(seconds=1000020000),
end_time=Timestamp(seconds=1000040000),
time_slot_type=quantum.QuantumTimeSlot.TimeSlotType.MAINTENANCE,
maintenance_config=quantum.QuantumTimeSlot.MaintenanceConfig(
title='Testing', description='Testing some new configuration.'
),
)
]
list_time_slots.return_value = results
processor = cg.EngineProcessor('proj', 'p0', EngineContext())
assert (
processor.get_schedule(
datetime.datetime.fromtimestamp(1000000000),
datetime.datetime.fromtimestamp(1000050000),
quantum.QuantumTimeSlot.TimeSlotType.MAINTENANCE,
)
== results
)
list_time_slots.assert_called_once_with(
'proj',
'p0',
'start_time < 1000050000 AND end_time > 1000000000 AND ' + 'time_slot_type = MAINTENANCE',
)
def test_calibration_results_not_a_calibration(get_job_results):
qjob = qtypes.QuantumJob(execution_status=qtypes.ExecutionStatus(
state=qtypes.ExecutionStatus.State.SUCCESS))
get_job_results.return_value = RESULTS
job = cg.EngineJob('a', 'b', 'steve', EngineContext(), _job=qjob)
with pytest.raises(ValueError, match='calibration results'):
job.calibration_results()
def test_current_calibration(get_current_calibration):
get_current_calibration.return_value = _CALIBRATION
processor = cg.EngineProcessor('a', 'p', EngineContext())
calibration = processor.get_current_calibration()
assert calibration.timestamp == 1562544000021
assert set(calibration.keys()) == {'xeb', 't1', 'globalMetric'}
get_current_calibration.assert_called_once_with('a', 'p')
def test_get_circuit_v1(get_program):
program = cg.EngineProgram('a', 'b', EngineContext())
get_program.return_value = qtypes.QuantumProgram(
code=_to_any(v1.program_pb2.Program()))
with pytest.raises(ValueError, match='v1 Program is not supported'):
program.get_circuit()
def test_batched_results(get_job_results):
qjob = quantum.QuantumJob(
execution_status=quantum.ExecutionStatus(
state=quantum.ExecutionStatus.State.SUCCESS),
update_time=UPDATE_TIME,
)
get_job_results.return_value = BATCH_RESULTS
job = cg.EngineJob('a', 'b', 'steve', EngineContext(), _job=qjob)
data = job.results()
assert len(data) == 4
assert str(data[0]) == 'q=011'
assert str(data[1]) == 'q=111'
assert str(data[2]) == 'q=1101'
assert str(data[3]) == 'q=1001'
get_job_results.assert_called_once_with('a', 'b', 'steve')
data = job.batched_results()
assert len(data) == 2
assert len(data[0]) == 2
assert len(data[1]) == 2
assert str(data[0][0]) == 'q=011'
assert str(data[0][1]) == 'q=111'
assert str(data[1][0]) == 'q=1101'
assert str(data[1][1]) == 'q=1001'
def test_get_calibration(get_calibration):
qjob = quantum.QuantumJob(execution_status=quantum.ExecutionStatus(
calibration_name='projects/a/processors/p/calibrations/123'))
calibration = quantum.QuantumCalibration(data=util.pack_any(
Merge(
"""
timestamp_ms: 123000,
metrics: [{
name: 'xeb',
targets: ['0_0', '0_1'],
values: [{
double_val: .9999
}]
}, {
name: 't1',
targets: ['0_0'],
values: [{
double_val: 321
}]
}, {
name: 'globalMetric',
values: [{
int32_val: 12300
}]
}]
""",
v2.metrics_pb2.MetricsSnapshot(),
)))
get_calibration.return_value = calibration
job = cg.EngineJob('a', 'b', 'steve', EngineContext(), _job=qjob)
assert list(job.get_calibration()) == ['xeb', 't1', 'globalMetric']
get_calibration.assert_called_once_with('a', 'p', 123)
def test_get_repetitions_and_sweeps_unsupported(get_job):
job = cg.EngineJob('a', 'b', 'steve', EngineContext())
get_job.return_value = quantum.QuantumJob(run_context=any_pb2.Any(
type_url='type.googleapis.com/unknown.proto'))
with pytest.raises(ValueError,
match='unsupported run_context type: unknown.proto'):
job.get_repetitions_and_sweeps()
def test_labels():
program = cg.EngineProgram(
'a',
'b',
EngineContext(),
_program=qtypes.QuantumProgram(labels={'t': '1'}))
assert program.labels() == {'t': '1'}
def test_sampler(client):
client().create_program_async.return_value = (
'prog',
quantum.QuantumProgram(name='projects/proj/programs/prog'),
)
client().create_job_async.return_value = (
'job-id',
quantum.QuantumJob(
name='projects/proj/programs/prog/jobs/job-id', execution_status={'state': 'READY'}
),
)
client().get_job_async.return_value = quantum.QuantumJob(
execution_status={'state': 'SUCCESS'}, update_time=_to_timestamp('2019-07-09T23:39:59Z')
)
client().get_job_results_async.return_value = quantum.QuantumResult(
result=util.pack_any(_RESULTS_V2)
)
processor = cg.EngineProcessor('proj', 'mysim', EngineContext())
sampler = processor.get_sampler()
results = sampler.run_sweep(
program=_CIRCUIT, params=[cirq.ParamResolver({'a': 1}), cirq.ParamResolver({'a': 2})]
)
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')}
assert client().create_program_async.call_args[0][0] == 'proj'
def test_run_calibration_no_processors(create_job):
create_job.return_value = ('dogs', qtypes.QuantumJob())
program = cg.EngineProgram('woof',
'woof',
EngineContext(),
result_type=ResultType.Calibration)
with pytest.raises(ValueError, match='No processors specified'):
_ = program.run_calibration(job_id='spot')
def test_run_calibration_delegation(create_job):
create_job.return_value = ('dogs', qtypes.QuantumJob())
program = cg.EngineProgram('woof',
'woof',
EngineContext(),
result_type=ResultType.Calibration)
job = program.run_calibration(processor_ids=['lazydog'])
assert job._job == qtypes.QuantumJob()
def test_create_context(client):
with pytest.raises(ValueError,
match='specify service_args and verbose or client'):
EngineContext(cg.engine.engine.ProtoVersion.V1, {'args': 'test'}, True,
mock.Mock())
with pytest.raises(ValueError, match='no longer supported'):
_ = EngineContext(cg.engine.engine.ProtoVersion.V1, {'args': 'test'},
True)
context = EngineContext(cg.engine.engine.ProtoVersion.V2, {'args': 'test'},
True)
assert context.proto_version == cg.engine.engine.ProtoVersion.V2
assert client.called_with({'args': 'test'}, True)
assert context.copy().proto_version == context.proto_version
assert context.copy().client == context.client
assert context.copy() == context
def test_run_batch_delegation(create_job):
create_job.return_value = ('kittens', quantum.QuantumJob())
program = cg.EngineProgram('my-meow', 'my-meow', EngineContext(), result_type=ResultType.Batch)
resolver_list = [cirq.Points('cats', [1.0, 2.0, 3.0]), cirq.Points('cats', [4.0, 5.0, 6.0])]
job = program.run_batch(
job_id='steve', repetitions=10, params_list=resolver_list, processor_ids=['lazykitty']
)
assert job._job == quantum.QuantumJob()
def test_run_sweeps_delegation(create_job):
create_job.return_value = ('steve', quantum.QuantumJob())
program = cg.EngineProgram('my-proj', 'my-prog', EngineContext())
param_resolver = cirq.ParamResolver({})
job = program.run_sweep(
job_id='steve', repetitions=10, params=param_resolver, processor_ids=['mine']
)
assert job._job == quantum.QuantumJob()
def test_get_repetitions_and_sweeps(get_job):
job = cg.EngineJob('a', 'b', 'steve', EngineContext())
get_job.return_value = quantum.QuantumJob(run_context=util.pack_any(
v2.run_context_pb2.RunContext(parameter_sweeps=[
v2.run_context_pb2.ParameterSweep(repetitions=10)
])))
assert job.get_repetitions_and_sweeps() == (10, [cirq.UnitSweep])
get_job.assert_called_once_with('a', 'b', 'steve', True)
def test_get_circuit_v2_unknown_gateset(get_program):
program = cg.EngineProgram('a', 'b', EngineContext())
get_program.return_value = qtypes.QuantumProgram(code=_to_any(
v2.program_pb2.Program(language=v2.program_pb2.Language(
gate_set="BAD_GATESET"))))
with pytest.raises(ValueError, match='BAD_GATESET'):
program.get_circuit()
def test_status(get_job):
qjob = qtypes.QuantumJob(execution_status=qtypes.ExecutionStatus(
state=qtypes.ExecutionStatus.State.RUNNING))
get_job.return_value = qjob
job = cg.EngineJob('a', 'b', 'steve', EngineContext())
assert job.status() == 'RUNNING'
get_job.assert_called_once()
def test_get_circuit_v2(get_program):
circuit = cirq.Circuit(
cirq.X(cirq.GridQubit(5, 2))**0.5,
cirq.measure(cirq.GridQubit(5, 2), key='result'))
program = cg.EngineProgram('a', 'b', EngineContext())
get_program.return_value = qtypes.QuantumProgram(code=_PROGRAM_V2)
assert program.get_circuit() == circuit
get_program.assert_called_once_with('a', 'b', True)
