def test_metadata_partial(self):
self.assertEquals(
self.__row(EnumRow(label='a')).to_json(), {
u'label': u'a',
u'description': None,
u'sort_key': u'key',
})
def test_metadata_default(self):
cell = PollingCell(
target=NoInherentCellSpecimen(),
key='value',
changes='never')
self.assertEqual(cell.metadata().naming, EnumRow(
label='value',
sort_key='value'))
def test_metadata_explicit(self):
self.assertEquals(
self.__row(EnumRow(label='a', description='b',
sort_key='c')).to_json(), {
u'label': u'a',
u'description': u'b',
u'sort_key': u'c',
})
def test_metadata_empty_label(self):
self.assertEquals(
self.__row(EnumRow(label='')).to_json(), {
u'type': u'EnumRow',
u'label': u'',
u'description': None,
u'sort_key': u'key',
})
def test_lookup_and_list_contents(self):
modes = self.table.get_modes(include_unavailable=False)
mode_def = self.table.lookup_mode('available',
include_unavailable=False)
self.assertEqual(modes[0], mode_def)
self.assertEqual(mode_def.mode, 'available')
self.assertEqual(mode_def.info, EnumRow(label='expected available'))
self.assertEqual(mode_def.mod_class, None)
self.assertEqual(mode_def.unavailability, None)
def test_metadata_explicit(self):
cell = Cell(target=NoInherentCellSpecimen(),
key='value',
changes='never',
label='foo',
description='bar',
sort_key='baz')
self.assertEqual(
cell.metadata().naming,
EnumRow(label='foo', description='bar', sort_key='baz'))
def test_specify_all_metadata(self):
# using LooseCell as an arbitrary concrete subclass
cell = LooseCell(
value=0,
type=int,
persists=False, # the non-default value
label='mylabel',
description='mydescription',
sort_key='mysortkey')
self.assertEqual(cell.metadata().value_type, to_value_type(int))
self.assertEqual(cell.metadata().persists, False)
self.assertEqual(cell.metadata().naming, EnumRow(
label='mylabel',
description='mydescription',
sort_key='mysortkey'))
def __init__(self,
type,
persists=True,
writable=False,
label=None,
description=None,
sort_key=None,
associated_key=None):
self._writable = writable
# TODO: Also allow specifying metadata object directly.
self.__metadata = CellMetadata(value_type=to_value_type(type),
persists=bool(persists),
naming=EnumRow(
label=label,
description=description,
sort_key=sort_key,
associated_key=associated_key))
def __init__(self,
mode,
info,
demod_class,
mod_class=None,
available=True):
"""
mode: String uniquely identifying this mode, typically a standard abbreviation written in uppercase letters (e.g. "USB", "WFM").
info: An EnumRow object with a label for the mode, or a string.
The EnumRow sort key should be like the mode value but organized for sorting with space as a separator of qualifiers (e.g. "SSB U", "FM W").
demod_class: Class (or factory function) to instantiate to create a demodulator for this mode. Should provide IDemodulatorFactory but need not declare it.
mod_class: Class (or factory function) to instantiate to create a modulator for this mode. Should provide IModulatorFactory but need not declare it.
available: If false, this mode definition will be ignored.
"""
self.mode = unicode(mode)
self.info = EnumRow(info)
self.demod_class = demod_class
self.mod_class = mod_class
self.available = bool(available)
def __init__(self,
target,
key,
type,
persists=True,
writable=False,
label=None,
description=None,
sort_key=None):
# The exact relationship of target and key depends on the subtype
self._target = target
self._key = key
self._writable = writable
# TODO: Also allow specifying metadata object directly.
self.__metadata = CellMetadata(value_type=to_value_type(type),
persists=bool(persists),
naming=EnumRow(associated_key=key,
label=label,
description=description,
sort_key=sort_key))
def __init__(self,
mode,
info,
demod_class,
mod_class=None,
unavailability=None):
"""
mode: String uniquely identifying this mode, typically a standard abbreviation written in uppercase letters (e.g. "USB", "WFM").
info: An EnumRow object with a label for the mode, or a string.
The EnumRow sort key should be like the mode value but organized for sorting with space as a separator of qualifiers (e.g. "SSB U", "FM W").
demod_class: Class (or factory function) to instantiate to create a demodulator for this mode. Should provide IDemodulatorFactory but need not declare it.
mod_class: Class (or factory function) to instantiate to create a modulator for this mode. Should provide IModulatorFactory but need not declare it.
unavailability: This mode definition will be ignored if this is a string rather than None. The string should be an error message informative to the user (plain text, significant whitespace).
"""
if isinstance(unavailability, bool):
raise Exception('unavailability should be a string or None')
self.mode = six.text_type(mode)
self.info = EnumRow(info)
self.demod_class = demod_class
self.mod_class = mod_class
self.unavailability = None if unavailability is None else six.text_type(unavailability)
def test_metadata_default(self):
cell = self.specimen.state()['unlabeled']
self.assertEqual(cell.metadata().naming,
EnumRow(label='unlabeled', sort_key='unlabeled'))
@exported_value(type=int,
changes='explicit',
sort_key='050',
label='Ident') # TODO naming may be wrong
def get_ident(self):
return self.__ident
@exported_value(type=six.text_type,
changes='explicit',
sort_key='020',
label='Aircraft type')
def get_aircraft_type(self):
return self.__aircraft_type
@exported_value(type=Track, changes='explicit', sort_key='010', label='')
def get_track(self):
return self.__track
plugin_mode = ModeDef(mode='MODE-S',
info=EnumRow(
label='Mode S',
description='Aviation telemetry found at 1090 MHz'),
demod_class=ModeSDemodulator,
unavailability=_unavailability)
plugin_client = ClientResourceDef(
key=__name__,
resource=static.File(os.path.join(os.path.split(__file__)[0], 'client')),
load_js_path='mode_s.js')
def test_metadata_explicit(self):
cell = self.specimen.state()['cmd']
self.assertEqual(cell.metadata().naming,
EnumRow(label='Do the thing', sort_key='cmd'))
from shinysdr.interfaces import ModeDef
from shinysdr.types import EnumRow
plugin_available = ModeDef(mode='available',
info=EnumRow(label='expected available'),
demod_class=object(),
unavailability=None)
plugin_unavailable = ModeDef(mode='unavailable',
info=EnumRow(label='expected unavailable'),
demod_class=object(),
unavailability='For testing.')
def test_values(self):
enum = EnumT({u'a': u'adesc'})
self.assertEquals(
enum.get_table(),
{u'a': EnumRow(u'adesc', associated_key=u'a')})
)
self.__rate = rate
self.connect(self, blocks.float_to_complex(1), blocks.add_const_cc(1),
self)
def get_input_type(self):
return SignalType(kind='MONO', sample_rate=self.__rate)
def get_output_type(self):
return SignalType(kind='IQ', sample_rate=self.__rate)
pluginDef_am = ModeDef(mode='AM',
info=EnumRow(label='AM',
sort_key=BASIC_MODE_SORT_PREFIX + 'AM'),
demod_class=AMDemodulator,
mod_class=AMModulator)
pluginDef_am_entire = ModeDef(mode='AM-unsel',
info=EnumRow(label='AM unselective',
sort_key=BASIC_MODE_SORT_PREFIX +
'AM unsel'),
demod_class=UnselectiveAMDemodulator)
class FMDemodulator(SimpleAudioDemodulator):
def __init__(
self,
mode,
deviation=75000,
demod_rate=48000,
self.__output_type = SignalType(kind='MONO', sample_rate=8000)
self.connect(self, self.__fm_demod,
make_resampler(fm_audio_rate, _demod_rate),
dsd_block_ff(), self)
@exported_block()
def get_fm_demod(self):
return self.__fm_demod
def can_set_mode(self, mode):
return False
def get_output_type(self):
return self.__output_type
@exported_value()
def get_band_filter_shape(self):
return self.__fm_demod.get_band_filter_shape()
_modeDef = ModeDef(
mode=
u'DSD', # TODO: Ought to declare all the individual modes that DSD can decode -- once we have a way to not spam the mode selector with that.
info=EnumRow(
label=u'DSD',
description=u'All modes DSD can decode (P25, DMR, D-STAR, …)'),
demod_class=DSDDemodulator,
available=_available)
self.state_changed()
if shape_changed:
self.state_shape_changed()
def is_interesting(self):
"""Implements ITelemetryObject."""
return True
def get_object_expiry(self):
"""implement ITelemetryObject"""
return self.__last_heard_time + drop_unheard_timeout_seconds
@exported_value(type=TimestampT(), changes='explicit', label='Last heard')
def get_last_heard_time(self):
return self.__last_heard_time
# TODO: Arrange for a way for the user to see why it is unavailable.
_rtl_433_available = test_subprocess(['rtl_433', '-r', '/dev/null'],
'Reading samples from file',
shell=False)
plugin_mode = ModeDef(
mode='433',
info=EnumRow(
label='rtl_433',
description='OOK telemetry decoded by rtl_433 mostly found at 433 MHz'
),
demod_class=RTL433Demodulator,
available=_rtl_433_available)
