def test_set_element_by_slice(dci_with_list):
foo = DummyChannel(dci_with_list, name="foo", channel="foo")
bar = DummyChannel(dci_with_list, name="bar", channel="bar")
dci_with_list.channels[0:2] = [foo, bar]
assert dci_with_list.channels[0] is foo
assert dci_with_list.channels[1] is bar
assert (dci_with_list.channels.get_channel_by_name("foo") ==
dci_with_list.channels[0])
assert (dci_with_list.channels.get_channel_by_name("bar") ==
dci_with_list.channels[1])
def test_channels_is_sequence(dci):
names = ("A", "B", "C", "D", "E", "F", "G", "H")
channels = tuple(DummyChannel(dci, name, name) for name in names)
chlist = ChannelList(dci, "channels", DummyChannel, channels)
assert isinstance(chlist, Sequence)
assert issubclass(ChannelList, Sequence)
def test_add_channel(self):
n_channels = len(self.instrument.channels)
name = 'foo'
channel = DummyChannel(self.instrument, 'Chan' + name, name)
self.instrument.channels.append(channel)
self.instrument.add_submodule(name, channel)
self.assertEqual(len(self.instrument.channels), n_channels + 1)
self.instrument.channels.lock()
# after locking the channels it's not possible to add any more channels
with self.assertRaises(AttributeError):
name = 'bar'
channel = DummyChannel(self.instrument, 'Chan' + name, name)
self.instrument.channels.append(channel)
self.assertEqual(len(self.instrument.channels), n_channels + 1)
def test_add_channels_from_generator(self):
n_channels = len(self.instrument.channels)
names = ('foo', 'bar', 'foobar')
channels = (DummyChannel(self.instrument, 'Chan'+name, name) for name in names)
self.instrument.channels.extend(channels)
self.assertEqual(len(self.instrument.channels), n_channels + len(names))
def test_channels_count(dci):
names = ("A", "B", "C", "D", "E", "F", "G", "H")
channels = tuple(DummyChannel(dci, name, name) for name in names)
chlist = ChannelList(dci, "channels", DummyChannel, channels)
for channel in channels:
assert chlist.count(channel) == 1
def test_add_channel(dci):
n_channels = len(dci.channels)
name = 'foo'
channel = DummyChannel(dci, 'Chan' + name, name)
dci.channels.append(channel)
dci.add_submodule(name, channel)
assert len(dci.channels) == n_channels + 1
dci.channels.lock()
# after locking the channels it's not possible to add any more channels
with pytest.raises(AttributeError):
name = 'bar'
channel = DummyChannel(dci, 'Chan' + name, name)
dci.channels.append(channel)
assert len(dci.channels) == n_channels + 1
def test_channels_reverse(dci):
names = ("A", "B", "C", "D", "E", "F", "G", "H")
channels = tuple(DummyChannel(dci, name, name) for name in names)
chlist = ChannelList(dci, "channels", DummyChannel, channels)
reverse_names = reversed(names)
for name, chan in zip(reverse_names, reversed(chlist)):
assert chan.short_name == name
def test_add_channels_from_tuple(dci):
n_channels = len(dci.channels)
names = ('foo', 'bar', 'foobar')
channels = tuple(DummyChannel(dci, 'Chan' + name, name) for name in names)
dci.channels.extend(channels)
assert len(dci.channels) == n_channels + len(names)
def test_extend_channels_from_tuple(dci_with_list):
n_channels = len(dci_with_list.channels)
names = ("foo", "bar", "foobar")
channels = tuple(
DummyChannel(dci_with_list, "Chan" + name, name) for name in names)
dci_with_list.channels.extend(channels)
assert len(dci_with_list.channels) == n_channels + len(names)
def test_access_channels_by_tuple(dci, myindexs):
names = ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H')
mytuple = tuple(myindexs)
channels = tuple(DummyChannel(dci, 'Chan' + name, name) for name in names)
chlist = ChannelList(dci, 'channels', DummyChannel, channels)
mychans = chlist[mytuple]
for chan, chanindex in zip(mychans, mytuple):
assert chan.name == f'dci_Chan{names[chanindex]}'
def test_access_channels_by_name(dci, myindexs):
names = ("A", "B", "C", "D", "E", "F", "G", "H")
channels = tuple(DummyChannel(dci, "Chan" + name, name) for name in names)
chlist = ChannelList(dci, "channels", DummyChannel, channels)
channel_names = (f"Chan{names[i]}" for i in myindexs)
mychans = chlist.get_channel_by_name(*channel_names)
for chan, chanindex in zip(mychans, myindexs):
assert chan.name == f'dci_Chan{names[chanindex]}'
def test_append_channel(dci_with_list):
n_channels_pre = len(dci_with_list.channels)
n_channels_post = n_channels_pre + 1
chan_num = 11
name = f"Chan{chan_num}"
channel = DummyChannel(dci_with_list, name, chan_num)
dci_with_list.channels.append(channel)
dci_with_list.add_submodule(name, channel)
assert len(dci_with_list.channels) == n_channels_post
dci_with_list.channels.lock()
# after locking the channels it's not possible to add any more channels
with pytest.raises(AttributeError):
name = "bar"
channel = DummyChannel(dci_with_list, "Chan" + name, name)
dci_with_list.channels.append(channel)
assert len(dci_with_list.channels) == n_channels_post
def test_access_channels_by_slice(dci, start, stop, step):
names = ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H')
channels = tuple(DummyChannel(dci, 'Chan' + name, name) for name in names)
chlist = ChannelList(dci, 'channels', DummyChannel, channels)
if stop < start:
step = -step
myslice = slice(start, stop, step)
mychans = chlist[myslice]
expected_channels = names[myslice]
for chan, exp_chan in zip(mychans, expected_channels):
assert chan.name == f'dci_Chan{exp_chan}'
def test_extend_then_remove(dci):
n_channels = len(dci.channels)
names = ('foo', 'bar', 'foobar')
channels = [DummyChannel(dci, 'Chan' + name, name) for name in names]
dci.channels.extend(channels)
assert len(dci.channels) == n_channels + len(names)
last_channel = dci.channels[-1]
dci.channels.remove(last_channel)
assert last_channel not in dci.channels
assert len(dci.channels) == n_channels + len(names) - 1
def test_insert_channel(dci_with_list):
n_channels_pre = len(dci_with_list.channels)
name = "foo"
channel = DummyChannel(dci_with_list, "Chan" + name, name)
dci_with_list.channels.insert(1, channel)
dci_with_list.add_submodule(name, channel)
n_channels_post = n_channels_pre + 1
assert dci_with_list.channels.get_channel_by_name(f"Chan{name}") is channel
assert len(dci_with_list.channels) == n_channels_post
assert dci_with_list.channels[1] is channel
dci_with_list.channels.lock()
# after locking the channels it's not possible to add any more channels
with pytest.raises(AttributeError):
name = "bar"
channel = DummyChannel(dci_with_list, "Chan" + name, name)
dci_with_list.channels.insert(2, channel)
assert len(dci_with_list.channels) == n_channels_post
assert len(dci_with_list.channels._channel_mapping) == n_channels_post
def test_extend_then_remove(self):
n_channels = len(self.instrument.channels)
names = ('foo', 'bar', 'foobar')
channels = [DummyChannel(self.instrument, 'Chan' + name, name) for name in names]
self.instrument.channels.extend(channels)
self.assertEqual(len(self.instrument.channels), n_channels + len(names))
last_channel = self.instrument.channels[-1]
self.instrument.channels.remove(last_channel)
assert last_channel not in self.instrument.channels
self.assertEqual(len(self.instrument.channels), n_channels + len(names) - 1)
def test_remove_tupled_channel(dci):
channel_tuple = tuple(
DummyChannel(dci, f'Chan{C}', C)
for C in ('A', 'B', 'C', 'D', 'E', 'F'))
channels = ChannelList(dci,
"TempSensorsTuple",
DummyChannel,
channel_tuple,
snapshotable=False)
chan_a = channels.ChanA
with pytest.raises(AttributeError):
channels.remove(chan_a)
def test_remove_tupled_channel(self):
channel_tuple = tuple(
DummyChannel(self.instrument, f'Chan{C}', C)
for C in ('A', 'B', 'C', 'D', 'E', 'F'))
channels = ChannelList(self.instrument,
"TempSensorsTuple",
DummyChannel,
channel_tuple,
snapshotable=False)
chanA = channels.ChanA
with self.assertRaises(AttributeError):
channels.remove(chanA)
def test_extend_then_remove(dci_with_list):
n_channels = len(dci_with_list.channels)
names = ("foo", "bar", "foobar")
channels = [
DummyChannel(dci_with_list, "Chan" + name, name) for name in names
]
dci_with_list.channels.extend(channels)
assert len(dci_with_list.channels) == n_channels + len(names)
last_channel = dci_with_list.channels[-1]
dci_with_list.channels.remove(last_channel)
assert last_channel not in dci_with_list.channels
assert len(dci_with_list.channels) == n_channels + len(names) - 1
def test_remove_tupled_channel(dci_with_list):
channel_tuple = tuple(
DummyChannel(dci_with_list, f"Chan{C}", C)
for C in ("A", "B", "C", "D", "E", "F"))
channels = ChannelList(
dci_with_list,
"TempSensorsTuple",
DummyChannel,
channel_tuple,
snapshotable=False,
)
chan_a = channels.ChanA
with pytest.raises(AttributeError):
channels.remove(chan_a)
def test_channel_tuple_snapshot_enabled(empty_instrument):
channels = ChannelList(empty_instrument,
"ListElem",
DummyChannel,
snapshotable=True)
for chan_name in ("A", "B", "C", "D", "E", "F"):
channel = DummyChannel(empty_instrument, f"Chan{chan_name}", chan_name)
channels.append(channel)
empty_instrument.add_submodule("channels", channels)
snapshot = empty_instrument.channels.snapshot()
assert snapshot["snapshotable"] is True
assert len(snapshot.keys()) == 3
assert "channels" in snapshot.keys()
def test_names(self):
ex_inst_name = 'testchanneldummy'
for channel in self.instrument.channels:
sub_channel = DummyChannel(channel, 'subchannel', 'subchannel')
channel.add_submodule('somesubchannel', sub_channel)
assert self.instrument.name == ex_inst_name
assert self.instrument.full_name == ex_inst_name
assert self.instrument.short_name == ex_inst_name
assert self.instrument.name_parts == [ex_inst_name]
# Parameters directly on instrument
assert self.instrument.IDN.name == 'IDN'
assert self.instrument.IDN.full_name == f"{ex_inst_name}_IDN"
for chan, name in zip(self.instrument.channels,
['A', 'B', 'C', 'D', 'E', 'F']):
ex_chan_name = f"Chan{name}"
ex_chan_full_name = f"{ex_inst_name}_{ex_chan_name}"
assert chan.short_name == ex_chan_name
assert chan.name == ex_chan_full_name
assert chan.full_name == ex_chan_full_name
assert chan.name_parts == [ex_inst_name, ex_chan_name]
ex_param_name = 'temperature'
assert chan.temperature.name == ex_param_name
assert chan.temperature.full_name ==\
f'{ex_chan_full_name}_{ex_param_name}'
assert chan.temperature.short_name == ex_param_name
assert chan.temperature.name_parts == [
ex_inst_name, ex_chan_name, ex_param_name
]
ex_subchan_name = f"subchannel"
ex_subchan_full_name = f"{ex_chan_full_name}_{ex_subchan_name}"
assert chan.somesubchannel.short_name == ex_subchan_name
assert chan.somesubchannel.name == ex_subchan_full_name
assert chan.somesubchannel.full_name == ex_subchan_full_name
assert chan.somesubchannel.name_parts == [
ex_inst_name, ex_chan_name, ex_subchan_name
]
assert chan.somesubchannel.temperature.name == ex_param_name
assert chan.somesubchannel.temperature.full_name ==\
f'{ex_subchan_full_name}_{ex_param_name}'
assert chan.somesubchannel.temperature.short_name == ex_param_name
assert chan.somesubchannel.temperature.name_parts == \
[ex_inst_name, ex_chan_name, ex_subchan_name, ex_param_name]
def _make_dci_with_list():
for i in range(10):
pass
dci = Instrument(name="dciwl")
channels = ChannelList(dci, "ListElem", DummyChannel, snapshotable=False)
for chan_name in ("A", "B", "C", "D", "E", "F"):
channel = DummyChannel(dci, f"Chan{chan_name}", chan_name)
channels.append(channel)
dci.add_submodule(chan_name, channel)
dci.add_submodule("channels", channels)
try:
yield dci
finally:
dci.close()