def test_deserialize_all_features(self):
body_str = 'dt'
dt = DummyPulseTemplate(parameter_names={'i'})
measurements = [('a', 0, 1), ('b', 1, 1)]
parameter_constraints = ['foo < 3']
def make_dt(ident: str):
self.assertEqual(body_str, ident)
return ident
data = dict(body=body_str,
loop_range=('A', 'B', 1),
loop_index='i',
identifier='meh',
measurements=measurements,
parameter_constraints=parameter_constraints)
serializer = DummySerializer(deserialize_callback=make_dt)
serializer.subelements['dt'] = dt
flt = ForLoopPulseTemplate.deserialize(serializer, **data)
self.assertEqual(flt.identifier, 'meh')
self.assertIs(flt.body, dt)
self.assertEqual(flt.loop_index, 'i')
self.assertEqual(flt.loop_range.to_tuple(), ('A', 'B', 1))
self.assertEqual(flt.measurement_declarations, measurements)
self.assertEqual([str(c) for c in flt.parameter_constraints], parameter_constraints)
def test_deserialize_all_features_old(self) -> None:
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(DeprecationWarning, "deprecated",
msg="ForLoopPT does not issue warning for old serialization routines."):
body_str = 'dt'
dt = DummyPulseTemplate(parameter_names={'i'})
measurements = [('a', 0, 1), ('b', 1, 1)]
parameter_constraints = ['foo < 3']
def make_dt(ident: str):
self.assertEqual(body_str, ident)
return ident
data = dict(body=body_str,
loop_range=('A', 'B', 1),
loop_index='i',
identifier='meh',
measurements=measurements,
parameter_constraints=parameter_constraints)
serializer = DummySerializer(deserialize_callback=make_dt)
serializer.subelements['dt'] = dt
flt = ForLoopPulseTemplate.deserialize(serializer, **data)
self.assertEqual(flt.identifier, 'meh')
self.assertIs(flt.body, dt)
self.assertEqual(flt.loop_index, 'i')
self.assertEqual(flt.loop_range.to_tuple(), ('A', 'B', 1))
self.assertEqual(flt.measurement_declarations, measurements)
self.assertEqual([str(c) for c in flt.parameter_constraints], parameter_constraints)
def test_deserialize_minimal_old(self) -> None:
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(
DeprecationWarning,
"deprecated",
msg=
"ForLoopPT does not issue warning for old serialization routines."
):
body_str = 'dt'
dt = DummyPulseTemplate(parameter_names={'i'})
def make_dt(ident: str):
self.assertEqual(body_str, ident)
return ident
data = dict(body=body_str,
loop_range=('A', 'B', 1),
loop_index='i',
identifier='meh')
serializer = DummySerializer(deserialize_callback=make_dt)
serializer.subelements['dt'] = dt
flt = ForLoopPulseTemplate.deserialize(serializer, **data)
self.assertEqual(flt.identifier, 'meh')
self.assertEqual(flt.body, dt)
self.assertEqual(flt.loop_index, 'i')
self.assertEqual(flt.loop_range.to_tuple(), ('A', 'B', 1))
def test_get_serialization_data(self) -> None:
constant_parameter = ConstantParameter(-0.2)
serializer = DummySerializer()
data = constant_parameter.get_serialization_data(serializer)
self.assertEqual(
dict(type=serializer.get_type_identifier(constant_parameter),
constant=-0.2), data)
def test_deserialize_old(self) -> None:
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(DeprecationWarning, "deprecated",
msg="AtomicMultiChannelPT does not issue warning for old serialization routines."):
sts = [DummyPulseTemplate(duration='t1', defined_channels={'A'}, parameter_names={'a', 'b'}),
DummyPulseTemplate(duration='t1', defined_channels={'B'}, parameter_names={'a', 'c'})]
def deserialization_callback(ident: str):
self.assertIn(ident, ('0', '1'))
if ident == '0':
return 0
else:
return 1
serializer = DummySerializer(deserialize_callback=deserialization_callback)
serializer.subelements = sts
data = dict(subtemplates=['0', '1'], parameter_constraints=['a < d'])
template = AtomicMultiChannelPulseTemplate.deserialize(serializer, **data)
self.assertIs(template.subtemplates[0], sts[0])
self.assertIs(template.subtemplates[1], sts[1])
self.assertEqual(template.parameter_constraints, [ParameterConstraint('a < d')])
def setUp(self) -> None:
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(
DeprecationWarning,
"deprecated",
msg=
"TablePT does not issue warning for old serialization routines."
):
self.serializer = DummySerializer(lambda x: dict(name=x.name),
lambda x: x.name,
lambda x: x['name'])
self.entries = dict(A=[('foo', 2, 'hold'),
('hugo', 'ilse', 'linear')],
B=[(0, 5, 'hold'), (1, 7, 'jump'),
('k', 't', 'hold')])
self.measurements = [('m', 1, 1), ('foo', 'z', 'o')]
self.template = TablePulseTemplate(
entries=self.entries,
measurements=self.measurements,
identifier='foo',
parameter_constraints=['ilse>2', 'k>foo'],
registry=dict())
self.expected_data = dict(
type=self.serializer.get_type_identifier(self.template))
self.maxDiff = None
def test_deserialize_all_features_old(self) -> None:
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(
DeprecationWarning,
"deprecated",
msg=
"RepetitionPT does not issue warning for old serialization routines."
):
serializer = DummySerializer(
deserialize_callback=lambda x: x['name'])
body = DummyPulseTemplate()
data = dict(repetition_count='foo',
body=dict(name=str(id(body))),
identifier='foo',
parameter_constraints=['foo < 3'],
measurements=[('a', 0, 1), ('b', 1, 1)])
# prepare dependencies for deserialization
serializer.subelements[str(id(body))] = body
# deserialize
template = RepetitionPulseTemplate.deserialize(serializer, **data)
# compare!
self.assertIs(body, template.body)
self.assertEqual('foo', template.repetition_count)
self.assertEqual(template.parameter_constraints,
[ParameterConstraint('foo < 3')])
self.assertEqual(template.measurement_declarations,
data['measurements'])
def test_deserialize_old(self) -> None:
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(
DeprecationWarning,
"deprecated",
msg=
"SequencePT does not issue warning for old serialization routines."
):
dummy1 = DummyPulseTemplate()
dummy2 = DummyPulseTemplate()
serializer = DummySerializer(
serialize_callback=lambda x: str(id(x)))
data = dict(subtemplates=[
serializer.dictify(dummy1),
serializer.dictify(dummy2)
],
identifier='foo',
parameter_constraints=['a < b'],
measurements=[('m', 0, 1)])
template = SequencePulseTemplate.deserialize(serializer, **data)
self.assertEqual(template.subtemplates, [dummy1, dummy2])
self.assertEqual(template.parameter_constraints,
[ParameterConstraint('a<b')])
self.assertEqual(template.measurement_declarations, [('m', 0, 1)])
def test_get_serialization_data(self) -> None:
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(DeprecationWarning, "deprecated",
msg="SequencePT does not issue warning for old serialization routines."):
dummy_pt = DummyPulseTemplate(defined_channels={'foo'},
measurement_names={'meas'},
parameter_names={'hugo', 'herbert', 'ilse'})
mpt = MappingPulseTemplate(
template=dummy_pt,
parameter_mapping={'hugo': Expression('2*k+c'), 'herbert': Expression('c-1.5'), 'ilse': Expression('ilse')},
measurement_mapping={'meas': 'seam'},
channel_mapping={'foo': 'default_channel'},
parameter_constraints=[str(ParameterConstraint('c > 0'))]
)
serializer = DummySerializer()
expected_data = {
'template': serializer.dictify(dummy_pt),
'parameter_mapping': {'hugo': str(Expression('2*k+c')), 'herbert': str(Expression('c-1.5')),
'ilse': str(Expression('ilse'))},
'measurement_mapping': {'meas': 'seam'},
'channel_mapping': {'foo': 'default_channel'},
'parameter_constraints': [str(ParameterConstraint('c > 0'))]
}
data = mpt.get_serialization_data(serializer=serializer)
self.assertEqual(expected_data, data)
def test_deserialize(self) -> None:
dummy1 = DummyPulseTemplate(parameter_names={'foo'}, num_channels=2)
dummy2 = DummyPulseTemplate(parameter_names={}, num_channels=1)
exp = Expression("bar - 35")
data = dict(external_parameters=['bar'],
subtemplates=[
dict(template=str(id(dummy1)),
parameter_mappings=dict(foo=str(exp)),
channel_mappings=[0, 2]),
dict(template=str(id(dummy2)),
parameter_mappings=dict(),
channel_mappings=[1])
])
serializer = DummySerializer(serialize_callback=lambda x: str(x) if
isinstance(x, Expression) else str(id(x)))
serializer.subelements[str(id(dummy1))] = dummy1
serializer.subelements[str(id(dummy2))] = dummy2
serializer.subelements[str(exp)] = exp
template = MultiChannelPulseTemplate.deserialize(serializer, **data)
self.assertEqual(set(data['external_parameters']),
template.parameter_names)
self.assertEqual({ParameterDeclaration('bar')},
template.parameter_declarations)
recovered_data = template.get_serialization_data(serializer)
self.assertEqual(data, recovered_data)
def test_get_serialization_data(self) -> None:
exp = Expression("foo + bar * hugo")
p = MappedParameter(exp)
serializer = DummySerializer()
data = p.get_serialization_data(serializer)
self.assertEqual(
dict(type=serializer.get_type_identifier(p),
expression=str(id(exp))), data)
class RepetitionPulseTemplateSerializationTests(unittest.TestCase):
def setUp(self) -> None:
self.serializer = DummySerializer(deserialize_callback=lambda x: x['name'])
self.body = DummyPulseTemplate()
def test_get_serialization_data_constant(self) -> None:
repetition_count = 3
template = RepetitionPulseTemplate(self.body, repetition_count)
expected_data = dict(
type=self.serializer.get_type_identifier(template),
body=str(id(self.body)),
repetition_count=repetition_count
)
data = template.get_serialization_data(self.serializer)
self.assertEqual(expected_data, data)
def test_get_serialization_data_declaration(self) -> None:
repetition_count = ParameterDeclaration('foo')
template = RepetitionPulseTemplate(self.body, repetition_count)
expected_data = dict(
type=self.serializer.get_type_identifier(template),
body=str(id(self.body)),
repetition_count=str(id(repetition_count))
)
data = template.get_serialization_data(self.serializer)
self.assertEqual(expected_data, data)
def test_deserialize_constant(self) -> None:
repetition_count = 3
data = dict(
repetition_count=repetition_count,
body=dict(name=str(id(self.body))),
identifier='foo'
)
# prepare dependencies for deserialization
self.serializer.subelements[str(id(self.body))] = self.body
# deserialize
template = RepetitionPulseTemplate.deserialize(self.serializer, **data)
# compare!
self.assertEqual(self.body, template.body)
self.assertEqual(repetition_count, template.repetition_count)
def test_deserialize_declaration(self) -> None:
repetition_count = ParameterDeclaration('foo')
data = dict(
repetition_count=dict(name='foo'),
body=dict(name=str(id(self.body))),
identifier='foo'
)
# prepare dependencies for deserialization
self.serializer.subelements[str(id(self.body))] = self.body
self.serializer.subelements['foo'] = repetition_count
# deserialize
template = RepetitionPulseTemplate.deserialize(self.serializer, **data)
# compare!
self.assertEqual(self.body, template.body)
self.assertEqual(repetition_count, template.repetition_count)
class RepetitionPulseTemplateSerializationTests(unittest.TestCase):
def setUp(self) -> None:
self.serializer = DummySerializer(deserialize_callback=lambda x: x['name'])
self.body = DummyPulseTemplate()
def test_get_serialization_data_constant(self) -> None:
repetition_count = 3
template = RepetitionPulseTemplate(self.body, repetition_count)
expected_data = dict(
type=self.serializer.get_type_identifier(template),
body=str(id(self.body)),
repetition_count=repetition_count
)
data = template.get_serialization_data(self.serializer)
self.assertEqual(expected_data, data)
def test_get_serialization_data_declaration(self) -> None:
repetition_count = ParameterDeclaration('foo')
template = RepetitionPulseTemplate(self.body, repetition_count)
expected_data = dict(
type=self.serializer.get_type_identifier(template),
body=str(id(self.body)),
repetition_count=str(id(repetition_count))
)
data = template.get_serialization_data(self.serializer)
self.assertEqual(expected_data, data)
def test_deserialize_constant(self) -> None:
repetition_count = 3
data = dict(
repetition_count=repetition_count,
body=dict(name=str(id(self.body))),
identifier='foo'
)
# prepare dependencies for deserialization
self.serializer.subelements[str(id(self.body))] = self.body
# deserialize
template = RepetitionPulseTemplate.deserialize(self.serializer, **data)
# compare!
self.assertEqual(self.body, template.body)
self.assertEqual(repetition_count, template.repetition_count)
def test_deserialize_declaration(self) -> None:
repetition_count = ParameterDeclaration('foo')
data = dict(
repetition_count=dict(name='foo'),
body=dict(name=str(id(self.body))),
identifier='foo'
)
# prepare dependencies for deserialization
self.serializer.subelements[str(id(self.body))] = self.body
self.serializer.subelements['foo'] = repetition_count
# deserialize
template = RepetitionPulseTemplate.deserialize(self.serializer, **data)
# compare!
self.assertEqual(self.body, template.body)
self.assertEqual(repetition_count, template.repetition_count)
def test_get_serialization_data(self) -> None:
body = DummyPulseTemplate()
condition_name = 'foo_cond'
identifier = 'foo_loop'
t = LoopPulseTemplate(condition_name, body, identifier=identifier)
serializer = DummySerializer()
expected_data = dict(type=serializer.get_type_identifier(t),
body=str(id(body)),
condition=condition_name)
data = t.get_serialization_data(serializer)
self.assertEqual(expected_data, data)
def test_get_serialization_data(self) -> None:
body = DummyPulseTemplate()
condition_name = 'foo_cond'
identifier = 'foo_loop'
t = WhileLoopPulseTemplate(condition_name, body, identifier=identifier)
serializer = DummySerializer()
expected_data = dict(type=serializer.get_type_identifier(t),
body=str(id(body)),
condition=condition_name)
data = t.get_serialization_data(serializer)
self.assertEqual(expected_data, data)
def setUp(self) -> None:
self.serializer = DummySerializer(lambda x: dict(name=x.name),
lambda x: x.name,
lambda x: x['name'])
self.entries = [('foo', 2, 'hold'), ('hugo', 'A + B', 'linear')]
self.measurements = [('m', 1, 1), ('foo', 'z', 'o')]
self.template = PointPulseTemplate(
time_point_tuple_list=self.entries,
channel_names=[0, 'A'],
measurements=self.measurements,
identifier='foo',
parameter_constraints=['ilse>2', 'k>foo'])
self.expected_data = dict(
type=self.serializer.get_type_identifier(self.template))
self.maxDiff = None
def test_get_serialization_data_all_features_old(self) -> None:
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(
DeprecationWarning,
"deprecated",
msg=
"ForLoopPT does not issue warning for old serialization routines."
):
measurements = [('a', 0, 1), ('b', 1, 1)]
parameter_constraints = ['foo < 3']
dt = DummyPulseTemplate(parameter_names={'i'})
flt = ForLoopPulseTemplate(
body=dt,
loop_index='i',
loop_range=('A', 'B'),
measurements=measurements,
parameter_constraints=parameter_constraints)
def check_dt(to_dictify) -> str:
self.assertIs(to_dictify, dt)
return 'dt'
serializer = DummySerializer(serialize_callback=check_dt)
data = flt.get_serialization_data(serializer)
expected_data = dict(body='dt',
loop_range=('A', 'B', 1),
loop_index='i',
measurements=measurements,
parameter_constraints=parameter_constraints)
self.assertEqual(data, expected_data)
def test_deserialize_old(self) -> None:
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(
DeprecationWarning,
"deprecated",
msg=
"FunctionPT does not issue warning for old serialization routines."
):
basic_data = dict(duration_expression=str(self.s2),
expression=self.s,
channel='A',
identifier='hugo',
measurement_declarations=self.meas_list,
parameter_constraints=self.constraints)
serializer = DummySerializer(
serialize_callback=lambda x: x.original_expression)
serializer.subelements[self.s2] = Expression(self.s2)
serializer.subelements[self.s] = Expression(self.s)
template = FunctionPulseTemplate.deserialize(
serializer, **basic_data)
self.assertEqual('hugo', template.identifier)
self.assertEqual({'a', 'b', 'c', 'x', 'z', 'j', 'u', 'd'},
template.parameter_names)
self.assertEqual(template.measurement_declarations, self.meas_list)
serialized_data = template.get_serialization_data(serializer)
del basic_data['identifier']
self.assertEqual(basic_data, serialized_data)
def test_get_serialization_data_all_features_old(self) -> None:
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(
DeprecationWarning,
"deprecated",
msg=
"RepetitionPT does not issue warning for old serialization routines."
):
serializer = DummySerializer(
deserialize_callback=lambda x: x['name'])
body = DummyPulseTemplate()
repetition_count = 'foo'
measurements = [('a', 0, 1), ('b', 1, 1)]
parameter_constraints = ['foo < 3']
template = RepetitionPulseTemplate(
body,
repetition_count,
measurements=measurements,
parameter_constraints=parameter_constraints)
expected_data = dict(body=str(id(body)),
repetition_count=repetition_count,
measurements=measurements,
parameter_constraints=parameter_constraints)
data = template.get_serialization_data(serializer)
self.assertEqual(expected_data, data)
def test_deserialize_old(self) -> None:
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(
DeprecationWarning,
"deprecated",
msg=
"PointPT does not issue warning for old serialization routines."
):
data = dict(measurements=self.measurements,
time_point_tuple_list=self.entries,
channel_names=(0, 'A'),
parameter_constraints=['ilse>2', 'k>foo'],
identifier='foo')
# deserialize
serializer = DummySerializer(lambda x: dict(name=x.name),
lambda x: x.name, lambda x: x['name'])
template = PointPulseTemplate.deserialize(serializer, **data)
self.assertEqual(template.point_pulse_entries,
self.template.point_pulse_entries)
self.assertEqual(template.measurement_declarations,
self.template.measurement_declarations)
self.assertEqual(template.parameter_constraints,
self.template.parameter_constraints)
def setUp(self) -> None:
self.serializer = DummySerializer(lambda x: dict(name=x.name),
lambda x: x.name,
lambda x: x['name'])
self.entries = dict(A=[('foo', 2, 'hold'), ('hugo', 'ilse', 'linear')],
B=[(0, 5, 'hold'), (1, 7, 'jump'),
('k', 't', 'hold')])
self.measurements = [('m', 1, 1), ('foo', 'z', 'o')]
self.template = TablePulseTemplate(
entries=self.entries,
measurements=self.measurements,
identifier='foo',
parameter_constraints=['ilse>2', 'k>foo'])
self.expected_data = dict(
type=self.serializer.get_type_identifier(self.template))
self.maxDiff = None
def test_serialize_old(self) -> None:
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(
DeprecationWarning,
"deprecated",
msg=
"AtomicMultiChannelPT does not issue warning for old serialization routines."
):
sts = [
DummyPulseTemplate(duration='t1',
defined_channels={'A'},
parameter_names={'a', 'b'}),
DummyPulseTemplate(duration='t1',
defined_channels={'B'},
parameter_names={'a', 'c'})
]
constraints = ['a < d']
template = AtomicMultiChannelPulseTemplate(
*sts, parameter_constraints=constraints)
expected_data = dict(subtemplates=['0', '1'],
parameter_constraints=['a < d'])
def serialize_callback(obj) -> str:
self.assertIn(obj, sts)
return str(sts.index(obj))
serializer = DummySerializer(
serialize_callback=serialize_callback,
identifier_callback=serialize_callback)
data = template.get_serialization_data(serializer=serializer)
self.assertEqual(expected_data, data)
class TablePulseTemplateOldSerializationTests(unittest.TestCase):
def setUp(self) -> None:
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(DeprecationWarning, "deprecated",
msg="TablePT does not issue warning for old serialization routines."):
self.serializer = DummySerializer(lambda x: dict(name=x.name), lambda x: x.name, lambda x: x['name'])
self.entries = dict(A=[('foo', 2, 'hold'), ('hugo', 'ilse', 'linear')],
B=[(0, 5, 'hold'), (1, 7, 'jump'), ('k', 't', 'hold')])
self.measurements = [('m', 1, 1), ('foo', 'z', 'o')]
self.template = TablePulseTemplate(entries=self.entries,
measurements=self.measurements,
identifier='foo', parameter_constraints=['ilse>2', 'k>foo'],
registry=dict())
self.expected_data = dict(type=self.serializer.get_type_identifier(self.template))
self.maxDiff = None
def test_get_serialization_data_old(self) -> None:
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(DeprecationWarning, "deprecated",
msg="TablePT does not issue warning for old serialization routines."):
expected_data = dict(measurements=self.measurements,
entries=self.entries,
parameter_constraints=[str(Expression('ilse>2')), str(Expression('k>foo'))])
data = self.template.get_serialization_data(self.serializer)
self.assertEqual(expected_data, data)
def test_deserialize_old(self) -> None:
registry = dict()
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(DeprecationWarning, "deprecated",
msg="TablePT does not issue warning for old serialization routines."):
data = dict(measurements=self.measurements,
entries=self.entries,
parameter_constraints=['ilse>2', 'k>foo'],
identifier='foo')
# deserialize
template = TablePulseTemplate.deserialize(self.serializer, **data, registry=registry)
self.assertEqual(template.entries, self.template.entries)
self.assertEqual(template.measurement_declarations, self.template.measurement_declarations)
self.assertEqual(template.parameter_constraints, self.template.parameter_constraints)
def test_serializer_integration_old(self):
registry = dict()
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(DeprecationWarning, "deprecated",
msg="TablePT does not issue warning for old serialization routines."):
serializer = Serializer(DummyStorageBackend())
serializer.serialize(self.template)
template = serializer.deserialize('foo')
self.assertIsInstance(template, TablePulseTemplate)
self.assertEqual(template.entries, self.template.entries)
self.assertEqual(template.measurement_declarations, self.template.measurement_declarations)
self.assertEqual(template.parameter_constraints, self.template.parameter_constraints)
def test_deserialize(self) -> None:
data = dict(identifier='foo_loop',
condition='foo_cond',
body='bodyDummyPulse')
# prepare dependencies for deserialization
serializer = DummySerializer()
serializer.subelements[data['body']] = DummyPulseTemplate()
# deserialize
result = LoopPulseTemplate.deserialize(serializer, **data)
# compare
self.assertIs(serializer.subelements[data['body']], result.body)
self.assertEqual(data['condition'], result.condition)
self.assertEqual(data['identifier'], result.identifier)
def test_serialization_data(self) -> None:
expected_data = dict(duration_expression=str(self.s2),
expression=str(self.s),
measurement=False)
self.assertEqual(
expected_data,
self.fpt.get_serialization_data(
DummySerializer(serialize_callback=lambda x: str(x))))
def test_deserialize(self) -> None:
dummy1 = DummyPulseTemplate()
dummy2 = DummyPulseTemplate()
serializer = DummySerializer(serialize_callback=lambda x: str(id(x)))
data = dict(subtemplates=[
serializer.dictify(dummy1),
serializer.dictify(dummy2)
],
identifier='foo',
parameter_constraints=['a<b'])
template = SequencePulseTemplate.deserialize(serializer, **data)
self.assertEqual(template.subtemplates, [dummy1, dummy2])
self.assertEqual(template.parameter_constraints,
[ParameterConstraint('a<b')])
class PointPulseTemplateSerializationTests(unittest.TestCase):
def setUp(self) -> None:
self.serializer = DummySerializer(lambda x: dict(name=x.name),
lambda x: x.name,
lambda x: x['name'])
self.entries = [('foo', 2, 'hold'), ('hugo', 'A + B', 'linear')]
self.measurements = [('m', 1, 1), ('foo', 'z', 'o')]
self.template = PointPulseTemplate(
time_point_tuple_list=self.entries,
channel_names=[0, 'A'],
measurements=self.measurements,
identifier='foo',
parameter_constraints=['ilse>2', 'k>foo'])
self.expected_data = dict(
type=self.serializer.get_type_identifier(self.template))
self.maxDiff = None
def test_get_serialization_data(self) -> None:
expected_data = dict(measurements=self.measurements,
time_point_tuple_list=self.entries,
channel_names=(0, 'A'),
parameter_constraints=[
str(Expression('ilse>2')),
str(Expression('k>foo'))
])
data = self.template.get_serialization_data(self.serializer)
self.assertEqual(expected_data, data)
def test_deserialize(self) -> None:
data = dict(measurements=self.measurements,
time_point_tuple_list=self.entries,
channel_names=(0, 'A'),
parameter_constraints=['ilse>2', 'k>foo'],
identifier='foo')
# deserialize
template = PointPulseTemplate.deserialize(self.serializer, **data)
self.assertEqual(template.point_pulse_entries,
self.template.point_pulse_entries)
self.assertEqual(template.measurement_declarations,
self.template.measurement_declarations)
self.assertEqual(template.parameter_constraints,
self.template.parameter_constraints)
def test_serializer_integration(self):
serializer = Serializer(DummyStorageBackend())
serializer.serialize(self.template)
template = serializer.deserialize('foo')
self.assertIsInstance(template, PointPulseTemplate)
self.assertEqual(template.point_pulse_entries,
self.template.point_pulse_entries)
self.assertEqual(template.measurement_declarations,
self.template.measurement_declarations)
self.assertEqual(template.parameter_constraints,
self.template.parameter_constraints)
def setUp(self) -> None:
self.serializer = DummySerializer()
self.table_foo = TablePulseTemplate(identifier='foo')
self.table_foo.add_entry('hugo', 2)
self.table_foo.add_entry(ParameterDeclaration('albert', max=9.1), 'voltage')
self.table = TablePulseTemplate(measurement=True)
self.foo_mappings = dict(hugo='ilse', albert='albert', voltage='voltage')
def test_deserialize(self) -> None:
data = dict(
identifier='foo_loop',
condition='foo_cond',
body='bodyDummyPulse'
)
# prepare dependencies for deserialization
serializer = DummySerializer()
serializer.subelements[data['body']] = DummyPulseTemplate()
# deserialize
result = LoopPulseTemplate.deserialize(serializer, **data)
# compare
self.assertIs(serializer.subelements[data['body']], result.body)
self.assertEqual(data['condition'], result.condition)
self.assertEqual(data['identifier'], result.identifier)
def test_get_serialization_data(self) -> None:
expected_data = dict(
if_branch_template=str(id(self.if_dummy)),
else_branch_template=str(id(self.else_dummy)),
condition='foo_condition'
)
serializer = DummySerializer()
serialized_data = self.template.get_serialization_data(serializer)
self.assertEqual(expected_data, serialized_data)
class SequencePulseTemplateSerializationTests(unittest.TestCase):
def setUp(self) -> None:
self.serializer = DummySerializer()
self.table_foo = TablePulseTemplate(identifier='foo')
self.table_foo.add_entry('hugo', 2)
self.table_foo.add_entry(ParameterDeclaration('albert', max=9.1), 'voltage')
self.table = TablePulseTemplate(measurement=True)
self.foo_mappings = dict(hugo='ilse', albert='albert', voltage='voltage')
def test_get_serialization_data(self) -> None:
sequence = SequencePulseTemplate([(self.table_foo, self.foo_mappings), (self.table, {})],
['ilse', 'albert', 'voltage'],
identifier='foo')
expected_data = dict(
type=self.serializer.get_type_identifier(sequence),
external_parameters=['albert', 'ilse', 'voltage'],
is_interruptable=True,
subtemplates = [
dict(template=str(id(self.table_foo)), mappings=self.foo_mappings),
dict(template=str(id(self.table)), mappings=dict())
]
)
data = sequence.get_serialization_data(self.serializer)
self.assertEqual(expected_data, data)
def test_deserialize(self) -> None:
data = dict(
external_parameters={'ilse', 'albert', 'voltage'},
is_interruptable=True,
subtemplates = [
dict(template=str(id(self.table_foo)), mappings=self.foo_mappings),
dict(template=str(id(self.table)), mappings=dict())
],
identifier='foo'
)
# prepare dependencies for deserialization
self.serializer.subelements[str(id(self.table_foo))] = self.table_foo
self.serializer.subelements[str(id(self.table))] = self.table
# deserialize
sequence = SequencePulseTemplate.deserialize(self.serializer, **data)
# compare!
self.assertEqual(data['external_parameters'], sequence.parameter_names)
self.assertEqual({ParameterDeclaration('ilse'), ParameterDeclaration('albert'), ParameterDeclaration('voltage')},
sequence.parameter_declarations)
self.assertIs(self.table_foo, sequence.subtemplates[0][0])
self.assertIs(self.table, sequence.subtemplates[1][0])
self.assertEqual(self.foo_mappings, {k: m.string for k,m in sequence.subtemplates[0][1].items()})
self.assertEqual(dict(), sequence.subtemplates[1][1])
self.assertEqual(data['identifier'], sequence.identifier)
class ParameterDeclarationSerializationTests(unittest.TestCase):
def setUp(self) -> None:
self.serializer = DummySerializer()
self.declaration = ParameterDeclaration('foo')
self.expected_data = dict(name='foo', type=self.serializer.get_type_identifier(self.declaration))
def test_get_serialization_data_all_default(self) -> None:
self.expected_data['min_value'] = float('-inf')
self.expected_data['max_value'] = float('+inf')
self.expected_data['default_value'] = None
self.assertEqual(self.expected_data, self.declaration.get_serialization_data(self.serializer))
def test_get_serialization_data_all_floats(self) -> None:
self.declaration = ParameterDeclaration('foo', min=-3.1, max=4.3, default=0.2)
self.expected_data['min_value'] = -3.1
self.expected_data['max_value'] = 4.3
self.expected_data['default_value'] = 0.2
self.assertEqual(self.expected_data, self.declaration.get_serialization_data(self.serializer))
def test_get_serialization_data_min_max_references(self) -> None:
bar_min = ParameterDeclaration('bar_min')
bar_max = ParameterDeclaration('bar_max')
self.declaration.min_value = bar_min
self.declaration.max_value = bar_max
self.expected_data['min_value'] = 'bar_min'
self.expected_data['max_value'] = 'bar_max'
self.expected_data['default_value'] = None
self.assertEqual(self.expected_data, self.declaration.get_serialization_data(self.serializer))
def test_deserialize_all_default(self) -> None:
data = dict(min_value=float('-inf'), max_value=float('+inf'), default_value=None, name='foo')
declaration = ParameterDeclaration.deserialize(self.serializer, **data)
self.assertEqual(data['min_value'], declaration.min_value)
self.assertEqual(data['max_value'], declaration.max_value)
self.assertEqual(data['default_value'], declaration.default_value)
self.assertEqual(data['name'], declaration.name)
self.assertIsNone(declaration.identifier)
def test_deserialize_all_floats(self) -> None:
data = dict(min_value=33.3, max_value=44, default_value=41.1, name='foo')
declaration = ParameterDeclaration.deserialize(self.serializer, **data)
self.assertEqual(data['min_value'], declaration.min_value)
self.assertEqual(data['max_value'], declaration.max_value)
self.assertEqual(data['default_value'], declaration.default_value)
self.assertEqual(data['name'], declaration.name)
self.assertIsNone(declaration.identifier)
def test_deserialize_min_max_references(self) -> None:
data = dict(min_value='bar_min', max_value='bar_max', default_value=-23.5, name='foo')
declaration = ParameterDeclaration.deserialize(self.serializer, **data)
self.assertEqual(float('-inf'), declaration.min_value)
self.assertEqual(float('+inf'), declaration.max_value)
self.assertEqual(data['default_value'], declaration.default_value)
self.assertEqual(data['name'], declaration.name)
self.assertIsNone(declaration.identifier)
def test_get_serialization_data(self) -> None:
serializer = DummySerializer(serialize_callback=lambda x: str(x))
foo_mappings = {k: Expression(v) for k, v in self.foo_mappings.items()}
sequence = SequencePulseTemplate([(self.table_foo, self.foo_mappings),
(self.table, {})],
['ilse', 'albert', 'voltage'],
identifier='foo')
expected_data = dict(
type=serializer.get_type_identifier(sequence),
external_parameters=['albert', 'ilse', 'voltage'],
is_interruptable=True,
subtemplates=[
dict(template=str(self.table_foo),
mappings={k: str(v)
for k, v in foo_mappings.items()}),
dict(template=str(self.table), mappings=dict())
])
data = sequence.get_serialization_data(serializer)
self.assertEqual(expected_data, data)
def test_deserialize(self) -> None:
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(
DeprecationWarning,
"deprecated",
msg=
"SequencePT does not issue warning for old serialization routines."
):
dummy_pt = DummyPulseTemplate(
defined_channels={'foo'},
measurement_names={'meas'},
parameter_names={'hugo', 'herbert', 'ilse'})
serializer = DummySerializer()
data = {
'template': serializer.dictify(dummy_pt),
'parameter_mapping': {
'hugo': str(Expression('2*k+c')),
'herbert': str(Expression('c-1.5')),
'ilse': str(Expression('ilse'))
},
'measurement_mapping': {
'meas': 'seam'
},
'channel_mapping': {
'foo': 'default_channel'
},
'parameter_constraints': [str(ParameterConstraint('c > 0'))]
}
deserialized = MappingPulseTemplate.deserialize(
serializer=serializer, **data)
self.assertIsInstance(deserialized, MappingPulseTemplate)
self.assertEqual(data['parameter_mapping'],
deserialized.parameter_mapping)
self.assertEqual(data['channel_mapping'],
deserialized.channel_mapping)
self.assertEqual(data['measurement_mapping'],
deserialized.measurement_mapping)
self.assertEqual(
data['parameter_constraints'],
[str(pc) for pc in deserialized.parameter_constraints])
self.assertIs(deserialized.template, dummy_pt)
def test_get_serialization_data_old(self) -> None:
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(DeprecationWarning, "deprecated",
msg="FunctionPT does not issue warning for old serialization routines."):
expected_data = dict(duration_expression=str(self.s2),
expression=str(self.s),
channel='A',
measurement_declarations=self.meas_list,
parameter_constraints=self.constraints)
self.assertEqual(expected_data, self.fpt.get_serialization_data(
DummySerializer(serialize_callback=lambda x: x.original_expression)))
def test_get_serialization_data(self) -> None:
expected_data = dict(duration_expression=str(self.s2),
expression=str(self.s),
channel='A',
measurement_declarations=self.meas_list,
parameter_constraints=self.constraints)
self.assertEqual(
expected_data,
self.fpt.get_serialization_data(
DummySerializer(
serialize_callback=lambda x: x.original_expression)))
class TablePulseTemplateSerializationTests(unittest.TestCase):
def setUp(self) -> None:
self.serializer = DummySerializer(lambda x: dict(name=x.name), lambda x: x.name, lambda x: x['name'])
self.template = TablePulseTemplate(measurement=True, identifier='foo')
self.expected_data = dict(type=self.serializer.get_type_identifier(self.template))
def test_get_serialization_data(self) -> None:
self.template.add_entry('foo', 2)
self.template.add_entry('hugo', 'ilse', interpolation='linear')
self.expected_data['is_measurement_pulse'] = True
self.expected_data['time_parameter_declarations'] = [dict(name='foo'), dict(name='hugo')]
self.expected_data['voltage_parameter_declarations'] = [dict(name='ilse')]
self.expected_data['entries'] = [(0, 0, 'hold'), ('foo', 2, 'hold'), ('hugo', 'ilse', 'linear')]
self.assertEqual(self.expected_data, self.template.get_serialization_data(self.serializer))
def test_deserialize(self) -> None:
data = dict(is_measurement_pulse=True,
time_parameter_declarations=[dict(name='hugo'), dict(name='foo')],
voltage_parameter_declarations=[dict(name='ilse')],
entries=[(0, 0, 'hold'), ('foo', 2, 'hold'), ('hugo', 'ilse', 'linear')],
identifier='foo')
# prepare dependencies for deserialization
self.serializer.subelements['foo'] = ParameterDeclaration('foo')
self.serializer.subelements['hugo'] = ParameterDeclaration('hugo')
self.serializer.subelements['ilse'] = ParameterDeclaration('ilse')
# deserialize
template = TablePulseTemplate.deserialize(self.serializer, **data)
# prepare expected parameter declarations
self.serializer.subelements['foo'].min_value = 0
self.serializer.subelements['foo'].max_value = self.serializer.subelements['hugo']
all_declarations = set(self.serializer.subelements.values())
# prepare expected entries
entries = [(0, 0, HoldInterpolationStrategy()),
(self.serializer.subelements['foo'], 2, HoldInterpolationStrategy()),
(self.serializer.subelements['hugo'], self.serializer.subelements['ilse'], LinearInterpolationStrategy())]
# compare!
self.assertEqual(all_declarations, template.parameter_declarations)
self.assertEqual({'foo', 'hugo', 'ilse'}, template.parameter_names)
self.assertEqual(entries, template.entries)
self.assertEqual('foo', template.identifier)
def setUp(self) -> None:
self.serializer = DummySerializer(lambda x: dict(name=x.name), lambda x: x.name, lambda x: x['name'])
self.template = TablePulseTemplate(measurement=True, identifier='foo')
self.expected_data = dict(type=self.serializer.get_type_identifier(self.template))
def setUp(self) -> None:
self.serializer = DummySerializer()
self.declaration = ParameterDeclaration('foo')
self.expected_data = dict(name='foo', type=self.serializer.get_type_identifier(self.declaration))
def test_get_serialization_data(self) -> None:
constant_parameter = ConstantParameter(-0.2)
serializer = DummySerializer()
data = constant_parameter.get_serialization_data(serializer)
self.assertEqual(dict(type=serializer.get_type_identifier(constant_parameter), constant=-0.2), data)
def setUp(self) -> None:
self.serializer = DummySerializer(deserialize_callback=lambda x: x['name'])
self.body = DummyPulseTemplate()
