def sweep_from_proto(msg: run_context_pb2.Sweep) -> sweeps.Sweep:
"""Creates a Sweep from a v2 protobuf message."""
which = msg.WhichOneof('sweep')
if which is None:
return sweeps.UnitSweep
elif which == 'sweep_function':
factors = [sweep_from_proto(m) for m in msg.sweep_function.sweeps]
func_type = msg.sweep_function.function_type
if func_type == run_context_pb2.SweepFunction.PRODUCT:
return sweeps.Product(*factors)
elif func_type == run_context_pb2.SweepFunction.ZIP:
return sweeps.Zip(*factors)
else:
raise ValueError(
'invalid sweep function type: {}'.format(func_type))
elif which == 'single_sweep':
key = msg.single_sweep.parameter_key
if msg.single_sweep.WhichOneof('sweep') == 'linspace':
return sweeps.Linspace(
key=key,
start=msg.single_sweep.linspace.first_point,
stop=msg.single_sweep.linspace.last_point,
length=msg.single_sweep.linspace.num_points,
)
elif msg.single_sweep.WhichOneof('sweep') == 'points':
return sweeps.Points(key=key,
points=msg.single_sweep.points.points)
else:
raise ValueError('single sweep type not set: {}'.format(msg))
else:
# coverage: ignore
raise ValueError('sweep type not set: {}'.format(msg))
def _sweep_from_single_param_sweep_proto_dict(
single_param_sweep: Dict) -> sweeps.Sweep:
key = single_param_sweep['parameter_key']
if 'points' in single_param_sweep:
points = single_param_sweep['points']
return sweeps.Points(key, list(points['points']))
if 'linspace' in single_param_sweep:
sl = single_param_sweep['linspace']
return sweeps.Linspace(key, sl['first_point'], sl['last_point'],
sl['num_points'])
raise ValueError('Single param sweep type undefined')
def _sweep_from_single_param_sweep_proto(
single_param_sweep: params_pb2.SingleSweep,
) -> sweeps.Sweep:
key = single_param_sweep.parameter_key
if single_param_sweep.HasField('points'):
points = single_param_sweep.points
return sweeps.Points(key, list(points.points))
if single_param_sweep.HasField('linspace'):
sl = single_param_sweep.linspace
return sweeps.Linspace(key, sl.first_point, sl.last_point, sl.num_points)
raise ValueError('Single param sweep type undefined')
def test_job_equality():
eq = EqualsTester()
q = ops.QubitId()
q2 = ops.QubitId()
# Equivalent empty jobs
eq.add_equality_group(Job(), Job(Circuit()), Job(Circuit([])),
Job(Circuit(), sweeps.Unit))
# Equivalent circuit, different instances
eq.add_equality_group(Job(Circuit([Moment([ops.Z(q)])])),
Job(Circuit([Moment([ops.Z(q)])])))
# Different Circuit
c = Circuit([Moment([ops.CZ(q, q2)])])
eq.add_equality_group(Job(c))
ps1 = sweeps.Points('Example', [42.0])
ps2 = sweeps.Points('Example', [42.0])
ps3 = sweeps.Points('Example', [42.0, 1.4])
eq.add_equality_group(Job(c, ps1, 2), Job(c, ps2, 2))
eq.add_equality_group(Job(c, ps1, 4))
eq.add_equality_group(Job(c, ps3, 2))
def sweep_to_proto(
sweep: sweeps.Sweep,
*,
out: Optional[run_context_pb2.Sweep] = None,
) -> run_context_pb2.Sweep:
"""Converts a Sweep to v2 protobuf message.
Args:
sweep: The sweep to convert.
out: Optional message to be populated. If not given, a new message will
be created.
Returns:
Populated sweep protobuf message.
"""
if out is None:
out = run_context_pb2.Sweep()
if sweep is sweeps.UnitSweep:
pass
elif isinstance(sweep, sweeps.Product):
out.sweep_function.function_type = run_context_pb2.SweepFunction.PRODUCT
for factor in sweep.factors:
sweep_to_proto(factor, out=out.sweep_function.sweeps.add())
elif isinstance(sweep, sweeps.Zip):
out.sweep_function.function_type = run_context_pb2.SweepFunction.ZIP
for s in sweep.sweeps:
sweep_to_proto(s, out=out.sweep_function.sweeps.add())
elif isinstance(sweep, sweeps.Linspace):
out.single_sweep.parameter_key = sweep.key
out.single_sweep.linspace.first_point = sweep.start
out.single_sweep.linspace.last_point = sweep.stop
out.single_sweep.linspace.num_points = sweep.length
elif isinstance(sweep, sweeps.Points):
out.single_sweep.parameter_key = sweep.key
out.single_sweep.points.points.extend(sweep.points)
elif isinstance(sweep, sweeps.ListSweep):
sweep_dict: Dict[str, List[value.TParamVal]] = {}
for param_resolver in sweep:
for key in param_resolver:
if key not in sweep_dict:
sweep_dict[key] = []
sweep_dict[key].append(param_resolver.value_of(key))
out.sweep_function.function_type = run_context_pb2.SweepFunction.ZIP
for key in sweep_dict:
sweep_to_proto(sweeps.Points(key, sweep_dict[key]),
out=out.sweep_function.sweeps.add())
else:
raise ValueError(f'cannot convert to v2 Sweep proto: {sweep}')
return out
