示例#1
0
def makepacket(data,
               samprate=666,
               net='net',
               sta='sta',
               chan='chan',
               loc='loc',
               type='GENC',
               time=0):
    """returns stuffed packet in form (pkttype, packet, srcname, time)

    Packet has one channel.
    """
    from mi.core.kudu import _pkt

    pkt = _pkt._newPkt()
    try:
        _pkt._Pkt_pkttype_set(pkt, type)
        _pkt._Pkt_time_set(pkt, time)
        pktchan = _pkt._newPktChannel()
        _pkt._PktChannel_time_set(pktchan, time)
        _pkt._PktChannel_data_set(pktchan, data)
        _pkt._PktChannel_samprate_set(pktchan, samprate)
        _pkt._PktChannel_net_set(pktchan, net)
        _pkt._PktChannel_sta_set(pktchan, sta)
        _pkt._PktChannel_chan_set(pktchan, chan)
        _pkt._PktChannel_loc_set(pktchan, loc)
        _pkt._Pkt_channels_set(pkt, [
            pktchan,
        ])
        return _pkt._stuffPkt(pkt)
    finally:
        _pkt._freePkt(pkt)
    def setUp(self):
        from mi.core.kudu import _pkt
        log.debug("*********************************************************************")
        log.debug("Starting Dataset Test %s", self._testMethodName)
        log.debug("*********************************************************************")
        log.debug("ID: %s", self.id())
        log.debug("DataSetTestCase setUp")

        # Test to ensure we have initialized our test config
        if not self.test_config.initialized:
            return TestNotInitialized(msg="Tests non initialized. Missing DataSetTestCase.initialize(...)?")

        log.debug("Driver Config: %s", self._driver_config())


        self.state_callback_result = []
        self.data_callback_result = []
        self.event_callback_result = []
        self.exception_callback_result = []

        self.memento = {}

        self.PKT_ID = PKT_ID = 123
        self.PKT_TYPE = PKT_TYPE = 'GENC'
        self.PKT_DATA = PKT_DATA = 1,2,3,4
        self.PKT_TIME = PKT_TIME = 999
        self.PKT_SAMPRATE = PKT_SAMPRATE = 666
        self.PKT_NET = PKT_NET = 'net'
        self.PKT_STA = PKT_STA = 'sta'
        self.PKT_CHAN = PKT_CHAN = 'chan'
        self.PKT_LOC = PKT_LOC = 'loc'

        pkt = _pkt._newPkt()
        _pkt._Pkt_pkttype_set(pkt, PKT_TYPE)
        pktchan = _pkt._newPktChannel()
        _pkt._PktChannel_data_set(pktchan, PKT_DATA)
        _pkt._PktChannel_samprate_set(pktchan, PKT_SAMPRATE)
        _pkt._PktChannel_time_set(pktchan, PKT_TIME)
        _pkt._PktChannel_net_set(pktchan, PKT_NET)
        _pkt._PktChannel_sta_set(pktchan, PKT_STA)
        _pkt._PktChannel_chan_set(pktchan, PKT_CHAN)
        _pkt._PktChannel_loc_set(pktchan, PKT_LOC)
        _pkt._Pkt_channels_set(pkt, [pktchan,])
        self.pkttype, self.packet, self.srcname, self.time = _pkt._stuffPkt(pkt)
        _pkt._freePkt(pkt)

        self.driver = self._get_driver_object()

        # NOTE why not do this in tearDown?
        self.addCleanup(self._stop_driver)

        self._metadata = None
        self._get_metadata()
    def setUp(self):
        ParserUnitTestCase.setUp(self)

        self.error_callback_values = []
        self.state_callback_values = []
        self.publish_callback_values = []

        self.parser_config = {
            ParserConfigKey.ORBNAME: ParserConfigKey.ORBNAME,
            ParserConfigKey.SELECT: ParserConfigKey.SELECT,
            ParserConfigKey.REJECT: ParserConfigKey.REJECT,
        }

        self.parser_state = None

        self.PKT_ID = PKT_ID = 123
        self.PKT_TYPE = PKT_TYPE = 'GENC'
        self.PKT_DATA = PKT_DATA = 1, 2, 3, 4
        self.PKT_TIME = PKT_TIME = 999
        self.PKT_SAMPRATE = PKT_SAMPRATE = 666
        self.PKT_NET = PKT_NET = 'net'
        self.PKT_STA = PKT_STA = 'sta'
        self.PKT_CHAN = PKT_CHAN = 'chan'
        self.PKT_LOC = PKT_LOC = 'loc'

        from mi.core.kudu import _pkt
        pkt = _pkt._newPkt()
        _pkt._Pkt_pkttype_set(pkt, PKT_TYPE)
        pktchan = _pkt._newPktChannel()
        _pkt._PktChannel_data_set(pktchan, PKT_DATA)
        _pkt._PktChannel_samprate_set(pktchan, PKT_SAMPRATE)
        _pkt._PktChannel_time_set(pktchan, PKT_TIME)
        _pkt._PktChannel_net_set(pktchan, PKT_NET)
        _pkt._PktChannel_sta_set(pktchan, PKT_STA)
        _pkt._PktChannel_chan_set(pktchan, PKT_CHAN)
        _pkt._PktChannel_loc_set(pktchan, PKT_LOC)
        _pkt._Pkt_channels_set(pkt, [
            pktchan,
        ])
        pkttype, packet, srcname, time = _pkt._stuffPkt(pkt)
        _pkt._freePkt(pkt)

        with patch(
                'mi.dataset.parser.antelope_orb.OrbReapThr') as MockOrbReapThr:
            self.parser = AntelopeOrbParser(self.parser_config,
                                            self.parser_state,
                                            self.state_callback,
                                            self.pub_callback,
                                            self.error_callback)
        self.parser._orbreapthr.get = MagicMock(return_value=(PKT_ID, srcname,
                                                              time, packet))
示例#4
0
def make_antelope_particle(get_r, *args, **kwargs):
    """Inspects packet channel, returns instance of appropriate antelope data particle class."""
    pktid, srcname, orbtimestamp, raw_packet = get_r
    pkt = None
    pkttype, pkt = _pkt._unstuffPkt(srcname, orbtimestamp, raw_packet)
    if pkttype < 0:
        raise SampleException("Failed to unstuff ORB packet")
    try:
        srcnameparts = _pkt._Pkt_srcnameparts_get(pkt)
        net, sta, chan, loc, dtype, subcode = srcnameparts
        ParticleClass = PARTICLE_CLASSES[chan.lower()]
        raw_data = pktid, srcname, orbtimestamp, raw_packet, pkttype, pkt
    except Exception:
        _pkt._freePkt(pkt)
        raise
    return ParticleClass(raw_data, *args, **kwargs)
示例#5
0
def make_antelope_particle(get_r, *args, **kwargs):
    """Inspects packet channel, returns instance of appropriate antelope data particle class."""
    pktid, srcname, orbtimestamp, raw_packet = get_r
    pkt = None
    pkttype, pkt = _pkt._unstuffPkt(srcname, orbtimestamp, raw_packet)
    if pkttype < 0:
        raise SampleException("Failed to unstuff ORB packet")
    try:
        srcnameparts = _pkt._Pkt_srcnameparts_get(pkt)
        net, sta, chan, loc, dtype, subcode = srcnameparts
        ParticleClass = PARTICLE_CLASSES[chan.lower()]
        raw_data = pktid, srcname, orbtimestamp, raw_packet, pkttype, pkt
    except Exception:
        _pkt._freePkt(pkt)
        raise
    return ParticleClass(raw_data, *args, **kwargs)
    def setUp(self):
        ParserUnitTestCase.setUp(self)

        self.error_callback_values = []
        self.state_callback_values = []
        self.publish_callback_values = []

        self.parser_config = {
            ParserConfigKey.ORBNAME: ParserConfigKey.ORBNAME,
            ParserConfigKey.SELECT: ParserConfigKey.SELECT,
            ParserConfigKey.REJECT: ParserConfigKey.REJECT,
        }

        self.parser_state = None

        self.PKT_ID = PKT_ID = 123
        self.PKT_TYPE = PKT_TYPE = 'GENC'
        self.PKT_DATA = PKT_DATA = 1,2,3,4
        self.PKT_TIME = PKT_TIME = 999
        self.PKT_SAMPRATE = PKT_SAMPRATE = 666
        self.PKT_NET = PKT_NET = 'net'
        self.PKT_STA = PKT_STA = 'sta'
        self.PKT_CHAN = PKT_CHAN = 'chan'
        self.PKT_LOC = PKT_LOC = 'loc'

        from mi.core.kudu import _pkt
        pkt = _pkt._newPkt()
        _pkt._Pkt_pkttype_set(pkt, PKT_TYPE)
        pktchan = _pkt._newPktChannel()
        _pkt._PktChannel_data_set(pktchan, PKT_DATA)
        _pkt._PktChannel_samprate_set(pktchan, PKT_SAMPRATE)
        _pkt._PktChannel_time_set(pktchan, PKT_TIME)
        _pkt._PktChannel_net_set(pktchan, PKT_NET)
        _pkt._PktChannel_sta_set(pktchan, PKT_STA)
        _pkt._PktChannel_chan_set(pktchan, PKT_CHAN)
        _pkt._PktChannel_loc_set(pktchan, PKT_LOC)
        _pkt._Pkt_channels_set(pkt, [pktchan,])
        pkttype, packet, srcname, time = _pkt._stuffPkt(pkt)
        _pkt._freePkt(pkt)

        with patch('mi.dataset.parser.antelope_orb.OrbReapThr') as MockOrbReapThr:
            self.parser = AntelopeOrbParser(self.parser_config, self.parser_state,
                            self.state_callback, self.pub_callback,
                            self.error_callback)
        self.parser._orbreapthr.get = MagicMock(return_value=(PKT_ID, srcname, time, packet))
def makepacket(data, samprate=666, net='net', sta='sta',
                chan='chan', loc='loc', type='GENC', time=0):
    """returns stuffed packet in form (pkttype, packet, srcname, time)

    Packet has one channel.
    """
    from mi.core.kudu import _pkt

    pkt = _pkt._newPkt()
    try:
        _pkt._Pkt_pkttype_set(pkt, type)
        _pkt._Pkt_time_set(pkt, time)
        pktchan = _pkt._newPktChannel()
        _pkt._PktChannel_time_set(pktchan, time)
        _pkt._PktChannel_data_set(pktchan, data)
        _pkt._PktChannel_samprate_set(pktchan, samprate)
        _pkt._PktChannel_net_set(pktchan, net)
        _pkt._PktChannel_sta_set(pktchan, sta)
        _pkt._PktChannel_chan_set(pktchan, chan)
        _pkt._PktChannel_loc_set(pktchan, loc)
        _pkt._Pkt_channels_set(pkt, [pktchan,])
        return _pkt._stuffPkt(pkt)
    finally:
        _pkt._freePkt(pkt)
示例#8
0
    def _build_parsed_values(self):
        """
        Take something in the data format and turn it into
        an array of dictionaries defining the data in the particle
        with the appropriate tag.
        @throws SampleException If there is a problem with sample creation
        """
        log.trace("_build_parsed_values")
        pktid, srcname, orbtimestamp, raw_packet = self.raw_data

        result = []
        pk = AntelopeOrbPacketParticleKey
        vid = DataParticleKey.VALUE_ID
        v = DataParticleKey.VALUE

        pkt = None
        try:
            pkttype, pkt = _pkt._unstuffPkt(srcname, orbtimestamp, raw_packet)
            if pkttype < 0:
                raise SampleException("Failed to unstuff ORB packet")

            # Calculate sample timestamp
            self.set_internal_timestamp(unix_time=_pkt._Pkt_time_get(pkt))

            result.append({vid: pk.ID, v: pktid})
            result.append({vid: pk.DB, v: _pkt._Pkt_db_get(pkt)})
            result.append({vid: pk.DFILE, v: _pkt._Pkt_dfile_get(pkt)})
            result.append({vid: pk.SRCNAME, v: _pkt._Pkt_srcnameparts_get(pkt)})
            result.append({vid: pk.VERSION, v: _pkt._Pkt_version_get(pkt)})
            result.append({vid: pk.STRING, v: _pkt._Pkt_string_get(pkt)})
            result.append({vid: pk.TIME, v: _pkt._Pkt_time_get(pkt)})
            result.append({vid: pk.TYPE, v: _pkt._Pkt_pkttype_get(pkt)})

            pf = None
            pfptr = _pkt._Pkt_pfptr_get(pkt)
            if pfptr != None:
                try:
                    pf = _stock._pfget(pfptr, None)
                finally:
                    _stock._pffree(pfptr)
            result.append({vid: pk.PF, v: pf})

            # channels
            channels = []
            ck = AntelopeOrbPacketParticleChannelKey
            for pktchan in _pkt._Pkt_channels_get(pkt):
                channel = {}
                channels.append(channel)
                channel[ck.CALIB] = _pkt._PktChannel_calib_get(pktchan)
                channel[ck.CALPER] = _pkt._PktChannel_calper_get(pktchan)
                channel[ck.CHAN] = _pkt._PktChannel_chan_get(pktchan)
                channel[ck.CUSER1] = _pkt._PktChannel_cuser1_get(pktchan)
                channel[ck.CUSER2] = _pkt._PktChannel_cuser2_get(pktchan)
                channel[ck.DATA] = np.array(_pkt._PktChannel_data_get(pktchan))
                channel[ck.DUSER1] = _pkt._PktChannel_duser1_get(pktchan)
                channel[ck.DUSER2] = _pkt._PktChannel_duser2_get(pktchan)
                channel[ck.IUSER1] = _pkt._PktChannel_iuser1_get(pktchan)
                channel[ck.IUSER2] = _pkt._PktChannel_iuser2_get(pktchan)
                channel[ck.IUSER3] = _pkt._PktChannel_iuser3_get(pktchan)
                channel[ck.LOC] = _pkt._PktChannel_loc_get(pktchan)
                channel[ck.NET] = _pkt._PktChannel_net_get(pktchan)
                channel[ck.SAMPRATE] = _pkt._PktChannel_samprate_get(pktchan)
                channel[ck.SEGTYPE] = _pkt._PktChannel_segtype_get(pktchan)
                channel[ck.STA] = _pkt._PktChannel_sta_get(pktchan)
                channel[ck.TIME] = _pkt._PktChannel_time_get(pktchan)

            result.append({vid: pk.CHANNELS, v: channels})

        finally:
            if pkt is not None:
                _pkt._freePkt(pkt)

        return result
示例#9
0
 def __del__(self):
     log.trace("del pkt: %s", self._pkt)
     if self._pkt is not None:
         _pkt._freePkt(self._pkt)
示例#10
0
    def setUp(self):
        from mi.core.kudu import _pkt
        log.debug(
            "*********************************************************************"
        )
        log.debug("Starting Dataset Test %s", self._testMethodName)
        log.debug(
            "*********************************************************************"
        )
        log.debug("ID: %s", self.id())
        log.debug("DataSetTestCase setUp")

        # Test to ensure we have initialized our test config
        if not self.test_config.initialized:
            return TestNotInitialized(
                msg=
                "Tests non initialized. Missing DataSetTestCase.initialize(...)?"
            )

        log.debug("Driver Config: %s", self._driver_config())

        self.state_callback_result = []
        self.data_callback_result = []
        self.event_callback_result = []
        self.exception_callback_result = []

        self.memento = {}

        self.PKT_ID = PKT_ID = 123
        self.PKT_TYPE = PKT_TYPE = 'GENC'
        self.PKT_DATA = PKT_DATA = 1, 2, 3, 4
        self.PKT_TIME = PKT_TIME = 999
        self.PKT_SAMPRATE = PKT_SAMPRATE = 666
        self.PKT_NET = PKT_NET = 'net'
        self.PKT_STA = PKT_STA = 'sta'
        self.PKT_CHAN = PKT_CHAN = 'chan'
        self.PKT_LOC = PKT_LOC = 'loc'

        pkt = _pkt._newPkt()
        _pkt._Pkt_pkttype_set(pkt, PKT_TYPE)
        pktchan = _pkt._newPktChannel()
        _pkt._PktChannel_data_set(pktchan, PKT_DATA)
        _pkt._PktChannel_samprate_set(pktchan, PKT_SAMPRATE)
        _pkt._PktChannel_time_set(pktchan, PKT_TIME)
        _pkt._PktChannel_net_set(pktchan, PKT_NET)
        _pkt._PktChannel_sta_set(pktchan, PKT_STA)
        _pkt._PktChannel_chan_set(pktchan, PKT_CHAN)
        _pkt._PktChannel_loc_set(pktchan, PKT_LOC)
        _pkt._Pkt_channels_set(pkt, [
            pktchan,
        ])
        self.pkttype, self.packet, self.srcname, self.time = _pkt._stuffPkt(
            pkt)
        _pkt._freePkt(pkt)

        self.driver = self._get_driver_object()

        # NOTE why not do this in tearDown?
        self.addCleanup(self._stop_driver)

        self._metadata = None
        self._get_metadata()
示例#11
0
 def __del__(self):
     log.trace("del pkt: %s", self._pkt)
     if self._pkt is not None:
         _pkt._freePkt(self._pkt)