def test_labels():
job = cg.EngineJob('a',
'b',
'steve',
EngineContext(),
_job=qtypes.QuantumJob(labels={'t': '1'}))
assert job.labels() == {'t': '1'}
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_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_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_get_calibration(get_calibration):
qjob = qtypes.QuantumJob(execution_status=qtypes.ExecutionStatus(
calibration_name='projects/a/processors/p/calibrations/123'))
calibration = qtypes.QuantumCalibration(data=_to_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_batched_results_not_a_batch(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='batched_results'):
job.batched_results()
def test_get_repetitions_and_sweeps_v1(get_job):
job = cg.EngineJob('a', 'b', 'steve', EngineContext())
get_job.return_value = qtypes.QuantumJob(run_context=_to_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_labels():
program = cg.EngineProgram(
'a',
'b',
EngineContext(),
_program=qtypes.QuantumProgram(labels={'t': '1'}))
assert program.labels() == {'t': '1'}
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_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_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_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_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_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_get_repetitions_and_sweeps_unsupported(get_job):
job = cg.EngineJob('a', 'b', 'steve', EngineContext())
get_job.return_value = qtypes.QuantumJob(run_context=qtypes.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_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_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_run_batch_no_sweeps():
program = cg.EngineProgram('no-meow',
'no-meow',
EngineContext(),
batch_mode=True)
with pytest.raises(ValueError, match='No parameter list specified'):
_ = program.run_batch(repetitions=1, processor_ids=['lazykitty'])
def test_run_sweeps_delegation(create_job):
create_job.return_value = ('steve', qtypes.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 == qtypes.QuantumJob()
def test_run_batch_delegation(create_job):
create_job.return_value = ('kittens', qtypes.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 == qtypes.QuantumJob()
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_repetitions_and_sweeps(get_job):
job = cg.EngineJob('a', 'b', 'steve', EngineContext())
get_job.return_value = qtypes.QuantumJob(run_context=_to_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='unsupported gateset: BAD_GATESET'):
program.get_circuit()
def test_create_time():
program = cg.EngineProgram(
'a',
'b',
EngineContext(),
_program=qtypes.QuantumProgram(
create_time=qtypes.timestamp_pb2.Timestamp(seconds=1581515101)))
assert program.create_time() == datetime.datetime(2020, 2, 12, 13, 45, 1)
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_remove_reservation_not_found(get_reservation):
get_reservation.return_value = None
processor = cg.EngineProcessor(
'proj', 'p0', EngineContext(),
qtypes.QuantumProcessor(schedule_frozen_period=Duration(
seconds=10000)))
with pytest.raises(ValueError):
processor.remove_reservation('rid')
def test_health(get_processor):
get_processor.return_value = qtypes.QuantumProcessor(health=qtypes.QuantumProcessor.Health.OK)
processor = cg.EngineProcessor(
'a',
'p',
EngineContext(),
_processor=qtypes.QuantumProcessor(health=qtypes.QuantumProcessor.Health.DOWN),
)
assert processor.health() == 'OK'
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)
def test_set_labels(set_program_labels):
program = cg.EngineProgram('a', 'b', EngineContext())
set_program_labels.return_value = qtypes.QuantumProgram(labels={'a': '1', 'b': '1'})
assert program.set_labels({'a': '1', 'b': '1'}).labels() == {'a': '1', 'b': '1'}
set_program_labels.assert_called_with('a', 'b', {'a': '1', 'b': '1'})
set_program_labels.return_value = qtypes.QuantumProgram()
assert program.set_labels({}).labels() == {}
set_program_labels.assert_called_with('a', 'b', {})
