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)
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()