def parse(basePythonCodePath, sourceFilePath, particleDataHdlrObj):
from mi.logging import config
config.add_configuration(os.path.join(basePythonCodePath, 'res', 'config', 'mi-logging.yml'))
log = get_logger()
config = {
DataSetDriverConfigKeys.PARTICLE_MODULE: 'mi.dataset.parser.adcps_jln',
DataSetDriverConfigKeys.PARTICLE_CLASS: 'AdcpsJlnParticle'
}
log.trace("My ADCPS JLN Config: %s", config)
def exception_callback(exception):
log.debug("ERROR: " + exception)
particleDataHdlrObj.setParticleDataCaptureFailure()
with open(sourceFilePath, 'rb') as file_handle:
parser = AdcpPd0Parser(config, None, file_handle,
lambda state, ingested: None,
lambda data: None, exception_callback)
driver = DataSetDriver(parser, particleDataHdlrObj)
driver.processFileStream()
return particleDataHdlrObj
def process(self):
log = get_logger()
try:
file_handle = open(self._sourceFilePath, 'rb')
filesize = os.path.getsize(file_handle.name)
state = None
parser_state = None
def state_callback(state, ingested):
pass
def pub_callback(data):
log.trace("Found data: %s", data)
def sample_exception_callback(exception):
self._particleDataHdlrObj.setParticleDataCaptureFailure()
parser = CtdpfCklWfpParser(self._config, parser_state, file_handle, lambda state,
ingested: state_callback(state, ingested), pub_callback,
sample_exception_callback, filesize)
driver = DataSetDriver(parser, self._particleDataHdlrObj)
driver.processFileStream()
finally:
file_handle.close()
return self._particleDataHdlrObj
def parse(basePythonCodePath, sourceFilePath, particleDataHdlrObj):
config.add_configuration(os.path.join(basePythonCodePath, 'res', 'config', 'mi-logging.yml'))
log = get_logger()
parser_config = {
DataSetDriverConfigKeys.PARTICLE_MODULE: 'mi.dataset.parser.flord_l_wfp',
DataSetDriverConfigKeys.PARTICLE_CLASS: 'FlordLWfpInstrumentParserDataParticle'
}
def exception_callback(exception):
log.debug("ERROR: %r", exception)
particleDataHdlrObj.setParticleDataCaptureFailure()
with open(sourceFilePath, 'r') as stream_handle:
parser = GlobalWfpEFileParser(parser_config, None,
stream_handle,
lambda state, ingested: None,
lambda data: log.trace("Found data: %s", data),
exception_callback)
driver = DataSetDriver(parser, particleDataHdlrObj)
driver.processFileStream()
return particleDataHdlrObj
def parse(basePythonCodePath, sourceFilePath, particleDataHdlrObj):
config.add_configuration(os.path.join(basePythonCodePath, 'res', 'config', 'mi-logging.yml'))
log = get_logger()
parser_config = {
DataSetDriverConfigKeys.PARTICLE_MODULE: 'mi.dataset.parser.vel3d_k_wfp',
DataSetDriverConfigKeys.PARTICLE_CLASS: ['Vel3dKWfpMetadataParticle',
'Vel3dKWfpInstrumentParticle',
'Vel3dKWfpStringParticle']
}
def exception_callback(exception):
log.debug("ERROR: %r", exception)
particleDataHdlrObj.setParticleDataCaptureFailure()
with open(sourceFilePath, 'rb') as stream_handle:
parser = Vel3dKWfpParser(parser_config,
None,
stream_handle,
lambda state,file : None,
lambda data : None,
exception_callback)
driver = DataSetDriver(parser, particleDataHdlrObj)
driver.processFileStream()
return particleDataHdlrObj
def parse(basePythonCodePath, sourceFilePath, particleDataHdlrObj):
from mi.logging import config
config.add_configuration(os.path.join(basePythonCodePath, 'res', 'config', 'mi-logging.yml'))
log = get_logger()
config = {
DataSetDriverConfigKeys.PARTICLE_MODULE: 'mi.dataset.parser.adcps_jln_stc',
DataSetDriverConfigKeys.PARTICLE_CLASS: None,
DataSetDriverConfigKeys.PARTICLE_CLASSES_DICT: {
AdcpsJlnStcParticleClassKey.METADATA_PARTICLE_CLASS:
AdcpsJlnStcMetadataRecoveredDataParticle,
AdcpsJlnStcParticleClassKey.INSTRUMENT_PARTICLE_CLASS:
AdcpsJlnStcInstrumentRecoveredDataParticle,
}
}
log.debug("My ADCPS JLN STC Config: %s", config)
def exception_callback(exception):
log.debug("ERROR: %r", exception)
particleDataHdlrObj.setParticleDataCaptureFailure()
with open(sourceFilePath, 'rb') as file_handle:
parser = AdcpsJlnStcParser(config,
None,
file_handle,
lambda state, ingested: None,
lambda data: None,
exception_callback)
driver = DataSetDriver(parser, particleDataHdlrObj)
driver.processFileStream()
return particleDataHdlrObj
def parse(basePythonCodePath, sourceFilePath, particleDataHdlrObj):
try:
if basePythonCodePath is not None:
pass
except NameError:
basePythonCodePath = os.curdir
sys.path.append(basePythonCodePath)
from mi.logging import config
config.add_configuration(os.path.join(basePythonCodePath, 'res', 'config', 'mi-logging.yml'))
from mi.core.log import get_logger
log = get_logger()
"""
Build and return the parser
"""
config = {
DataSetDriverConfigKeys.PARTICLE_MODULE: 'mi.dataset.parser.ctdpf_ckl_wfp_particles',
DataSetDriverConfigKeys.PARTICLE_CLASS: None,
DataSetDriverConfigKeys.PARTICLE_CLASSES_DICT: {
'instrument_data_particle_class': CtdpfCklWfpTelemeteredDataParticle,
'metadata_particle_class': CtdpfCklWfpTelemeteredMetadataParticle
}
}
log.debug("My Config: %s", config)
driver = CtdpfCklWfpDriver(sourceFilePath, particleDataHdlrObj, config)
return driver.process()
def parse(basePythonCodePath, sourceFilePath, particleDataHdlrObj):
"""
This is the method called by Uframe
:param basePythonCodePath This is the file system location of mi-dataset
:param sourceFilePath This is the full path and filename of the file to be parsed
:param particleDataHdlrObj Java Object to consume the output of the parser
:return particleDataHdlrObj
"""
log = get_logger()
with open(sourceFilePath, 'rb') as stream_handle:
def exception_callback(exception):
log.debug("Exception: %s", exception)
particleDataHdlrObj.setParticleDataCaptureFailure()
parser_config = {
DataSetDriverConfigKeys.PARTICLE_MODULE: 'mi.dataset.parser.ctdmo_ghqr_sio',
DataSetDriverConfigKeys.PARTICLE_CLASS: ['CtdmoGhqrSioTelemeteredInstrumentDataParticle',
'CtdmoGhqrSioTelemeteredOffsetDataParticle']
}
parser = CtdmoGhqrSioTelemeteredParser(parser_config, stream_handle, exception_callback)
# create and instance of the concrete driver class defined below
driver = DataSetDriver(parser, particleDataHdlrObj)
driver.processFileStream()
return particleDataHdlrObj
def process(self):
"""
Process a file by opening the file and instantiating a parser and driver
"""
log = get_logger()
with open(self._source_file_path, "rb") as file_handle:
def exception_callback(exception):
log.debug("Exception %s", exception)
self._particle_data_hdlr_obj.setParticleDataCaptureFailure()
# essentially comment out the state and data callbacks by inserting
# lambda with None functions, so it doesn't complain about not being
# able to pass arguments
parser = GliderEngineeringParser(self._parser_config, None,
file_handle,
lambda state, ingested: None,
lambda data: None,
exception_callback)
# instantiate the driver
driver = DataSetDriver(parser, self._particle_data_hdlr_obj)
# start the driver processing the file
driver.processFileStream()
return self._particle_data_hdlr_obj
def parse(unused, source_file_path, particle_data_handler):
"""
This is the method called by Uframe
:param unused
:param source_file_path This is the full path and filename of the file to be parsed
:param particle_data_handler Java Object to consume the output of the parser
:return particle_data_handler
"""
log = get_logger()
with open(source_file_path, 'r') as stream_handle:
def exception_callback(exception):
log.debug("Exception: %s", exception)
particle_data_handler.setParticleDataCaptureFailure()
# extract the serial number from the file name
serial_num = get_serial_num_from_filepath(source_file_path)
parser_config = {
DataSetDriverConfigKeys.PARTICLE_MODULE: 'mi.dataset.parser.ctdmo_ghqr_sio',
DataSetDriverConfigKeys.PARTICLE_CLASS: ['CtdmoGhqrRecoveredInstrumentDataParticle'],
INDUCTIVE_ID_KEY: serial_num
}
parser = CtdmoGhqrRecoveredCtParser(parser_config, stream_handle, exception_callback)
# create and instance of the concrete driver class defined below
driver = DataSetDriver(parser, particle_data_handler)
driver.processFileStream()
return particle_data_handler
def parse(basePythonCodePath, sourceFilePath, particleDataHdlrObj):
config.add_configuration(os.path.join(basePythonCodePath, 'res', 'config', 'mi-logging.yml'))
log = get_logger()
parser_config = {
DataSetDriverConfigKeys.PARTICLE_MODULE: 'mi.dataset.parser.nutnr_b_particles',
DataSetDriverConfigKeys.PARTICLE_CLASS: None
}
def exception_callback(exception):
log.debug("ERROR: " + exception)
particleDataHdlrObj.setParticleDataCaptureFailure()
with open(sourceFilePath, 'r') as stream_handle:
parser = NutnrBDclConcRecoveredParser(parser_config,
stream_handle,
lambda state, ingested : None,
lambda data : None,
exception_callback)
driver = DataSetDriver(parser, particleDataHdlrObj)
driver.processFileStream()
return particleDataHdlrObj
def parse(basePythonCodePath, sourceFilePath, particleDataHdlrObj):
from mi.logging import config
config.add_configuration(os.path.join(basePythonCodePath, 'res', 'config', 'mi-logging.yml'))
log = get_logger()
config = {
DataSetDriverConfigKeys.PARTICLE_CLASSES_DICT: {
'velocity': 'VelocityEarth',
'engineering': 'AdcpsEngineering',
'config': 'AdcpsConfig',
'bottom_track': 'EarthBottom',
'bottom_track_config': 'BottomConfig',
}
}
log.trace("My ADCPS JLN Config: %s", config)
def exception_callback(exception):
log.error("ERROR: %r", exception)
particleDataHdlrObj.setParticleDataCaptureFailure()
with open(sourceFilePath, 'rb') as file_handle:
parser = AdcpPd0Parser(config, file_handle, exception_callback)
driver = DataSetDriver(parser, particleDataHdlrObj)
driver.processFileStream()
return particleDataHdlrObj
def parse(basePythonCodePath, sourceFilePath, particleDataHdlrObj):
from mi.logging import config
config.add_configuration(os.path.join(basePythonCodePath, "res", "config", "mi-logging.yml"))
from mi.core.log import get_logger
log = get_logger()
from mi.dataset.dataset_driver import DataSetDriver, ParticleDataHandler
from mi.dataset.parser.parad_k_stc_imodem import Parad_k_stc_imodemParser
from mi.dataset.dataset_parser import DataSetDriverConfigKeys
config = {
DataSetDriverConfigKeys.PARTICLE_MODULE: "mi.dataset.parser.parad_k_stc_imodem",
DataSetDriverConfigKeys.PARTICLE_CLASS: "Parad_k_stc_imodemDataParticle",
}
try:
if particleDataHdlrObj is not None:
pass
except NameError:
particleDataHdlrObj = ParticleDataHandler()
try:
if sourceFilePath is not None:
pass
except NameError:
try:
sourceFilePath = sys.argv[1]
except IndexError:
print "Need a source file path"
sys.exit(1)
def state_callback(state, ingested):
pass
def pub_callback(data):
log.trace("Found data: %s", data)
def exception_callback(exception):
particleDataHdlrObj.setParticleDataCaptureFailure()
stream_handle = open(sourceFilePath, "rb")
try:
parser = Parad_k_stc_imodemParser(config, None, stream_handle, state_callback, pub_callback, exception_callback)
driver = DataSetDriver(parser, particleDataHdlrObj)
driver.processFileStream()
finally:
stream_handle.close()
stream_handle = open(sourceFilePath, "rb")
return particleDataHdlrObj
def parse(basePythonCodePath, sourceFilePath, particleDataHdlrObj):
log = get_logger()
with open(sourceFilePath, "r") as stream_handle:
def exception_callback(exception):
log.debug("Exception: %s", exception)
particleDataHdlrObj.setParticleDataCaptureFailure()
parser = CtdbpCdefCpParser({}, stream_handle, exception_callback)
driver = DataSetDriver(parser, particleDataHdlrObj)
driver.processFileStream()
return particleDataHdlrObj
def process(self):
log = get_logger()
with open(self._sourceFilePath, "r") as file_handle:
def exception_callback(exception):
log.debug("Exception: %s", exception)
self._particleDataHdlrObj.setParticleDataCaptureFailure()
parser = FlortDjDclParser(self._parser_config, file_handle, exception_callback)
driver = DataSetDriver(parser, self._particleDataHdlrObj)
driver.processFileStream()
return self._particleDataHdlrObj
def process(self):
log = get_logger()
with open(self._source_file_path, "rb") as file_handle:
def exception_callback(exception):
log.debug("Exception: %s", exception)
self._particle_data_handler.setParticleDataCaptureFailure()
parser = OptaaDjDclParser(self._parser_config,
file_handle, exception_callback, self._source_file_path, True)
driver = DataSetDriver(parser, self._particle_data_handler)
driver.processFileStream()
return self._particle_data_handler
def process(self):
log = get_logger()
def exception_callback(exception):
log.debug("ERROR: %r", exception)
self._particleDataHdlrObj.setParticleDataCaptureFailure()
with open(self._sourceFilePath, 'r') as stream_handle:
parser = CgCpmEngCpmParser(self._parser_config, stream_handle,
exception_callback)
driver = DataSetDriver(parser, self._particleDataHdlrObj)
driver.processFileStream()
return self._particleDataHdlrObj
def process(self):
log = get_logger()
def exception_callback(exception):
log.debug("ERROR: " + exception)
self._particleDataHdlrObj.setParticleDataCaptureFailure()
with open(self._sourceFilePath, 'rb') as stream_handle:
parser = CgStcEngStcParser(self._parser_config, None, stream_handle,
lambda state, ingested: None,
lambda data: None, exception_callback)
driver = DataSetDriver(parser, self._particleDataHdlrObj)
driver.processFileStream()
return self._particleDataHdlrObj
def process(self):
log = get_logger()
def exception_callback(exception):
log.debug("ERROR: %r", exception)
self._particleDataHdlrObj.setParticleDataCaptureFailure()
pathList = (self._sourceFilePath.split('/'))
filename = pathList[len(pathList) - 1]
with open(self._sourceFilePath, 'rb') as stream_handle:
parser = MopakODclParser(self._parser_config, stream_handle,
filename, exception_callback)
driver = DataSetDriver(parser, self._particleDataHdlrObj)
driver.processFileStream()
return self._particleDataHdlrObj
def process(self):
"""
Process a file by opening the file and instantiating a parser and driver
@return: processed particle data handler object
"""
log = get_logger()
with open(self._sourceFilePath, "r") as file_handle:
def exception_callback(exception):
log.warn("Exception: %s", exception)
self._particleDataHdlrObj.setParticleDataCaptureFailure()
# instantiate the parser
parser = WavssADclParser(file_handle, exception_callback, True)
# instantiate the driver
driver = DataSetDriver(parser, self._particleDataHdlrObj)
# start the driver processing the file
driver.processFileStream()
return self._particleDataHdlrObj
def process(self):
log = get_logger()
with open(self._sourceFilePath, "r") as file_handle:
def exception_callback(exception):
log.debug("Exception: %s", exception)
self._particleDataHdlrObj.setParticleDataCaptureFailure()
parser = SpkirAbjDclTelemeteredParser(self._parser_config,
file_handle,
None,
lambda state, ingested: None,
lambda data: None,
exception_callback)
driver = DataSetDriver(parser, self._particleDataHdlrObj)
driver.processFileStream()
return self._particleDataHdlrObj
def parse(basePythonCodePath, sourceFilePath, particleDataHdlrObj, serialNumToInductiveIdMapHandler):
"""
This is the method called by Uframe
:param basePythonCodePath This is the file system location of mi-dataset
:param sourceFilePath This is the full path and filename of the file to be parsed
:param particleDataHdlrObj Java Object to consume the output of the parser
:return particleDataHdlrObj
"""
log = get_logger()
with open(sourceFilePath, 'r') as stream_handle:
def exception_callback(exception):
log.debug("Exception: %s", exception)
particleDataHdlrObj.setParticleDataCaptureFailure()
# extract the serial number from the file name
serial_num = get_serial_num_from_filepath(sourceFilePath)
# retrieve the inductive ID associated with the serial number
induct_id = serialNumToInductiveIdMapHandler.getInductiveId(serial_num)
if not induct_id:
raise DatasetParserException(
"Unable to obtain the inductive ID associated with serial num %d",
serial_num)
parser_config = {
DataSetDriverConfigKeys.PARTICLE_MODULE: 'mi.dataset.parser.ctdmo_ghqr_sio',
DataSetDriverConfigKeys.PARTICLE_CLASS: ['CtdmoGhqrRecoveredInstrumentDataParticle'],
INDUCTIVE_ID_KEY: induct_id
}
parser = CtdmoGhqrRecoveredCtParser(parser_config, stream_handle, exception_callback)
# create and instance of the concrete driver class defined below
driver = DataSetDriver(parser, particleDataHdlrObj)
driver.processFileStream()
return particleDataHdlrObj
def parse(basePythonCodePath, sourceFilePath, particleDataHdlrObj):
log = get_logger()
with open(sourceFilePath, "r") as stream_handle:
def exception_callback(exception):
log.debug("Exception: %s", exception)
particleDataHdlrObj.setParticleDataCaptureFailure()
parser = CtdbpCdefCpParser(
{DataSetDriverConfigKeys.PARTICLE_MODULE: "mi.dataset.parser.ctdbp_cdef_cp",
DataSetDriverConfigKeys.PARTICLE_CLASS: None},
stream_handle,
lambda state, ingested: None,
lambda data: None,
exception_callback
)
driver = DataSetDriver(parser, particleDataHdlrObj)
driver.processFileStream()
return particleDataHdlrObj
def process(self):
log = get_logger()
with open(self._source_file_path,"rb") as file_handle:
def exception_callback(exception):
log.debug("Exception: %s", exception)
self._particle_data_handler.setParticleDataCaptureFailure()
parser = WfpEngStcImodemParser(self._parser_config,
None, file_handle,
lambda state, ingested: None,
lambda data: None,
exception_callback)
driver = DataSetDriver(parser, self._particle_data_handler)
driver.processFileStream()
return self._particle_data_handler
def parse(basePythonCodePath, sourceFilePath, particleDataHdlrObj):
config.add_configuration(os.path.join(basePythonCodePath, "res", "config", "mi-logging.yml"))
log = get_logger()
parser_config = {
DataSetDriverConfigKeys.PARTICLE_MODULE: "mi.dataset.parser.vel3d_k_wfp_stc",
DataSetDriverConfigKeys.PARTICLE_CLASS: ["Vel3dKWfpStcMetadataParticle", "Vel3dKWfpStcInstrumentParticle"],
}
def exception_callback(exception):
log.debug("ERROR: %r", exception)
particleDataHdlrObj.setParticleDataCaptureFailure()
with open(sourceFilePath, "rb") as stream_handle:
parser = Vel3dKWfpStcParser(parser_config, stream_handle, exception_callback)
driver = DataSetDriver(parser, particleDataHdlrObj)
driver.processFileStream()
return particleDataHdlrObj
def parse(unused, source_file_path, particle_data_handler):
log = get_logger()
with open(source_file_path, "r") as stream_handle:
def exception_callback(exception):
log.debug("Exception: %s", exception)
particle_data_handler.setParticleDataCaptureFailure()
parser = DostaLnWfpParser(
{DataSetDriverConfigKeys.PARTICLE_MODULE: 'mi.dataset.parser.dosta_ln_wfp',
DataSetDriverConfigKeys.PARTICLE_CLASS: 'DostaLnWfpInstrumentParserDataParticle'},
{StateKey.POSITION: 0},
stream_handle,
lambda state, ingested: None,
lambda data: None,
exception_callback
)
driver = DataSetDriver(parser, particle_data_handler)
driver.processFileStream()
return particle_data_handler
def process(self):
log = get_logger()
with open(self._sourceFilePath, 'rb') as file_handle:
def exception_callback(exception):
log.debug('Exception: %s', exception)
self._particleDataHdlrObj.setParticleDataCaptureFailure()
parser = GliderParser(self._config,
None,
file_handle,
lambda state, ingested: None,
lambda data: None,
exception_callback)
driver = DataSetDriver(parser, self._particleDataHdlrObj)
driver.processFileStream()
return self._particleDataHdlrObj
def process(self):
log = get_logger()
stream_handle = open(self._sourceFilePath, 'rb')
filesize = os.path.getsize(stream_handle.name)
def state_callback(state, ingested):
pass
def pub_callback(data):
log.trace("Found data: %s", data)
def exp_callback(exception):
self._particleDataHdlrObj.setParticleDataCaptureFailure()
try:
parser = DofstKWfpParser(self._config, None, stream_handle, state_callback, pub_callback, exp_callback, filesize)
driver = DataSetDriver(parser, self._particleDataHdlrObj)
driver.processFileStream()
finally:
stream_handle.close()
return self._particleDataHdlrObj
def parse(basePythonCodePath, sourceFilePath, particleDataHdlrObj):
from mi.logging import config
config.add_configuration(os.path.join(basePythonCodePath, "res", "config", "mi-logging.yml"))
log = get_logger()
config = {
DataSetDriverConfigKeys.PARTICLE_MODULE: "mi.dataset.parser.adcps_jln",
DataSetDriverConfigKeys.PARTICLE_CLASS: "AdcpsJlnParticle",
}
log.trace("My ADCPS JLN Config: %s", config)
def exception_callback(exception):
log.debug("ERROR: %r", exception)
particleDataHdlrObj.setParticleDataCaptureFailure()
with open(sourceFilePath, "rb") as file_handle:
parser = AdcpPd0Parser(config, file_handle, exception_callback)
driver = DataSetDriver(parser, particleDataHdlrObj)
driver.processFileStream()
return particleDataHdlrObj
_author__ = 'jeff roy'
from mi.core.log import get_logger
log = get_logger()
from mi.idk.config import Config
import unittest
import os
from mi.dataset.driver.flord_g.ctdbp_p.dcl.flord_g_ctdbp_p_dcl_telemetered_driver import parse
from mi.dataset.dataset_driver import ParticleDataHandler
class DriverTest(unittest.TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def test_one(self):
sourceFilePath = os.path.join('mi',
'dataset', 'driver', 'ctdbp_p',
'dcl', 'resource',
'ctdbp01_20150804_061734.DAT')
particle_data_hdlr_obj = ParticleDataHandler()
#!/usr/bin/env python
"""
@package mi.dataset.parser.test.test_phsen
@file marine-integrations/mi/dataset/parser/test/test_phsen.py
@author Emily Hahn
@brief Test code for a Phsen data parser
"""
import os
from nose.plugins.attrib import attr
from mi.core.log import get_logger ; log = get_logger()
from mi.dataset.test.test_parser import ParserUnitTestCase
from mi.dataset.parser.mflm import StateKey
from mi.dataset.dataset_driver import DataSetDriverConfigKeys
from mi.core.instrument.data_particle import DataParticleKey
from mi.dataset.parser.phsen import PhsenParser, PhsenParserDataParticle
from mi.idk.config import Config
RESOURCE_PATH = os.path.join(Config().base_dir(), 'mi',
'dataset', 'driver', 'mflm',
'phsen', 'resource')
@attr('UNIT', group='mi')
class PhsenParserUnitTestCase(ParserUnitTestCase):
"""
Phsen Parser unit test suite
"""
def state_callback(self, state):
""" Call back method to watch what comes in via the position callback """
def __init__(self, label=None, logger=None):
self.start_time = datetime.datetime.now()
self.label = label
self.logger = logger if logger else get_logger().debug
def parse(basePythonCodePath, sourceFilePath, particleDataHdlrObj):
try:
if basePythonCodePath is not None:
pass
except NameError:
basePythonCodePath = os.curdir
sys.path.append(basePythonCodePath)
from mi.logging import config
config.add_configuration(os.path.join(basePythonCodePath, 'res', 'config', 'mi-logging.yml'))
from mi.core.log import get_logger
log = get_logger()
from mi.dataset.dataset_driver import DataSetDriver, ParticleDataHandler
from mi.dataset.parser.ctdpf_ckl_mmp_cds import CtdpfCklMmpCdsParser
from mi.dataset.dataset_parser import DataSetDriverConfigKeys
config = {
DataSetDriverConfigKeys.PARTICLE_MODULE: 'mi.dataset.parser.ctdpf_ckl_mmp_cds',
DataSetDriverConfigKeys.PARTICLE_CLASS: 'CtdpfCklMmpCdsParserDataParticle'
}
try:
if particleDataHdlrObj is not None:
pass
except NameError:
particleDataHdlrObj = ParticleDataHandler()
try:
if sourceFilePath is not None:
pass
except NameError:
try:
sourceFilePath = sys.argv[1]
except IndexError:
print "Need a source file path"
sys.exit(1)
def state_callback(state, ingested):
pass
def pub_callback(data):
log.trace("Found data: %s", data)
stream_handle = open(sourceFilePath, 'rb')
try:
parser = CtdpfCklMmpCdsParser(config, None, stream_handle,
state_callback, pub_callback)
driver = DataSetDriver(parser, particleDataHdlrObj)
driver.processFileStream()
finally:
stream_handle.close()
return particleDataHdlrObj
* From the IDK
$ bin/dsa/test_driver
$ bin/dsa/test_driver -i [-t testname]
$ bin/dsa/test_driver -q [-t testname]
"""
__author__ = 'Bill French'
__license__ = 'Apache 2.0'
import gevent
import unittest
from nose.plugins.attrib import attr
from mock import Mock
from mi.core.log import get_logger ; log = get_logger()
from exceptions import Exception
from mi.idk.dataset.unit_test import DataSetTestCase
from mi.idk.dataset.unit_test import DataSetTestConfig
from mi.idk.dataset.unit_test import DataSetUnitTestCase
from mi.idk.dataset.unit_test import DataSetIntegrationTestCase
from mi.idk.dataset.unit_test import DataSetQualificationTestCase
from mi.core.exceptions import ConfigurationException
from mi.core.exceptions import SampleException
from mi.core.exceptions import InstrumentParameterException
from mi.idk.exceptions import SampleTimeout
from mi.dataset.dataset_driver import DataSourceConfigKey, DataSetDriverConfigKeys
#!/home/mworden/uframes/ooi/uframe-1.0/python/bin/python
__author__ = 'mworden'
from mi.core.log import get_logger
log = get_logger()
from mi.idk.config import Config
import unittest
import os
from mi.dataset.driver.nutnr_b.nutnr_b_recovered_driver import parse
from mi.dataset.dataset_driver import ParticleDataHandler
class SampleTest(unittest.TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def test_one(self):
sourceFilePath = os.path.join('mi', 'dataset', 'driver', 'nutnr_b',
'resource', 'SCH14178.DAT')
particle_data_hdlr_obj = ParticleDataHandler()
particle_data_hdlr_obj = parse(Config().base_dir(), sourceFilePath,
