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)