def create_calibration_program(
self,
layers: List['cirq.google.CalibrationLayer'],
program_id: Optional[str] = None,
gate_set: Optional[sgs.SerializableGateSet] = None,
description: Optional[str] = None,
labels: Optional[Dict[str, str]] = None,
) -> engine_program.EngineProgram:
"""Wraps a list of calibration layers into an Any for Quantum Engine.
Args:
layers: The calibration routines to execute. All layers will be
executed within the same API call in the order specified,
though some layers may be interleaved together using
hardware-specific batching.
program_id: A user-provided identifier for the program. This must be
unique within the Google Cloud project being used. If this
parameter is not provided, a random id of the format
'calibration-################YYMMDD' will be generated,
where # is alphanumeric and YYMMDD is the current year, month,
and day.
gate_set: The gate set used to serialize the circuits in each
layer. The gate set must be supported by the processor.
description: An optional description to set on the program.
labels: Optional set of labels to set on the program.
Returns:
A EngineProgram for the newly created program.
"""
if not gate_set:
raise ValueError('Gate set must be specified.')
if not program_id:
program_id = _make_random_id('calibration-')
calibration = v2.calibration_pb2.FocusedCalibration()
for layer in layers:
new_layer = calibration.layers.add()
new_layer.calibration_type = layer.calibration_type
for arg in layer.args:
arg_to_proto(layer.args[arg], out=new_layer.args[arg])
gate_set.serialize(layer.program, msg=new_layer.layer)
new_program_id, new_program = self.context.client.create_program(
self.project_id,
program_id,
code=self._pack_any(calibration),
description=description,
labels=labels,
)
return engine_program.EngineProgram(
self.project_id,
new_program_id,
self.context,
new_program,
result_type=ResultType.Calibration,
)
def to_proto(
self,
op: 'cirq.Operation',
msg: Optional[v2.program_pb2.Operation] = None,
*,
arg_function_language: Optional[str] = '',
constants: List[v2.program_pb2.Constant] = None,
) -> Optional[v2.program_pb2.Operation]:
"""Returns the cirq.google.api.v2.Operation message as a proto dict.
Note that this function may modify the constant list if it adds
tokens to the circuit's constant table.
"""
gate = op.gate
if not isinstance(gate, self.gate_type):
raise ValueError(
'Gate of type {} but serializer expected type {}'.format(
type(gate), self.gate_type))
if not self.can_serialize_predicate(op):
return None
if msg is None:
msg = v2.program_pb2.Operation()
msg.gate.id = self.serialized_gate_id
for qubit in op.qubits:
msg.qubits.add().id = v2.qubit_to_proto_id(qubit)
for arg in self.args:
value = self._value_from_gate(op, arg)
if value is not None and (not arg.default or value != arg.default):
arg_to_proto(
value,
out=msg.args[arg.serialized_name],
arg_function_language=arg_function_language,
)
if self.serialize_tokens:
for tag in op.tags:
if isinstance(tag, CalibrationTag):
if constants is not None:
constant = v2.program_pb2.Constant()
constant.string_value = tag.token
try:
msg.token_constant_index = constants.index(
constant)
except ValueError:
# Token not found, add it to the list
msg.token_constant_index = len(constants)
constants.append(constant)
else:
msg.token_value = tag.token
return msg
def test_serialize_conversion(value: ARG_LIKE, proto: v2.program_pb2.Arg):
msg = v2.program_pb2.Arg()
json_format.ParseDict(proto, msg)
packed = json_format.MessageToDict(arg_to_proto(value,
arg_function_language=''),
including_default_value_fields=True,
preserving_proto_field_name=True,
use_integers_for_enums=True)
assert packed == proto
def test_serialize_sympy_constants():
proto = arg_to_proto(sympy.pi, arg_function_language='')
packed = json_format.MessageToDict(
proto,
including_default_value_fields=True,
preserving_proto_field_name=True,
use_integers_for_enums=True,
)
assert len(packed) == 1
assert len(packed['arg_value']) == 1
# protobuf 3.12+ truncates floats to 4 bytes
assert np.isclose(packed['arg_value']['float_value'], np.float32(sympy.pi), atol=1e-7)
def test_correspondence(min_lang: str, value: ARG_LIKE, proto: v2.program_pb2.Arg):
msg = v2.program_pb2.Arg()
json_format.ParseDict(proto, msg)
min_i = LANGUAGE_ORDER.index(min_lang)
for i, lang in enumerate(LANGUAGE_ORDER):
if i < min_i:
with pytest.raises(ValueError, match='not supported by arg_function_language'):
_ = arg_to_proto(value, arg_function_language=lang)
with pytest.raises(ValueError, match='Unrecognized function type'):
_ = arg_from_proto(msg, arg_function_language=lang)
else:
parsed = arg_from_proto(msg, arg_function_language=lang)
packed = json_format.MessageToDict(
arg_to_proto(value, arg_function_language=lang),
including_default_value_fields=True,
preserving_proto_field_name=True,
use_integers_for_enums=True,
)
assert parsed == value
assert packed == proto
def test_unsupported_function_language():
with pytest.raises(ValueError, match='Unrecognized arg_function_language'):
_ = arg_to_proto(1, arg_function_language='NEVER GONNAH APPEN')
with pytest.raises(ValueError, match='Unrecognized arg_function_language'):
_ = arg_from_proto(None, arg_function_language='NEVER GONNAH APPEN')