def test_get_device_specification():
processor = cg.EngineProcessor('a',
'p',
EngineContext(),
_processor=qtypes.QuantumProcessor())
assert not processor.get_device_specification()
# Construct expected device proto based on example
expected = v2.device_pb2.DeviceSpecification()
gs = expected.valid_gate_sets.add()
gs.name = 'test_set'
gates = gs.valid_gates.add()
gates.id = 'x'
gates.number_of_qubits = 1
gates.gate_duration_picos = 1000
gates.valid_targets.extend(['1q_targets'])
expected.valid_qubits.extend(['0_0', '1_1'])
target = expected.valid_targets.add()
target.name = '1q_targets'
target.target_ordering = v2.device_pb2.TargetSet.SYMMETRIC
new_target = target.targets.add()
new_target.ids.extend(['0_0'])
processor = cg.EngineProcessor(
'a',
'p',
EngineContext(),
_processor=qtypes.QuantumProcessor(device_spec=_DEVICE_SPEC))
assert processor.get_device_specification() == expected
def test_list_processors(list_processors):
processor1 = qtypes.QuantumProcessor(name='projects/proj/processors/xmonsim')
processor2 = qtypes.QuantumProcessor(name='projects/proj/processors/gmonsim')
list_processors.return_value = [processor1, processor2]
result = cg.Engine(project_id='proj').list_processors()
list_processors.assert_called_once_with('proj')
assert [p.processor_id for p in result] == ['xmonsim', 'gmonsim']
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_supported_languages():
processor = cg.EngineProcessor('a', 'p', EngineContext(), _processor=qtypes.QuantumProcessor())
assert processor.supported_languages() == []
processor = cg.EngineProcessor(
'a',
'p',
EngineContext(),
_processor=qtypes.QuantumProcessor(supported_languages=['lang1', 'lang2']),
)
assert processor.supported_languages() == ['lang1', 'lang2']
def test_expected_down_time(get_processor):
processor = cg.EngineProcessor('a', 'p', EngineContext(), _processor=qtypes.QuantumProcessor())
assert not processor.expected_down_time()
get_processor.return_value = qtypes.QuantumProcessor(
expected_down_time=qtypes.timestamp_pb2.Timestamp(seconds=1581515101)
)
assert cg.EngineProcessor('a', 'p', EngineContext()).expected_down_time() == datetime.datetime(
2020, 2, 12, 13, 45, 1
)
get_processor.assert_called_once()
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_list_processors(client_constructor):
grpc_client = setup_mock_(client_constructor)
results = [
qtypes.QuantumProcessor(name='projects/proj/processor/processor0'),
qtypes.QuantumProcessor(name='projects/proj/processor/processor1')
]
grpc_client.list_quantum_processors.return_value = results
client = EngineClient()
assert client.list_processors('proj') == results
assert grpc_client.list_quantum_processors.call_args[0] == (
'projects/proj', '')
def test_list_processors(client_constructor):
client = mock.Mock()
client_constructor.return_value = client
PROCESSOR1 = qtypes.QuantumProcessor(
name='projects/myproject/processors/xmonsim'),
PROCESSOR2 = qtypes.QuantumProcessor(
name='projects/myproject/processors/gmonsin'),
client.list_quantum_processors.return_value = [PROCESSOR1, PROCESSOR2]
result = cg.Engine(project_id='myproject').list_processors()
assert client.list_quantum_processors.call_args[0][
0] == 'projects/myproject'
assert result == [PROCESSOR1, PROCESSOR2]
def test_device_specification(client_constructor):
client = mock.Mock()
client_constructor.return_value = client
client.get_quantum_processor.return_value = qtypes.QuantumProcessor(
device_spec=_DEVICE_SPEC)
device_spec = cg.Engine(
project_id='myproject').get_device_specification('x')
assert client.get_quantum_processor.call_args[0][
0] == 'projects/myproject/processors/x'
# Construct expected device proto based on example
expected = v2.device_pb2.DeviceSpecification()
gs = expected.valid_gate_sets.add()
gs.name = 'test_set'
gates = gs.valid_gates.add()
gates.id = 'x'
gates.number_of_qubits = 1
gates.gate_duration_picos = 1000
gates.valid_targets.extend(['1q_targets'])
expected.valid_qubits.extend(['0_0', '1_1'])
target = expected.valid_targets.add()
target.name = '1q_targets'
target.target_ordering = v2.device_pb2.TargetSet.SYMMETRIC
new_target = target.targets.add()
new_target.ids.extend(['0_0'])
assert device_spec == expected
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_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_missing_device_specification(client_constructor):
client = mock.Mock()
client_constructor.return_value = client
client.get_quantum_processor.return_value = qtypes.QuantumProcessor()
device_spec = cg.Engine(
project_id='myproject').get_device_specification('x')
assert client.get_quantum_processor.call_args[0][
0] == 'projects/myproject/processors/x'
assert device_spec == v2.device_pb2.DeviceSpecification()
def test_get_processor(client_constructor):
grpc_client = setup_mock_(client_constructor)
result = qtypes.QuantumProcessor(name='projects/proj/processors/processor0')
grpc_client.get_quantum_processor.return_value = result
client = EngineClient()
assert client.get_processor('proj', 'processor0') == result
assert grpc_client.get_quantum_processor.call_args[0] == (
'projects/proj/processors/processor0',)
def test_get_device():
processor = cg.EngineProcessor(
'a', 'p', EngineContext(), _processor=qtypes.QuantumProcessor(device_spec=_DEVICE_SPEC)
)
device = processor.get_device(gate_sets=[_GATE_SET])
assert device.qubits == [cirq.GridQubit(0, 0), cirq.GridQubit(1, 1)]
device.validate_operation(cirq.X(cirq.GridQubit(0, 0)))
with pytest.raises(ValueError):
device.validate_operation(cirq.X(cirq.GridQubit(1, 2)))
with pytest.raises(ValueError):
device.validate_operation(cirq.Y(cirq.GridQubit(0, 0)))
def test_get_engine_device(get_processor):
device_spec = _to_any(
Merge(
"""
valid_gate_sets: [{
name: 'test_set',
valid_gates: [{
id: 'x',
number_of_qubits: 1,
gate_duration_picos: 1000,
valid_targets: ['1q_targets']
}]
}],
valid_qubits: ['0_0', '1_1'],
valid_targets: [{
name: '1q_targets',
target_ordering: SYMMETRIC,
targets: [{
ids: ['0_0']
}]
}]
""",
v2.device_pb2.DeviceSpecification(),
))
gate_set = cg.SerializableGateSet(
gate_set_name='x_gate_set',
serializers=[
cg.GateOpSerializer(gate_type=cirq.XPowGate,
serialized_gate_id='x',
args=[])
],
deserializers=[
cg.GateOpDeserializer(serialized_gate_id='x',
gate_constructor=cirq.XPowGate,
args=[])
],
)
get_processor.return_value = qtypes.QuantumProcessor(
device_spec=device_spec)
device = cirq.google.get_engine_device('rainbow',
'project',
gatesets=[gate_set])
assert set(device.qubits) == {cirq.GridQubit(0, 0), cirq.GridQubit(1, 1)}
device.validate_operation(cirq.X(cirq.GridQubit(0, 0)))
with pytest.raises(ValueError):
device.validate_operation(cirq.X(cirq.GridQubit(1, 2)))
with pytest.raises(ValueError):
device.validate_operation(cirq.Y(cirq.GridQubit(0, 0)))
def test_remove_reservation_cancel(cancel_reservation, get_reservation):
name = 'projects/proj/processors/p0/reservations/rid'
now = int(datetime.datetime.now().timestamp())
result = qtypes.QuantumReservation(
name=name,
start_time=Timestamp(seconds=now + 10),
end_time=Timestamp(seconds=now + 3610),
whitelisted_users=['*****@*****.**'],
)
get_reservation.return_value = result
cancel_reservation.return_value = result
processor = cg.EngineProcessor(
'proj', 'p0', EngineContext(),
qtypes.QuantumProcessor(schedule_frozen_period=Duration(seconds=10000)))
assert processor.remove_reservation('rid') == result
cancel_reservation.assert_called_once_with('proj', 'p0', 'rid')
def test_remove_reservation_failures(get_reservation, get_processor):
name = 'projects/proj/processors/p0/reservations/rid'
now = int(datetime.datetime.now().timestamp())
result = qtypes.QuantumReservation(
name=name,
start_time=Timestamp(seconds=now + 10),
end_time=Timestamp(seconds=now + 3610),
whitelisted_users=['*****@*****.**'],
)
get_reservation.return_value = result
get_processor.return_value = None
# no processor
processor = cg.EngineProcessor('proj', 'p0', EngineContext())
with pytest.raises(ValueError):
processor.remove_reservation('rid')
# No freeze period defined
processor = cg.EngineProcessor('proj', 'p0', EngineContext(), qtypes.QuantumProcessor())
with pytest.raises(ValueError):
processor.remove_reservation('rid')
