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 test_get_entries_instantiated_two_entries_parameter_missing(self) -> None:
table = TablePulseTemplate()
t_decl = ParameterDeclaration('t', min=1, max=2)
v2_decl = ParameterDeclaration('v2', min=10, max=30)
table.add_entry(t_decl, v2_decl)
with self.assertRaises(ParameterNotProvidedException):
table.get_entries_instantiated(dict())
def __test_valid_values(self, **kwargs):
expected_values = {'min': float('-inf'), 'max': float('+inf'), 'default': None}
for k in kwargs:
expected_values[k] = kwargs[k]
expected_values['absolute_min'] = expected_values['min']
expected_values['absolute_max'] = expected_values['max']
if isinstance(expected_values['absolute_min'], ParameterDeclaration):
expected_values['absolute_min'] = expected_values['absolute_min'].absolute_min_value
if isinstance(expected_values['absolute_max'], ParameterDeclaration):
expected_values['absolute_max'] = expected_values['absolute_max'].absolute_max_value
decl = ParameterDeclaration('test', **kwargs)
self.assertEqual('test', decl.name)
self.assertEqual(expected_values['min'], decl.min_value)
self.assertEqual(expected_values['max'], decl.max_value)
self.assertEqual(expected_values['default'], decl.default_value)
self.assertEqual(expected_values['absolute_min'], decl.absolute_min_value)
self.assertEqual(expected_values['absolute_max'], decl.absolute_max_value)
decl = ParameterDeclaration('test', default=expected_values['default'])
if 'min' in kwargs:
decl.min_value = kwargs['min']
if 'max' in kwargs:
decl.max_value = kwargs['max']
self.assertEqual(expected_values['min'], decl.min_value)
self.assertEqual(expected_values['max'], decl.max_value)
self.assertEqual(expected_values['default'], decl.default_value)
self.assertEqual(expected_values['absolute_min'], decl.absolute_min_value)
self.assertEqual(expected_values['absolute_max'], decl.absolute_max_value)
def test_add_entry_empty_time_is_declaration(self) -> None:
table = TablePulseTemplate()
decl = ParameterDeclaration('foo')
table.add_entry(decl, 0)
decl.min_value = 0
self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (decl, 0, HoldInterpolationStrategy())]], table.entries)
self.assertEqual({'foo'}, table.parameter_names)
self.assertEqual({decl}, table.parameter_declarations)
def test_add_entry_empty_time_is_declaration(self) -> None:
table = TablePulseTemplate()
decl = ParameterDeclaration('foo')
table.add_entry(decl, 0)
decl.min_value = 0
self.assertEqual([(0, 0, HoldInterpolationStrategy()), (decl, 0, HoldInterpolationStrategy())], table.entries)
self.assertEqual({'foo'}, table.parameter_names)
self.assertEqual({decl}, table.parameter_declarations)
def test_add_entry_time_float_after_declaration_greater_bound(self) -> None:
table = TablePulseTemplate()
decl = ParameterDeclaration('t', max=3.4)
table.add_entry(decl, 7.1)
table.add_entry(2.1, 5.5)
expected_decl = ParameterDeclaration('t', min=0, max=2.1)
self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (expected_decl, 7.1, HoldInterpolationStrategy()), (2.1, 5.5, HoldInterpolationStrategy())]], table.entries)
self.assertEqual({'t'}, table.parameter_names)
self.assertEqual({expected_decl}, table.parameter_declarations)
def test_add_entry_time_float_after_declaration_greater_bound(self) -> None:
table = TablePulseTemplate()
decl = ParameterDeclaration('t', max=3.4)
table.add_entry(decl, 7.1)
decl.min_value = 0
self.assertRaises(ValueError, table.add_entry, 2.1, 5.5)
self.assertEqual([(0, 0, HoldInterpolationStrategy()), (decl, 7.1, HoldInterpolationStrategy())], table.entries)
self.assertEqual({'t'}, table.parameter_names)
self.assertEqual({decl}, table.parameter_declarations)
def test_add_entry_time_declaration_lower_bound_after_declaration_upper_bound(self) -> None:
table = TablePulseTemplate()
bar_decl = ParameterDeclaration('bar', min=1, max=2)
foo_decl = ParameterDeclaration('foo', min=1)
table.add_entry(bar_decl, -3)
table.add_entry(foo_decl, 0.1)
self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (bar_decl, -3, HoldInterpolationStrategy()), (foo_decl, 0.1, HoldInterpolationStrategy())]], table.entries)
self.assertEqual({'foo', 'bar'}, table.parameter_names)
self.assertEqual({foo_decl, bar_decl}, table.parameter_declarations)
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_add_entry_time_parmeter_name_in_use_as_time(self) -> None:
table = TablePulseTemplate()
table.add_entry('foo', 'bar')
foo_decl = ParameterDeclaration('foo', min=0)
bar_decl = ParameterDeclaration('bar')
with self.assertRaises(ValueError):
table.add_entry(ParameterDeclaration('foo'), 3.4)
self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (foo_decl, bar_decl, HoldInterpolationStrategy())]], table.entries)
self.assertEqual({'foo', 'bar'}, table.parameter_names)
self.assertEqual({foo_decl, bar_decl}, table.parameter_declarations)
def test_add_entry_time_declaration_after_declaration_no_upper_bound(self) -> None:
table = TablePulseTemplate()
table.add_entry('bar', 72.14)
table.add_entry('foo', 0)
bar_decl = ParameterDeclaration('bar', min=0)
foo_decl = ParameterDeclaration('foo')
foo_decl.min_value = bar_decl
self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (bar_decl, 72.14, HoldInterpolationStrategy()), (foo_decl, 0, HoldInterpolationStrategy())]], table.entries)
self.assertEqual({'bar', 'foo'}, table.parameter_names)
self.assertEqual({bar_decl, foo_decl}, table.parameter_declarations)
def test_internal_set_value_exception_branches(self) -> None:
foo = ParameterDeclaration('foo', min=2.1, max=2.6)
bar = ParameterDeclaration('bar', min=foo, max=foo)
with self.assertRaises(ValueError):
ParameterDeclaration('foobar', min=3.1, max=bar)
bar = ParameterDeclaration('bar', min=foo, max=foo)
foobar = ParameterDeclaration('foobar', max=1.1)
with self.assertRaises(ValueError):
self.__assign_min_value(foobar, bar)
def test_add_entry_time_declaration_after_declaration_no_upper_bound(self) -> None:
table = TablePulseTemplate()
table.add_entry('bar', 72.14)
table.add_entry('foo', 0)
bar_decl = ParameterDeclaration('bar', min=0)
foo_decl = ParameterDeclaration('foo')
foo_decl.min_value = bar_decl
self.assertEqual([(0, 0, HoldInterpolationStrategy()), (bar_decl, 72.14, HoldInterpolationStrategy()), (foo_decl, 0, HoldInterpolationStrategy())], table.entries)
self.assertEqual({'bar', 'foo'}, table.parameter_names)
self.assertEqual({bar_decl, foo_decl}, table.parameter_declarations)
def test_add_entry_time_declaration_after_declaration_upper_bound(self) -> None:
table = TablePulseTemplate()
bar_decl = ParameterDeclaration('bar', min=1, max=2)
foo_decl = ParameterDeclaration('foo')
table.add_entry(bar_decl, -3)
table.add_entry(foo_decl, 0.1)
foo_decl.min_value = bar_decl
self.assertEqual([(0, 0, HoldInterpolationStrategy()), (bar_decl, -3, HoldInterpolationStrategy()), (foo_decl, 0.1, HoldInterpolationStrategy())], table.entries)
self.assertEqual({'foo', 'bar'}, table.parameter_names)
self.assertEqual({foo_decl, bar_decl}, table.parameter_declarations)
def test_add_entry_time_declaration_lower_bound_upper_bound_too_small_after_declaration(self) -> None:
table = TablePulseTemplate()
bar_decl = ParameterDeclaration('bar', min=1, max=2)
foo_decl = ParameterDeclaration('foo', min=1, max=1.5)
table.add_entry(bar_decl, -3)
with self.assertRaises(ValueError):
table.add_entry(foo_decl, 0.1)
self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (bar_decl, -3, HoldInterpolationStrategy())]], table.entries)
self.assertEqual({'bar'}, table.parameter_names)
self.assertEqual({bar_decl}, table.parameter_declarations)
def test_get_entries_instantiated_unlinked_time_declarations(self) -> None:
table = TablePulseTemplate()
foo_decl = ParameterDeclaration('foo', min=1, max=2)
bar_decl = ParameterDeclaration('bar', min=1.5, max=4)
table.add_entry(foo_decl, 'v', 'linear')
table.add_entry(bar_decl, 0, 'jump')
instantiated_entries = table.get_entries_instantiated({'v': 2.3, 'foo': 1, 'bar': 4})
self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (1, 2.3, LinearInterpolationStrategy()), (4, 0, JumpInterpolationStrategy())]], instantiated_entries)
with self.assertRaises(Exception):
table.get_entries_instantiated({'v': 2.3, 'foo': 2, 'bar': 1.5})
def test_get_entries_instantiated_two_entries_invalid_parameters(self) -> None:
table = TablePulseTemplate()
table.add_entry(0, 'v1')
t_decl = ParameterDeclaration('t', min=1, max=2)
v2_decl = ParameterDeclaration('v2', min=10, max=30)
table.add_entry(t_decl, v2_decl)
with self.assertRaises(ParameterValueIllegalException):
table.get_entries_instantiated({'v1': -5, 't': 0, 'v2': 20})
with self.assertRaises(ParameterValueIllegalException):
table.get_entries_instantiated({'v1': -5, 't': 1, 'v2': -20})
def test_add_entry_time_declaration_invalid_bounds(self) -> None:
table = TablePulseTemplate()
bar_decl = ParameterDeclaration('bar')
foo_decl = ParameterDeclaration('foo')
foo_decl.min_value = bar_decl
self.assertRaises(ValueError, table.add_entry, foo_decl, 23857.23)
self.assertRaises(ValueError, table.add_entry, bar_decl, -4967.1)
self.assertFalse(table.entries)
self.assertFalse(table.parameter_names)
self.assertFalse(table.parameter_declarations)
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_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_requires_stop_true_mapped_parameters(self) -> None:
dummy = DummyPulseTemplate(parameter_names={'foo'}, requires_stop=True)
pulse = MultiChannelPulseTemplate([(dummy, dict(foo='2*bar'), [0]),
(dummy, dict(foo='rab-5'), [1])],
{'bar', 'rab'})
self.assertEqual({'bar', 'rab'}, pulse.parameter_names)
self.assertEqual(
{ParameterDeclaration('bar'),
ParameterDeclaration('rab')}, pulse.parameter_declarations)
parameters = dict(bar=ConstantParameter(-3.6),
rab=ConstantParameter(35.26))
self.assertTrue(pulse.requires_stop(parameters, dict()))
def test_add_entry_time_declaration_invalid_bounds(self) -> None:
table = TablePulseTemplate()
bar_decl = ParameterDeclaration('bar')
foo_decl = ParameterDeclaration('foo')
foo_decl.min_value = bar_decl
with self.assertRaises(ValueError):
table.add_entry(foo_decl, 23857.23)
with self.assertRaises(ValueError):
table.add_entry(bar_decl, -4967.1)
self.assertEquals([[TableEntry(0, 0, HoldInterpolationStrategy())]], table.entries)
self.assertFalse(table.parameter_names)
self.assertFalse(table.parameter_declarations)
def test_add_entry_voltage_declaration_reuse(self) -> None:
table = TablePulseTemplate()
foo_decl = ParameterDeclaration('foo', min=0, max=3.3)
bar_decl = ParameterDeclaration('bar', min=-3.3, max=1.15)
table.add_entry(0, foo_decl)
table.add_entry(1.51, bar_decl)
table.add_entry(3, 'foo')
table.add_entry('t', foo_decl)
t_decl = ParameterDeclaration('t', min=3)
self.assertEqual([[(0, foo_decl, HoldInterpolationStrategy()), (1.51, bar_decl, HoldInterpolationStrategy()),
(3, foo_decl, HoldInterpolationStrategy()), (t_decl, foo_decl, HoldInterpolationStrategy())]], table.entries)
self.assertEqual({'foo', 'bar', 't'}, table.parameter_names)
self.assertEqual({foo_decl, bar_decl, t_decl}, table.parameter_declarations)
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_requires_stop(self) -> None:
table = TablePulseTemplate()
foo_decl = ParameterDeclaration('foo', min=1)
bar_decl = ParameterDeclaration('bar')
table.add_entry(foo_decl, 'v', 'linear')
table.add_entry(bar_decl, 0, 'jump')
test_sets = [(False, {'foo': DummyParameter(0, False), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, False)}, {'foo': DummyCondition(False)}),
(False, {'foo': DummyParameter(0, False), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, False)}, {'foo': DummyCondition(True)}),
(True, {'foo': DummyParameter(0, True), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, False)}, {'foo': DummyCondition(False)}),
(True, {'foo': DummyParameter(0, True), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, False)}, {'foo': DummyCondition(True)}),
(True, {'foo': DummyParameter(0, False), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, True)}, {'foo': DummyCondition(False)}),
(True, {'foo': DummyParameter(0, False), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, True)}, {'foo': DummyCondition(True)}),
(True, {'foo': DummyParameter(0, True), 'bar': DummyParameter(0, True), 'v': DummyParameter(0, True)}, {'foo': DummyCondition(False)}),
(True, {'foo': DummyParameter(0, True), 'bar': DummyParameter(0, True), 'v': DummyParameter(0, True)}, {'foo': DummyCondition(True)})]
for expected_result, parameter_set, condition_set in test_sets:
self.assertEqual(expected_result, table.requires_stop(parameter_set, condition_set))
def test_add_entry_empty_time_is_0_voltage_is_parameter(self) -> None:
table = TablePulseTemplate()
table.add_entry(0, 'foo')
decl = ParameterDeclaration('foo')
self.assertEqual([[(0, decl, HoldInterpolationStrategy())]], table.entries)
self.assertEqual({'foo'}, table.parameter_names)
self.assertEqual({decl}, table.parameter_declarations)
def test_add_entry_time_declaration_higher_min_after_float(self) -> None:
table = TablePulseTemplate()
table.add_entry(3.2, 92.1)
decl = ParameterDeclaration('t', min=4.5)
table.add_entry(decl, 1.2)
self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (3.2, 92.1, HoldInterpolationStrategy()), (decl, 1.2, HoldInterpolationStrategy())]], table.entries)
self.assertEqual({'t'}, table.parameter_names)
self.assertEqual({decl}, table.parameter_declarations)
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_parameter_names_and_declarations_string_input(self) -> None:
template = FunctionPulseTemplate("3 * foo + bar * t", "5 * hugo")
expected_parameter_names = {'foo', 'bar', 'hugo'}
self.assertEqual(expected_parameter_names, template.parameter_names)
self.assertEqual(
{ParameterDeclaration(name)
for name in expected_parameter_names},
template.parameter_declarations)
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_build_sequence(self) -> None:
table = TablePulseTemplate()
foo_decl = ParameterDeclaration('foo', min=1)
bar_decl = ParameterDeclaration('bar')
table.add_entry(foo_decl, 'v', 'linear')
table.add_entry(bar_decl, 0, 'jump')
parameters = {'v': 2.3, 'foo': 1, 'bar': 4}
instantiated_entries = tuple(table.get_entries_instantiated(parameters))
waveform = table.build_waveform(parameters)
sequencer = DummySequencer()
instruction_block = DummyInstructionBlock()
table.build_sequence(sequencer, parameters, {}, instruction_block)
expected_waveform = TableWaveform(instantiated_entries)
self.assertEqual(1, len(instruction_block.instructions))
instruction = instruction_block.instructions[0]
self.assertIsInstance(instruction, EXECInstruction)
self.assertEqual(expected_waveform, instruction.waveform)
self.assertEqual(expected_waveform, waveform)
def test_add_entry_time_float_after_declaration_smaller_than_min_bound(self) -> None:
table = TablePulseTemplate()
decl = ParameterDeclaration('t', min=1.2, max=83456.2)
table.add_entry(decl, 2.2)
with self.assertRaises(ValueError):
table.add_entry(1.1, -6.3)
self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (decl, 2.2, HoldInterpolationStrategy())]], table.entries)
self.assertEqual({'t'}, table.parameter_names)
self.assertEqual({decl}, table.parameter_declarations)
def test_add_entry_time_declaration_lower_min_after_float(self) -> None:
table = TablePulseTemplate()
table.add_entry(3.2, 92.1)
decl = ParameterDeclaration('t', min=0.1)
with self.assertRaises(ValueError):
table.add_entry(decl, 1.2)
self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (3.2, 92.1, HoldInterpolationStrategy())]], table.entries)
self.assertFalse(table.parameter_names)
self.assertFalse(table.parameter_declarations)
def test_add_entry_voltage_declaration_in_use_as_time(self) -> None:
table = TablePulseTemplate()
foo_decl = ParameterDeclaration('foo', min=0, max=2)
table.add_entry(foo_decl, 0)
with self.assertRaises(ValueError):
table.add_entry(4, foo_decl)
self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (foo_decl, 0, HoldInterpolationStrategy())]], table.entries)
self.assertEqual({'foo'}, table.parameter_names)
self.assertEqual({foo_decl}, table.parameter_declarations)
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_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_init(self) -> None:
body = DummyPulseTemplate()
repetition_count = 3
t = RepetitionPulseTemplate(body, repetition_count)
self.assertEqual(repetition_count, t.repetition_count)
self.assertEqual(body, t.body)
repetition_count = ParameterDeclaration('foo')
t = RepetitionPulseTemplate(body, repetition_count)
self.assertEqual(repetition_count, t.repetition_count)
self.assertEqual(body, t.body)
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_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_get_value(self) -> None:
decl = ParameterDeclaration('foo')
foo_param = ConstantParameter(2.1)
self.assertEqual(foo_param.get_value(), decl.get_value({'foo': foo_param}))
self.assertRaises(ParameterNotProvidedException, decl.get_value, {})
decl = ParameterDeclaration('foo', default=2.7)
self.assertEqual(decl.default_value, decl.get_value({}))
decl = ParameterDeclaration('foo', min=1.3)
self.assertEqual(1.4, decl.get_value({'foo': ConstantParameter(1.4)}))
self.assertEqual(1.3, decl.get_value({'foo': ConstantParameter(1.3)}))
self.assertRaises(ParameterValueIllegalException, decl.get_value, {'foo': ConstantParameter(1.1)})
decl = ParameterDeclaration('foo', max=2.3)
self.assertTrue(1.4, decl.get_value({'foo': ConstantParameter(1.4)}))
self.assertTrue(2.3, decl.get_value({'foo': ConstantParameter(2.3)}))
self.assertRaises(ParameterValueIllegalException, decl.get_value, {'foo': ConstantParameter(3.1)})
decl = ParameterDeclaration('foo', min=1.3, max=2.3)
self.assertRaises(ParameterValueIllegalException, decl.get_value, {'foo': ConstantParameter(0.9)})
self.assertEqual(1.3, decl.get_value({'foo': ConstantParameter(1.3)}))
self.assertEqual(1.4, decl.get_value({'foo': ConstantParameter(1.4)}))
self.assertEqual(2.3, decl.get_value({'foo': ConstantParameter(2.3)}))
self.assertRaises(ParameterValueIllegalException, decl.get_value, {'foo': ConstantParameter(3.1)})
min_decl = ParameterDeclaration('min', min=1.2, max=2.3)
max_decl = ParameterDeclaration('max', min=1.2, max=5.1)
min_param = ConstantParameter(1.3)
max_param = ConstantParameter(2.3)
decl = ParameterDeclaration('foo', min=min_decl, max=max_decl)
self.assertRaises(ParameterValueIllegalException, decl.get_value, {'min': min_param, 'max': max_param, 'foo': ConstantParameter(0.9)})
self.assertRaises(ParameterValueIllegalException, decl.get_value, {'min': min_param, 'max': max_param, 'foo': ConstantParameter(1.2)})
self.assertRaises(ParameterValueIllegalException, decl.get_value, {'min': min_param, 'max': max_param, 'foo': ConstantParameter(1.25)})
self.assertEqual(1.3, decl.get_value({'min': min_param, 'max': max_param, 'foo': ConstantParameter(1.3)}))
self.assertEqual(1.7, decl.get_value({'min': min_param, 'max': max_param, 'foo': ConstantParameter(1.7)}))
self.assertEqual(2.3, decl.get_value({'min': min_param, 'max': max_param, 'foo': ConstantParameter(2.3)}))
self.assertRaises(ParameterValueIllegalException, decl.get_value, {'min': min_param, 'max': max_param, 'foo': ConstantParameter(3.5)})
self.assertRaises(ParameterValueIllegalException, decl.get_value, {'min': min_param, 'max': max_param, 'foo': ConstantParameter(5.1)})
self.assertRaises(ParameterValueIllegalException, decl.get_value, {'min': min_param, 'max': max_param, 'foo': ConstantParameter(17.2)})
def test_is_parameter_valid_no_bounds(self) -> None:
decl = ParameterDeclaration('foo')
param = ConstantParameter(2.4)
self.assertTrue(decl.is_parameter_valid(param))
def test_is_parameter_valid_min_max_bound(self) -> None:
decl = ParameterDeclaration('foobar', min=-0.1, max=13.2)
params = [(False, -0.5), (True, -0.1), (True, 0), (True, 7.9), (True, 13.2), (False, 17.3)]
for expected, param in params:
self.assertEqual(expected, decl.is_parameter_valid(param))
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_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 __min_assignment(self, decl: ParameterDeclaration, value: Union[ParameterDeclaration, float]) -> None:
decl.min_value = value
def __assign_min_value(self, left_value: ParameterDeclaration, right_value: ParameterDeclaration) -> None:
left_value.min_value = right_value
