def test_set_program_labels(client_constructor):
grpc_client = setup_mock_(client_constructor)
grpc_client.get_quantum_program.return_value = qtypes.QuantumProgram(
labels={
'color': 'red',
'weather': 'sun',
'run': '1'
},
label_fingerprint='hash')
result = qtypes.QuantumProgram(name='projects/proj/programs/prog')
grpc_client.update_quantum_program.return_value = result
client = EngineClient()
labels = {'hello': 'world', 'color': 'blue', 'run': '1'}
assert client.set_program_labels('proj', 'prog', labels) == result
assert grpc_client.update_quantum_program.call_args[0] == (
'projects/proj/programs/prog',
qtypes.QuantumProgram(name='projects/proj/programs/prog',
labels=labels,
label_fingerprint='hash'),
qtypes.field_mask_pb2.FieldMask(paths=['labels']))
assert client.set_program_labels('proj', 'prog', {}) == 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_get_batch_size(get_program):
# Has to fetch from engine if not _program specified.
program = cg.EngineProgram('a',
'b',
EngineContext(),
result_type=ResultType.Batch)
get_program.return_value = qtypes.QuantumProgram(code=_BATCH_PROGRAM_V2)
assert program.batch_size() == 1
# If _program specified, uses that value.
program = cg.EngineProgram(
'a',
'b',
EngineContext(),
_program=qtypes.QuantumProgram(code=_BATCH_PROGRAM_V2),
result_type=ResultType.Batch)
assert program.batch_size() == 1
with pytest.raises(ValueError, match='ResultType.Program'):
program = cg.EngineProgram('a',
'b',
EngineContext(),
result_type=ResultType.Program)
_ = program.batch_size()
with pytest.raises(ValueError, match='cirq.google.api.v2.Program'):
get_program.return_value = qtypes.QuantumProgram(code=_PROGRAM_V2)
program = cg.EngineProgram('a',
'b',
EngineContext(),
result_type=ResultType.Batch)
_ = program.batch_size()
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_description(get_program):
program = cg.EngineProgram(
'a', 'b', EngineContext(), _program=qtypes.QuantumProgram(description='hello')
)
assert program.description() == 'hello'
get_program.return_value = qtypes.QuantumProgram(description='hello')
assert cg.EngineProgram('a', 'b', EngineContext()).description() == 'hello'
get_program.assert_called_once_with('a', 'b', False)
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', {})
def test_set_description(set_program_description):
program = cg.EngineProgram('a', 'b', EngineContext())
set_program_description.return_value = qtypes.QuantumProgram(description='world')
assert program.set_description('world').description() == 'world'
set_program_description.assert_called_with('a', 'b', 'world')
set_program_description.return_value = qtypes.QuantumProgram(description='')
assert program.set_description('').description() == ''
set_program_description.assert_called_with('a', 'b', '')
def test_list_programs(list_programs):
prog1 = qtypes.QuantumProgram(name='projects/proj/programs/prog-YBGR48THF3JHERZW200804')
prog2 = qtypes.QuantumProgram(name='projects/otherproj/programs/prog-V3ZRTV6TTAFNTYJV200804')
list_programs.return_value = [prog1, prog2]
result = cg.Engine(project_id='proj').list_programs()
list_programs.assert_called_once_with(
'proj', created_after=None, created_before=None, has_labels=None
)
assert [(p.program_id, p.project_id, p._program) for p in result] == [
('prog-YBGR48THF3JHERZW200804', 'proj', prog1),
('prog-V3ZRTV6TTAFNTYJV200804', 'otherproj', prog2),
]
def test_list_program(client_constructor):
grpc_client = setup_mock_(client_constructor)
results = [
qtypes.QuantumProgram(name='projects/proj/programs/prog1'),
qtypes.QuantumProgram(name='projects/proj/programs/prog2')
]
grpc_client.list_quantum_programs.return_value = results
client = EngineClient()
assert client.list_programs(project_id='proj') == results
assert grpc_client.list_quantum_programs.call_args[0] == ('projects/proj',)
assert grpc_client.list_quantum_programs.call_args[1] == {
'filter_': '',
}
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_create_program(client):
client().create_program.return_value = ('prog', qtypes.QuantumProgram())
result = cg.Engine(project_id='proj').create_program(_CIRCUIT,
'prog',
gate_set=cg.XMON)
client().create_program.assert_called_once()
assert result.program_id == 'prog'
def test_run_circuit_failed_missing_processor_name(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': 'FAILURE',
'failure': {
'error_code': 'SYSTEM_ERROR',
'error_message': 'Not good'
},
},
)
engine = cg.Engine(project_id='proj')
with pytest.raises(
RuntimeError,
match='Job projects/proj/programs/prog/jobs/job-id on processor'
' UNKNOWN failed. SYSTEM_ERROR: Not good',
):
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_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_labels():
program = cg.EngineProgram(
'a',
'b',
EngineContext(),
_program=qtypes.QuantumProgram(labels={'t': '1'}))
assert program.labels() == {'t': '1'}
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_remove_labels(remove_program_labels):
program = cg.EngineProgram(
'a', 'b', EngineContext(), _program=qtypes.QuantumProgram(labels={'a': '1', 'b': '1'})
)
assert program.labels() == {'a': '1', 'b': '1'}
remove_program_labels.return_value = qtypes.QuantumProgram(
labels={
'b': '1',
}
)
assert program.remove_labels(['a']).labels() == {'b': '1'}
remove_program_labels.assert_called_with('a', 'b', ['a'])
remove_program_labels.return_value = qtypes.QuantumProgram(labels={})
assert program.remove_labels(['a', 'b', 'c']).labels() == {}
remove_program_labels.assert_called_with('a', 'b', ['a', 'b', 'c'])
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_program_labels(client_constructor):
client = mock.Mock()
client_constructor.return_value = client
program_name = 'projects/my-proj/programs/my-prog'
engine = cg.Engine(project_id='project-id')
client.get_quantum_program.return_value = qtypes.QuantumProgram(labels={
'a': '1',
'b': '1'
})
engine.add_program_labels(program_name, {'b': '1'})
engine.remove_program_labels(program_name, ['c'])
assert client.update_quantum_program.call_count == 0
def update():
return client.update_quantum_program.call_args[0][1]
client.get_quantum_program.return_value = qtypes.QuantumProgram(labels={
'a': '1',
'b': '1'
})
engine.add_program_labels(program_name, {'a': '2', 'c': '1'})
assert update().labels == {'a': '2', 'b': '1', 'c': '1'}
assert update().label_fingerprint == ''
client.get_quantum_program.return_value = qtypes.QuantumProgram(
labels={
'a': '1',
'b': '1'
}, label_fingerprint='abcdef')
engine.set_program_labels(program_name, {'s': '1', 'p': '1'})
assert update().labels == {'s': '1', 'p': '1'}
assert update().label_fingerprint == 'abcdef'
client.get_quantum_program.return_value = qtypes.QuantumProgram(
labels={
'a': '1',
'b': '1'
}, label_fingerprint='abcdef')
engine.remove_program_labels(program_name, ['a', 'c'])
assert update().labels == {'b': '1'}
assert update().label_fingerprint == 'abcdef'
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_create_program(client_constructor):
client = mock.Mock()
client_constructor.return_value = client
fake_result = qtypes.QuantumProgram(name='project/my-project/program/foo')
client.create_quantum_program.return_value = fake_result
result = cg.Engine(project_id='my-project').create_program(_CIRCUIT, 'foo')
assert client.create_quantum_program.call_args[0][
1].name == 'projects/my-project/programs/foo'
assert result.resource_name == fake_result.name
def test_set_program_description(client_constructor):
grpc_client = setup_mock_(client_constructor)
result = qtypes.QuantumProgram(name='projects/proj/programs/prog')
grpc_client.update_quantum_program.return_value = result
client = EngineClient()
assert client.set_program_description('proj', 'prog', 'A program') == result
assert grpc_client.update_quantum_program.call_args[0] == (
'projects/proj/programs/prog',
qtypes.QuantumProgram(name='projects/proj/programs/prog',
description='A program'),
qtypes.field_mask_pb2.FieldMask(paths=['description']))
assert client.set_program_description('proj', 'prog', '') == result
assert grpc_client.update_quantum_program.call_args[0] == (
'projects/proj/programs/prog',
qtypes.QuantumProgram(name='projects/proj/programs/prog'),
qtypes.field_mask_pb2.FieldMask(paths=['description']))
def test_get_program(client_constructor):
client = mock.Mock()
client_constructor.return_value = client
fake_result = qtypes.QuantumProgram(name='project/my-project/program/foo')
client.get_quantum_program.return_value = fake_result
result = cg.Engine(project_id='my-project').get_program('foo')
assert client.get_quantum_program.call_args[0][
0] == 'projects/my-project/programs/foo'
assert result == fake_result
def setup_run_circuit_with_result_(client, result):
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=result)
def test_bad_priority(client_constructor):
client = mock.Mock()
client_constructor.return_value = client
client.create_quantum_program.return_value = qtypes.QuantumProgram(
name='projects/project-id/programs/test')
engine = cg.Engine(project_id='project-id',
proto_version=cg.engine.engine.ProtoVersion.V2)
with pytest.raises(ValueError, match='priority must be'):
engine.run(program=_CIRCUIT, priority=1001)
def setup_run_circuit_with_job_state_(client_constructor, job_return_value):
client = mock.Mock()
client_constructor.return_value = client
client.create_quantum_program.return_value = qtypes.QuantumProgram(
name='projects/project-id/programs/test')
client.create_quantum_job.return_value = qtypes.QuantumJob(
name='projects/project-id/programs/test/jobs/test',
execution_status={'state': 'READY'})
client.get_quantum_job.return_value = job_return_value
return client
def test_get_circuit_batch(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=_BATCH_PROGRAM_V2)
with pytest.raises(ValueError, match='A program number must be specified'):
program.get_circuit()
with pytest.raises(ValueError, match='Only 1 in the batch but index 1 was specified'):
program.get_circuit(1)
assert program.get_circuit(0) == circuit
get_program.assert_called_once_with('a', 'b', True)
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_calibration_from_job_with_no_calibration(client_constructor):
client = mock.Mock()
client_constructor.return_value = client
client.create_quantum_program.return_value = qtypes.QuantumProgram(
name='projects/project-id/programs/test')
client.create_quantum_job.return_value = qtypes.QuantumJob(
name='projects/project-id/programs/test/jobs/test',
execution_status={'state': 'SUCCESS'})
engine = cg.Engine(project_id='project-id')
job = engine.run_sweep(program=cirq.Circuit())
calibration = job.get_calibration()
assert not calibration
assert not client.get_quantum_calibration.called
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
