def get_serialization_data(self, serializer: Serializer) -> Dict[str, Any]: repetition_count = self.__repetition_count if isinstance(repetition_count, ParameterDeclaration): repetition_count = serializer.dictify(repetition_count) return dict(type=serializer.get_type_identifier(self), body=serializer.dictify(self.__body), repetition_count=repetition_count)
def deserialize(serializer: Serializer, time_parameter_declarations: Iterable[Any], voltage_parameter_declarations: Iterable[Any], entries: Iterable[Any], is_measurement_pulse: bool, identifier: Optional[str] = None) -> 'TablePulseTemplate': time_parameter_declarations = \ {declaration['name']: serializer.deserialize(declaration) for declaration in time_parameter_declarations} voltage_parameter_declarations = \ {declaration['name']: serializer.deserialize(declaration) for declaration in voltage_parameter_declarations} template = TablePulseTemplate(channels=len(entries), measurement=is_measurement_pulse, identifier=identifier) for channel, channel_entries in enumerate(entries): for (time, voltage, interpolation) in channel_entries: if isinstance(time, str): time = time_parameter_declarations[time] if isinstance(voltage, str): voltage = voltage_parameter_declarations[voltage] template.add_entry(time, voltage, interpolation=interpolation, channel=channel) return template
def get_serialization_data(self, serializer: Serializer) -> Dict[str, Any]: data = dict( type=serializer.get_type_identifier(self), condition=self.__condition, body=serializer._serialize_subpulse(self.__body) ) return data
def get_serialization_data(self, serializer: Serializer) -> Dict[str, Any]: data = dict( type=serializer.get_type_identifier(self), condition=self.__condition, body=serializer.dictify(self.__body) ) return data
def deserialize(serializer: Serializer, condition: str, if_branch_template: Dict[str, Any], else_branch_template: Dict[str, Any], identifier: Optional[str] = None) -> 'BranchPulseTemplate': return BranchPulseTemplate( condition, serializer.deserialize(if_branch_template), serializer.deserialize(else_branch_template), identifier)
def deserialize(serializer: Serializer, repetition_count: Dict[str, Any], body: Dict[str, Any], identifier: Optional[str]=None) -> 'Serializable': body = serializer.deserialize(body) if isinstance(repetition_count, dict): repetition_count = serializer.deserialize(repetition_count) return RepetitionPulseTemplate(body, repetition_count, identifier=identifier)
def get_serialization_data(self, serializer: Serializer) -> Dict[str, Any]: repetition_count = self.__repetition_count if isinstance(repetition_count, ParameterDeclaration): repetition_count = serializer._serialize_subpulse(repetition_count) return dict( type=serializer.get_type_identifier(self), body=serializer._serialize_subpulse(self.__body), repetition_count=repetition_count )
def deserialize(serializer: Serializer, repetition_count: Dict[str, Any], body: Dict[str, Any], identifier: Optional[str] = None) -> 'Serializable': body = serializer.deserialize(body) if isinstance(repetition_count, dict): repetition_count = serializer.deserialize(repetition_count) return RepetitionPulseTemplate(body, repetition_count, identifier=identifier)
def test_serializer_integration(self): 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 get_serialization_data(self, serializer: Serializer) -> Dict[str, Any]: subtemplates = [] for subtemplate, channel_mapping in self.__subtemplates: mapping_functions = self.__parameter_mapping.get_template_map(subtemplate) mapping_function_strings = \ {k: serializer.dictify(m) for k, m in mapping_functions.items()} subtemplate = serializer.dictify(subtemplate) subtemplates.append(dict(template=subtemplate, parameter_mappings=mapping_function_strings, channel_mappings=channel_mapping)) return dict(subtemplates=subtemplates, external_parameters=sorted(list(self.parameter_names)))
def deserialize(serializer: Serializer, subtemplates: Iterable[Dict[str, Any]], external_parameters: Iterable[str], identifier: Optional[str]=None) -> 'MultiChannelPulseTemplate': subtemplates = \ [(serializer.deserialize(subt['template']), {k: str(serializer.deserialize(m)) for k, m in subt['parameter_mappings'].items()}, subt['channel_mappings']) for subt in subtemplates] template = MultiChannelPulseTemplate(subtemplates, external_parameters, identifier=identifier) return template
def get_serialization_data(self, serializer: Serializer) -> Dict[str, Any]: data = dict() data['external_parameters'] = sorted(list(self.parameter_names)) data['is_interruptable'] = self.is_interruptable subtemplates = [] for (subtemplate, mapping_functions) in self.subtemplates: mapping_functions_strings = {k: m.string for k, m in mapping_functions.items()} subtemplate = serializer._serialize_subpulse(subtemplate) subtemplates.append(dict(template=subtemplate, mappings=copy.deepcopy(mapping_functions_strings))) data['subtemplates'] = subtemplates data['type'] = serializer.get_type_identifier(self) return data
def get_serialization_data(self, serializer: Serializer) -> Dict[str, Any]: data = dict() data['is_measurement_pulse'] = self.__is_measurement_pulse data['time_parameter_declarations'] = [serializer._serialize_subpulse(self.__time_parameter_declarations[key]) for key in sorted(self.__time_parameter_declarations.keys())] data['voltage_parameter_declarations'] = [serializer._serialize_subpulse(self.__voltage_parameter_declarations[key]) for key in sorted(self.__voltage_parameter_declarations.keys())] entries = [] for (time, voltage, interpolation) in self.__entries: if isinstance(time, ParameterDeclaration): time = time.name if isinstance(voltage, ParameterDeclaration): voltage = voltage.name entries.append((time, voltage, str(interpolation))) data['entries'] = entries data['type'] = serializer.get_type_identifier(self) return data
def get_serialization_data(self, serializer: Serializer) -> Dict[str, Any]: parameter_mapping_dict = dict( (key, str(expression)) for key, expression in self.__parameter_mapping.items()) return dict(template=serializer.dictify(self.template), parameter_mapping=parameter_mapping_dict, measurement_mapping=self.__measurement_mapping, channel_mapping=self.__channel_mapping)
def deserialize( serializer: Serializer, is_interruptable: bool, subtemplates: Iterable[Dict[str, Union[str, Dict[str, Any]]]], external_parameters: Iterable[str], identifier: Optional[str] = None) -> 'SequencePulseTemplate': subtemplates = \ [(serializer.deserialize(d['template']), {k: str(serializer.deserialize(m)) for k, m in d['mappings'].items()}) for d in subtemplates] template = SequencePulseTemplate(subtemplates, external_parameters, identifier=identifier) template.is_interruptable = is_interruptable return template
def test_serialization_and_deserialization_combined(self) -> None: table_foo = TablePulseTemplate( identifier='foo', entries={'default': [('hugo', 2), ('albert', 'voltage')]}, parameter_constraints=['albert<9.1']) table = TablePulseTemplate({'default': [('t', 0)]}) foo_mappings = dict(hugo='ilse', albert='albert', voltage='voltage') sequence = SequencePulseTemplate( (table_foo, foo_mappings, dict()), (table, dict(t=0), dict()), external_parameters=['ilse', 'albert', 'voltage'], identifier=None) storage = DummyStorageBackend() serializer = Serializer(storage) serializer.serialize(sequence) serialized_foo = storage.stored_items['foo'] serialized_sequence = storage.stored_items['main'] deserialized_sequence = serializer.deserialize('main') storage.stored_items = dict() serializer.serialize(deserialized_sequence) self.assertEqual(serialized_foo, storage.stored_items['foo']) self.assertEqual(serialized_sequence, storage.stored_items['main'])
def deserialize(serializer: Serializer, subtemplates: Iterable[Dict[str, Any]], parameter_constraints: List[str], identifier: Optional[str]=None) -> 'SequencePulseTemplate': subtemplates = [serializer.deserialize(st) for st in subtemplates] seq_template = SequencePulseTemplate(*subtemplates, parameter_constraints=parameter_constraints, identifier=identifier) return seq_template
def get_serialization_data(self, serializer: Serializer) -> Dict[str, Any]: data = dict() data['external_parameters'] = sorted(list(self.parameter_names)) data['is_interruptable'] = self.is_interruptable subtemplates = [] for subtemplate in self.__subtemplates: mapping_functions = self.__parameter_mapping.get_template_map( subtemplate) mapping_functions_strings = \ {k: serializer.dictify(m) for k, m in mapping_functions.items()} subtemplate = serializer.dictify(subtemplate) subtemplates.append( dict(template=subtemplate, mappings=mapping_functions_strings)) data['subtemplates'] = subtemplates data['type'] = serializer.get_type_identifier(self) return data
def deserialize( serializer: Serializer, condition: str, body: Dict[str, Any], identifier: Optional[str] = None) -> 'WhileLoopPulseTemplate': body = serializer.deserialize(body) result = WhileLoopPulseTemplate(condition=condition, body=body, identifier=identifier) return result
def deserialize(serializer: Serializer, time_parameter_declarations: Iterable[Any], voltage_parameter_declarations: Iterable[Any], entries: Iterable[Any], is_measurement_pulse: bool, identifier: Optional[str]=None) -> 'TablePulseTemplate': time_parameter_declarations = {declaration['name']: serializer.deserialize(declaration) for declaration in time_parameter_declarations} voltage_parameter_declarations = {declaration['name']: serializer.deserialize(declaration) for declaration in voltage_parameter_declarations} template = TablePulseTemplate(is_measurement_pulse, identifier=identifier) for (time, voltage, interpolation) in entries: if isinstance(time, str): time = time_parameter_declarations[time] if isinstance(voltage, str): voltage = voltage_parameter_declarations[voltage] template.add_entry(time, voltage, interpolation=interpolation) return template
def get_serialization_data(self, serializer: Serializer) -> Dict[str, Any]: data = dict(body=serializer.dictify(self.body), repetition_count=self.repetition_count.original_expression) if self.parameter_constraints: data['parameter_constraints'] = [ str(c) for c in self.parameter_constraints ] if self.measurement_declarations: data['measurements'] = self.measurement_declarations return data
def test_serializer_integration(self): before = FunctionPulseTemplate(expression=self.s, duration_expression=self.s2, channel='A', measurements=self.meas_list, parameter_constraints=self.constraints, identifier='my_tpt') serializer = Serializer(DummyStorageBackend()) serializer.serialize(before) after = serializer.deserialize('my_tpt') self.assertIsInstance(after, FunctionPulseTemplate) self.assertEqual(before.expression, after.expression) self.assertEqual(before.duration, after.duration) self.assertEqual(before.defined_channels, after.defined_channels) self.assertEqual(before.measurement_declarations, after.measurement_declarations) self.assertEqual(before.parameter_constraints, after.parameter_constraints)
def deserialize(serializer: Serializer, is_interruptable: bool, subtemplates: Iterable[Dict[str, Union[str, Dict[str, Any]]]], external_parameters: Iterable[str], identifier: Optional[str]=None) -> 'SequencePulseTemplate': subtemplates = \ [(serializer.deserialize(d['template']), {k: m for k, m in d['mappings'].items()}) for d in subtemplates] template = SequencePulseTemplate(subtemplates, external_parameters, identifier=identifier) template.is_interruptable = is_interruptable return template
def get_serialization_data(self, serializer: Serializer) -> Dict[str, Any]: data = dict( body=serializer.dictify(self.body), loop_range=self._loop_range.to_tuple(), loop_index=self._loop_index, ) if self.parameter_constraints: data['parameter_constraints'] = [ str(c) for c in self.parameter_constraints ] if self.measurement_declarations: data['measurements'] = self.measurement_declarations return data
def deserialize( serializer: Serializer, subtemplates: Iterable[Dict[str, Any]], parameter_constraints: Optional[Any] = None, identifier: Optional[str] = None, measurements: Optional[List[MeasurementDeclaration]] = None ) -> 'AtomicMultiChannelPulseTemplate': subtemplates = [serializer.deserialize(st) for st in subtemplates] return AtomicMultiChannelPulseTemplate( *subtemplates, parameter_constraints=parameter_constraints, identifier=identifier, measurements=measurements)
def get_serialization_data(self, serializer: Serializer) -> Dict[str, Any]: data = dict() data['is_measurement_pulse'] = self.__is_measurement_pulse data['time_parameter_declarations'] = \ [serializer.dictify(self.__time_parameter_declarations[key]) for key in sorted(self.__time_parameter_declarations.keys())] data['voltage_parameter_declarations'] = \ [serializer.dictify(self.__voltage_parameter_declarations[key]) for key in sorted(self.__voltage_parameter_declarations.keys())] serialized_entries = [] for channel in self.__entries: entries = [] for (time, voltage, interpolation) in channel: if isinstance(time, ParameterDeclaration): time = time.name if isinstance(voltage, ParameterDeclaration): voltage = voltage.name entries.append((time, voltage, str(interpolation))) serialized_entries.append(entries) data['entries'] = serialized_entries data['type'] = serializer.get_type_identifier(self) return data
def get_serialization_data(self, serializer: Serializer) -> Dict[str, Any]: data = dict(subtemplates=[ serializer.dictify(subtemplate) for subtemplate in self.subtemplates ]) if self.parameter_constraints: data['parameter_constraints'] = [ str(constraint) for constraint in self.parameter_constraints ] if self.measurement_declarations: data['measurements'] = self.measurement_declarations return data
def deserialize( serializer: Serializer, repetition_count: Union[str, int], body: Dict[str, Any], parameter_constraints: Optional[List[str]] = None, identifier: Optional[str] = None, measurements: Optional[List[MeasurementDeclaration]] = None ) -> 'RepetitionPulseTemplate': body = cast(PulseTemplate, serializer.deserialize(body)) return RepetitionPulseTemplate( body, repetition_count, identifier=identifier, parameter_constraints=parameter_constraints, measurements=measurements)
def deserialize( serializer: Serializer, body: Dict[str, Any], loop_range: Tuple, loop_index: str, identifier: Optional[str] = None, measurements: Optional = None, parameter_constraints: Optional = None) -> 'ForLoopPulseTemplate': body = cast(PulseTemplate, serializer.deserialize(body)) return ForLoopPulseTemplate( body=body, identifier=identifier, loop_range=loop_range, loop_index=loop_index, measurements=measurements, parameter_constraints=parameter_constraints)
def get_serialization_data(self, serializer: Serializer) -> Dict[str, Any]: data = dict() min_value = self.min_value if isinstance(min_value, ParameterDeclaration): min_value = min_value.name max_value = self.max_value if isinstance(max_value, ParameterDeclaration): max_value = max_value.name data['name'] = self.name data['min_value'] = min_value data['max_value'] = max_value data['default_value'] = self.default_value data['type'] = serializer.get_type_identifier(self) return data
def test_serialization_and_deserialization_combined(self) -> None: table_foo = TablePulseTemplate(identifier='foo') table_foo.add_entry('hugo', 2) table_foo.add_entry(ParameterDeclaration('albert', max=9.1), 'voltage') table = TablePulseTemplate(measurement=True) foo_mappings = dict(hugo='ilse', albert='albert', voltage='voltage') sequence = SequencePulseTemplate([(table_foo, foo_mappings), (table, {})], ['ilse', 'albert', 'voltage'], identifier=None) storage = DummyStorageBackend() serializer = Serializer(storage) serializer.serialize(sequence) serialized_foo = storage.stored_items['foo'] serialized_sequence = storage.stored_items['main'] deserialized_sequence = serializer.deserialize('main') storage.stored_items = dict() serializer.serialize(deserialized_sequence) self.assertEqual(serialized_foo, storage.stored_items['foo']) self.assertEqual(serialized_sequence, storage.stored_items['main'])
def setUp(self) -> None: self.backend = DummyStorageBackend() self.serializer = Serializer(self.backend) self.deserialization_data = dict(data='THIS IS DARTAA!', type=self.serializer.get_type_identifier(DummySerializable()))
def get_serialization_data(self, serializer: Serializer) -> Dict[str, Any]: return dict(data=serializer.dictify(self.data))
def setUp(self) -> None: self.backend = DummyStorageBackend() self.serializer = Serializer(self.backend) self.deserialization_data = dict( data='THIS IS DARTAA!', type=self.serializer.get_type_identifier(DummySerializable()))
class SerializerTests(unittest.TestCase): def setUp(self) -> None: self.backend = DummyStorageBackend() self.serializer = Serializer(self.backend) self.deserialization_data = dict( data='THIS IS DARTAA!', type=self.serializer.get_type_identifier(DummySerializable())) def test_serialize_subpulse_no_identifier(self) -> None: serializable = DummySerializable(data='bar') serialized = self.serializer.dictify(serializable) expected = serializable.get_serialization_data(self.serializer) expected['type'] = self.serializer.get_type_identifier(serializable) self.assertEqual(expected, serialized) def test_serialize_subpulse_identifier(self) -> None: serializable = DummySerializable(identifier='bar') serialized = self.serializer.dictify(serializable) self.assertEqual(serializable.identifier, serialized) def test_serialize_subpulse_duplicate_identifier(self) -> None: serializable = DummySerializable(identifier='bar') self.serializer.dictify(serializable) self.serializer.dictify(serializable) serializable = DummySerializable(data='this is other data than before', identifier='bar') with self.assertRaises(Exception): self.serializer.dictify(serializable) def test_collection_dictionaries_no_identifier(self) -> None: serializable = DummySerializable(data='bar') dictified = self.serializer._Serializer__collect_dictionaries( serializable) expected = {'': serializable.get_serialization_data(self.serializer)} expected['']['type'] = self.serializer.get_type_identifier( serializable) self.assertEqual(expected, dictified) def test_collection_dictionaries_identifier(self) -> None: serializable = DummySerializable(data='bar', identifier='foo') dicified = self.serializer._Serializer__collect_dictionaries( serializable) expected = { serializable.identifier: serializable.get_serialization_data(self.serializer) } expected[serializable.identifier][ 'type'] = self.serializer.get_type_identifier(serializable) self.assertEqual(expected, dicified) def test_dicitify_no_identifier_one_nesting_no_identifier(self) -> None: inner_serializable = DummySerializable(data='bar') serializable = NestedDummySerializable(data=inner_serializable) dicitified = self.serializer._Serializer__collect_dictionaries( serializable) expected = {'': serializable.get_serialization_data(self.serializer)} expected['']['type'] = self.serializer.get_type_identifier( serializable) self.assertEqual(expected, dicitified) def test_collection_dictionaries_no_identifier_one_nesting_identifier( self) -> None: inner_serializable = DummySerializable(data='bar', identifier='foo') serializable = NestedDummySerializable(data=inner_serializable) dicitified = self.serializer._Serializer__collect_dictionaries( serializable) expected = { '': serializable.get_serialization_data(self.serializer), inner_serializable.identifier: inner_serializable.get_serialization_data(self.serializer) } expected['']['type'] = self.serializer.get_type_identifier( serializable) expected[inner_serializable.identifier][ 'type'] = self.serializer.get_type_identifier(inner_serializable) self.assertEqual(expected, dicitified) def test_collection_dictionaries_identifier_one_nesting_no_identifier( self) -> None: inner_serializable = DummySerializable(data='bar') serializable = NestedDummySerializable(data=inner_serializable, identifier='outer_foo') dicitified = self.serializer._Serializer__collect_dictionaries( serializable) expected = { serializable.identifier: serializable.get_serialization_data(self.serializer) } expected[serializable.identifier][ 'type'] = self.serializer.get_type_identifier(serializable) self.assertEqual(expected, dicitified) def test_collection_dictionaries_identifier_one_nesting_identifier( self) -> None: inner_serializable = DummySerializable(data='bar', identifier='foo') serializable = NestedDummySerializable(data=inner_serializable, identifier='outer_foo') dicitified = self.serializer._Serializer__collect_dictionaries( serializable) expected = { inner_serializable.identifier: inner_serializable.get_serialization_data(self.serializer), serializable.identifier: serializable.get_serialization_data(self.serializer) } expected[serializable.identifier][ 'type'] = self.serializer.get_type_identifier(serializable) expected[inner_serializable.identifier][ 'type'] = self.serializer.get_type_identifier(inner_serializable) self.assertEqual(expected, dicitified) def __serialization_test_helper(self, serializable: Serializable, expected: Dict[str, str]) -> None: self.serializer.serialize(serializable) expected = { k: json.dumps(v, indent=4, sort_keys=True) for k, v in expected.items() } self.assertEqual(expected, self.backend.stored_items) def test_serialize_no_identifier(self) -> None: serializable = DummySerializable(data='bar') expected = { 'main': serializable.get_serialization_data(self.serializer) } expected['main']['type'] = self.serializer.get_type_identifier( serializable) self.__serialization_test_helper(serializable, expected) def test_serialize_identifier(self) -> None: serializable = DummySerializable(data='bar', identifier='foo') expected = { serializable.identifier: serializable.get_serialization_data(self.serializer) } expected[serializable.identifier][ 'type'] = self.serializer.get_type_identifier(serializable) self.__serialization_test_helper(serializable, expected) def test_serialize_no_identifier_one_nesting_no_identifier(self) -> None: inner_serializable = DummySerializable(data='bar') serializable = NestedDummySerializable(data=inner_serializable) expected = { 'main': serializable.get_serialization_data(self.serializer) } expected['main']['type'] = self.serializer.get_type_identifier( serializable) self.__serialization_test_helper(serializable, expected) def test_serialize_no_identifier_one_nesting_identifier(self) -> None: inner_serializable = DummySerializable(data='bar', identifier='foo') serializable = NestedDummySerializable(data=inner_serializable) expected = { 'main': serializable.get_serialization_data(self.serializer), inner_serializable.identifier: inner_serializable.get_serialization_data(self.serializer) } expected['main']['type'] = self.serializer.get_type_identifier( serializable) expected[inner_serializable.identifier][ 'type'] = self.serializer.get_type_identifier(inner_serializable) self.__serialization_test_helper(serializable, expected) def test_serialize_identifier_one_nesting_no_identifier(self) -> None: inner_serializable = DummySerializable(data='bar') serializable = NestedDummySerializable(data=inner_serializable, identifier='outer_foo') expected = { serializable.identifier: serializable.get_serialization_data(self.serializer) } expected[serializable.identifier][ 'type'] = self.serializer.get_type_identifier(serializable) self.__serialization_test_helper(serializable, expected) def test_serialize_identifier_one_nesting_identifier(self) -> None: inner_serializable = DummySerializable(data='bar', identifier='foo') serializable = NestedDummySerializable(data=inner_serializable, identifier='outer_foo') expected = { serializable.identifier: serializable.get_serialization_data(self.serializer), inner_serializable.identifier: inner_serializable.get_serialization_data(self.serializer) } expected[serializable.identifier][ 'type'] = self.serializer.get_type_identifier(serializable) expected[inner_serializable.identifier][ 'type'] = self.serializer.get_type_identifier(inner_serializable) self.__serialization_test_helper(serializable, expected) def test_deserialize_dict(self) -> None: deserialized = self.serializer.deserialize(self.deserialization_data) self.assertIsInstance(deserialized, DummySerializable) self.assertEqual(self.deserialization_data['data'], deserialized.data) def test_deserialize_identifier(self) -> None: jsonized_data = json.dumps(self.deserialization_data, indent=4, sort_keys=True) identifier = 'foo' self.backend.put(identifier, jsonized_data) deserialized = self.serializer.deserialize(identifier) self.assertIsInstance(deserialized, DummySerializable) self.assertEqual(self.deserialization_data['data'], deserialized.data) def test_serialization_and_deserialization_combined(self) -> None: table_foo = TablePulseTemplate( identifier='foo', entries={'default': [('hugo', 2), ('albert', 'voltage')]}, parameter_constraints=['albert<9.1']) table = TablePulseTemplate({'default': [('t', 0)]}) foo_mappings = dict(hugo='ilse', albert='albert', voltage='voltage') sequence = SequencePulseTemplate( (table_foo, foo_mappings, dict()), (table, dict(t=0), dict()), external_parameters=['ilse', 'albert', 'voltage'], identifier=None) storage = DummyStorageBackend() serializer = Serializer(storage) serializer.serialize(sequence) serialized_foo = storage.stored_items['foo'] serialized_sequence = storage.stored_items['main'] deserialized_sequence = serializer.deserialize('main') storage.stored_items = dict() serializer.serialize(deserialized_sequence) self.assertEqual(serialized_foo, storage.stored_items['foo']) self.assertEqual(serialized_sequence, storage.stored_items['main'])
def get_serialization_data(self, serializer: Serializer) -> None: return dict(type=serializer.get_type_identifier(self), constant=self.__value)
def get_serialization_data(self, serializer: Serializer) -> Dict[str, Any]: data = dict(subtemplates=[serializer.dictify(subtemplate) for subtemplate in self.subtemplates], parameter_constraints=self.parameter_constraints) return data
def deserialize(serializer: Serializer, condition: str, body: Dict[str, Any], identifier: Optional[str]=None) -> 'LoopPulseTemplate': body = serializer.deserialize(body) return LoopPulseTemplate(condition, body, identifier=identifier)
def get_serialization_data(self, serializer: Serializer) -> Dict[str, Any]: return dict(type=serializer.get_type_identifier(self), expression=str(self))
class SerializerTests(unittest.TestCase): def setUp(self) -> None: self.backend = DummyStorageBackend() self.serializer = Serializer(self.backend) self.deserialization_data = dict(data='THIS IS DARTAA!', type=self.serializer.get_type_identifier(DummySerializable())) def test_serialize_subpulse_no_identifier(self) -> None: serializable = DummySerializable(data='bar') serialized = self.serializer._serialize_subpulse(serializable) self.assertEqual(serializable.get_serialization_data(self.serializer), serialized) def test_serialize_subpulse_identifier(self) -> None: serializable = DummySerializable(identifier='bar') serialized = self.serializer._serialize_subpulse(serializable) self.assertEqual(serializable.identifier, serialized) def test_serialize_subpulse_duplicate_identifier(self) -> None: serializable = DummySerializable(identifier='bar') self.serializer._serialize_subpulse(serializable) self.serializer._serialize_subpulse(serializable) serializable = DummySerializable(data='this is other data than before', identifier='bar') with self.assertRaises(Exception): self.serializer._serialize_subpulse(serializable) def test_dictify_no_identifier(self) -> None: serializable = DummySerializable(data='bar') dictified = self.serializer.dictify(serializable) self.assertEqual({'': serializable.get_serialization_data(self.serializer)}, dictified) def test_dictify_identifier(self) -> None: serializable = DummySerializable(data='bar', identifier='foo') dicified = self.serializer.dictify(serializable) self.assertEqual({serializable.identifier: serializable.get_serialization_data(self.serializer)}, dicified) def test_dicitify_no_identifier_one_nesting_no_identifier(self) -> None: inner_serializable = DummySerializable(data='bar') serializable = NestedDummySerializable(data=inner_serializable) dicitified = self.serializer.dictify(serializable) self.assertEqual({'': serializable.get_serialization_data(self.serializer)}, dicitified) def test_dictify_no_identifier_one_nesting_identifier(self) -> None: inner_serializable = DummySerializable(data='bar', identifier='foo') serializable = NestedDummySerializable(data=inner_serializable) dicitified = self.serializer.dictify(serializable) self.assertEqual({'': serializable.get_serialization_data(self.serializer), inner_serializable.identifier: inner_serializable.get_serialization_data(self.serializer)}, dicitified) def test_dictify_identifier_one_nesting_no_identifier(self) -> None: inner_serializable = DummySerializable(data='bar') serializable = NestedDummySerializable(data=inner_serializable, identifier='outer_foo') dicitified = self.serializer.dictify(serializable) self.assertEqual({serializable.identifier: serializable.get_serialization_data(self.serializer)}, dicitified) def test_dictify_identifier_one_nesting_identifier(self) -> None: inner_serializable = DummySerializable(data='bar', identifier='foo') serializable = NestedDummySerializable(data=inner_serializable, identifier='outer_foo') dicitified = self.serializer.dictify(serializable) self.assertEqual({inner_serializable.identifier: inner_serializable.get_serialization_data(self.serializer), serializable.identifier: serializable.get_serialization_data(self.serializer)}, dicitified) def __serialization_test_helper(self, serializable: Serializable, expected: Dict[str, str]) -> None: self.serializer.serialize(serializable) expected = {k: json.dumps(v, indent=4, sort_keys=True) for k,v in expected.items()} self.assertEqual(expected, self.backend.stored_items) def test_serialize_no_identifier(self) -> None: serializable = DummySerializable(data='bar') expected = {'main': serializable.get_serialization_data(self.serializer)} self.__serialization_test_helper(serializable, expected) def test_serialize_identifier(self) -> None: serializable = DummySerializable(data='bar', identifier='foo') expected = {serializable.identifier: serializable.get_serialization_data(self.serializer)} self.__serialization_test_helper(serializable, expected) def test_serialize_no_identifier_one_nesting_no_identifier(self) -> None: inner_serializable = DummySerializable(data='bar') serializable = NestedDummySerializable(data=inner_serializable) expected = {'main': serializable.get_serialization_data(self.serializer)} self.__serialization_test_helper(serializable, expected) def test_serialize_no_identifier_one_nesting_identifier(self) -> None: inner_serializable = DummySerializable(data='bar', identifier='foo') serializable = NestedDummySerializable(data=inner_serializable) expected = {'main': serializable.get_serialization_data(self.serializer), inner_serializable.identifier: inner_serializable.get_serialization_data(self.serializer)} self.__serialization_test_helper(serializable, expected) def test_serialize_identifier_one_nesting_no_identifier(self) -> None: inner_serializable = DummySerializable(data='bar') serializable = NestedDummySerializable(data=inner_serializable, identifier='outer_foo') expected = {serializable.identifier: serializable.get_serialization_data(self.serializer)} self.__serialization_test_helper(serializable, expected) def test_serialize_identifier_one_nesting_identifier(self) -> None: inner_serializable = DummySerializable(data='bar', identifier='foo') serializable = NestedDummySerializable(data=inner_serializable, identifier='outer_foo') expected = {serializable.identifier: serializable.get_serialization_data(self.serializer), inner_serializable.identifier: inner_serializable.get_serialization_data(self.serializer)} self.__serialization_test_helper(serializable, expected) def test_deserialize_dict(self) -> None: deserialized = self.serializer.deserialize(self.deserialization_data) self.assertIsInstance(deserialized, DummySerializable) self.assertEqual(self.deserialization_data['data'], deserialized.data) def test_deserialize_identifier(self) -> None: jsonized_data = json.dumps(self.deserialization_data, indent=4, sort_keys=True) identifier = 'foo' self.backend.put(identifier, jsonized_data) deserialized = self.serializer.deserialize(identifier) self.assertIsInstance(deserialized, DummySerializable) self.assertEqual(self.deserialization_data['data'], deserialized.data) def test_serialization_and_deserialization_combined(self) -> None: table_foo = TablePulseTemplate(identifier='foo') table_foo.add_entry('hugo', 2) table_foo.add_entry(ParameterDeclaration('albert', max=9.1), 'voltage') table = TablePulseTemplate(measurement=True) foo_mappings = dict(hugo='ilse', albert='albert', voltage='voltage') sequence = SequencePulseTemplate([(table_foo, foo_mappings), (table, {})], ['ilse', 'albert', 'voltage'], identifier=None) storage = DummyStorageBackend() serializer = Serializer(storage) serializer.serialize(sequence) serialized_foo = storage.stored_items['foo'] serialized_sequence = storage.stored_items['main'] deserialized_sequence = serializer.deserialize('main') storage.stored_items = dict() serializer.serialize(deserialized_sequence) self.assertEqual(serialized_foo, storage.stored_items['foo']) self.assertEqual(serialized_sequence, storage.stored_items['main'])
def get_serialization_data(self, serializer: Serializer) -> None: return dict(duration_expression=serializer.dictify( self.__duration_expression), expression=serializer.dictify(self.__expression), measurement=self.__is_measurement_pulse)
def get_serialization_data(self, serializer: Serializer) -> Dict[str, Any]: return dict(data=serializer._serialize_subpulse(self.data))