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'))
parser_config = {
DataSetDriverConfigKeys.PARTICLE_MODULE: 'mi.dataset.parser.phsen_abcdef',
DataSetDriverConfigKeys.PARTICLE_CLASS: ['PhsenRecoveredMetadataDataParticle',
'PhsenRecoveredInstrumentDataParticle']
}
def exception_callback(exception):
log.debug("ERROR: %r", exception)
particleDataHdlrObj.setParticleDataCaptureFailure()
with open(sourceFilePath, 'rb') as stream_handle:
parser = PhsenRecoveredParser(parser_config,
None,
stream_handle,
lambda state, ingested: None,
lambda data: None,
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'))
parser_config = {
DataSetDriverConfigKeys.PARTICLE_MODULE: 'mi.dataset.parser.dosta_abcdjm_mmp_cds',
DataSetDriverConfigKeys.PARTICLE_CLASS: 'DostaAbcdjmMmpCdsParserDataParticle'
}
def exception_callback(exception):
log.debug("ERROR: " + exception)
particleDataHdlrObj.setParticleDataCaptureFailure()
with open(sourceFilePath, 'rb') as stream_handle:
parser = DostaAbcdjmMmpCdsParser(parser_config,
None,
stream_handle,
lambda state, ingested: None,
lambda data: None,
exception_callback)
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 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(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(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, 'rb') as stream_handle:
def exception_callback(exception):
log.debug("Exception: %s", exception)
particle_data_handler.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, particle_data_handler)
driver.processFileStream()
return particle_data_handler
def parse(unused, source_file_path, particle_data_handler):
config = {
DataSetDriverConfigKeys.PARTICLE_MODULE: 'mi.dataset.parser.adcps_jln_stc',
DataSetDriverConfigKeys.PARTICLE_CLASS: None,
DataSetDriverConfigKeys.PARTICLE_CLASSES_DICT: {
AdcpsJlnStcParticleClassKey.METADATA_PARTICLE_CLASS:
AdcpsJlnStcMetadataTelemeteredDataParticle,
AdcpsJlnStcParticleClassKey.INSTRUMENT_PARTICLE_CLASS:
AdcpsJlnStcInstrumentTelemeteredDataParticle,
}
}
log.debug("My ADCPS JLN STC Config: %s", config)
def exception_callback(exception):
log.debug("ERROR: %r", exception)
particle_data_handler.setParticleDataCaptureFailure()
with open(source_file_path, 'rb') as file_handle:
parser = AdcpsJlnStcParser(config,
file_handle,
exception_callback)
driver = DataSetDriver(parser, particle_data_handler)
driver.processFileStream()
return particle_data_handler
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):
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):
"""
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 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: %r", exception)
particleDataHdlrObj.setParticleDataCaptureFailure()
with open(sourceFilePath, 'r') as stream_handle:
parser = NutnrBDclConcTelemeteredParser(parser_config, 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()
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):
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 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):
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:
'AdcpsJlnStcInstrumentParserDataParticle'
}
log.debug("My ADCPS JLN STC Config: %s", config)
def exception_callback(exception):
log.debug("ERROR: " + 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):
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(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 parse(unused, source_file_path, particle_data_handler):
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)
particle_data_handler.setParticleDataCaptureFailure()
with open(source_file_path, 'rb') as file_handle:
parser = AdcpsJlnStcParser(config, file_handle, exception_callback)
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.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):
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: [
'NutnrBMetadataRecoveredDataParticle',
'NutnrBInstrumentRecoveredDataParticle'
]
}
def exception_callback(exception):
log.debug("ERROR: " + exception)
particleDataHdlrObj.setParticleDataCaptureFailure()
with open(sourceFilePath, 'r') as stream_handle:
parser = NutnrBParser(parser_config, stream_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'))
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(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):
"""
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:
['CtdmoGhqrSioRecoveredOffsetDataParticle']
}
parser = CtdmoGhqrSioRecoveredCoParser(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(unused, source_file_path, particle_data_handler):
config = {
DataSetDriverConfigKeys.PARTICLE_MODULE: 'mi.dataset.parser.parad_k_stc_imodem',
DataSetDriverConfigKeys.PARTICLE_CLASS: 'Parad_k_stc_imodemDataParticle'
}
def state_callback(state, ingested):
pass
def pub_callback(data):
log.trace("Found data: %s", data)
def exception_callback(exception):
particle_data_handler.setParticleDataCaptureFailure()
stream_handle = open(source_file_path, 'rb')
try:
parser = Parad_k_stc_imodemParser(config, None, stream_handle,
state_callback, pub_callback,
exception_callback)
driver = DataSetDriver(parser, particle_data_handler)
driver.processFileStream()
finally:
stream_handle.close()
return particle_data_handler
def parse(unused, source_file_path, particle_data_handler):
"""
This is the method called by Uframe. Note since the instrument in use is not inductive
there is no need to attempt to extract that value from the name of the parsed file.
: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()
parser_config = {
DataSetDriverConfigKeys.PARTICLE_MODULE: MODULE_NAME,
DataSetDriverConfigKeys.PARTICLE_CLASS: [PARTICLE_CLASS]
}
parser = MetbkCtDclParser(parser_config, stream_handle,
exception_callback)
driver = DataSetDriver(parser, particle_data_handler)
driver.processFileStream()
return particle_data_handler
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, file_handle, 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'))
parser_config = {
DataSetDriverConfigKeys.PARTICLE_MODULE:
'mi.dataset.parser.dosta_abcdjm_mmp_cds',
DataSetDriverConfigKeys.PARTICLE_CLASS:
'DostaAbcdjmMmpCdsParserDataParticle'
}
def exception_callback(exception):
log.debug("ERROR: %r", exception)
particleDataHdlrObj.setParticleDataCaptureFailure()
with open(sourceFilePath, 'rb') as stream_handle:
parser = DostaAbcdjmMmpCdsParser(parser_config, None, 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"))
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 process(source_file_path, particle_data_hdlr_obj, particle_class):
with open(source_file_path, "r") as stream_handle:
parser = MetbkADclParser(
{
DataSetDriverConfigKeys.PARTICLE_MODULE: MODULE_NAME,
DataSetDriverConfigKeys.PARTICLE_CLASS: particle_class
}, stream_handle,
lambda ex: particle_data_hdlr_obj.setParticleDataCaptureFailure())
driver = DataSetDriver(parser, particle_data_hdlr_obj)
driver.processFileStream()
def parse(basePythonCodePath, sourceFilePath, particleDataHdlrObj):
with open(sourceFilePath,"r") as fil :
parser = Flort_kn_stc_imodemParser(
{DataSetDriverConfigKeys.PARTICLE_MODULE:"mi.dataset.parser.flort_kn__stc_imodem",DataSetDriverConfigKeys.PARTICLE_CLASS:"Flort_kn_stc_imodemParserDataParticleTelemetered"},
None,
fil,
lambda state,file : None,
lambda state : None)
driver = DataSetDriver(parser, particleDataHdlrObj)
driver.processFileStream()
return particleDataHdlrObj
def parse(basePythonCodePath, sourceFilePath, particleDataHdlrObj):
with open(sourceFilePath,"r") as fil :
parser = Flort_kn_stc_imodemParser(
{DataSetDriverConfigKeys.PARTICLE_MODULE:"mi.dataset.parser.flort_kn__stc_imodem",DataSetDriverConfigKeys.PARTICLE_CLASS:"Flort_kn_stc_imodemParserDataParticleRecovered"},
None,
fil,
lambda state,file : None,
lambda state : None)
driver = DataSetDriver(parser, particleDataHdlrObj)
driver.processFileStream()
return particleDataHdlrObj
def process(source_file_path, particle_data_handler, particle_class):
with open(source_file_path, "r") as stream_handle:
parser = MetbkADclParser(
{DataSetDriverConfigKeys.PARTICLE_MODULE: MODULE_NAME,
DataSetDriverConfigKeys.PARTICLE_CLASS: particle_class},
stream_handle,
lambda ex: particle_data_handler.setParticleDataCaptureFailure()
)
driver = DataSetDriver(parser, particle_data_handler)
driver.processFileStream()
def parse(unused, source_file_path, particle_data_handler):
with open(source_file_path, "r") as fil:
parser = Flort_kn_stc_imodemParser(
{
DataSetDriverConfigKeys.PARTICLE_MODULE:
"mi.dataset.parser.flort_kn__stc_imodem",
DataSetDriverConfigKeys.PARTICLE_CLASS:
"Flort_kn_stc_imodemParserDataParticleRecovered"
}, None, fil, lambda state, f: None, lambda state: None)
driver = DataSetDriver(parser, particle_data_handler)
driver.processFileStream()
return particle_data_handler
def process(self):
with open(self._source_file_path, 'rb') as stream_handle:
def exp_callback(exception):
self._particle_data_handler.setParticleDataCaptureFailure()
parser = GliderParser(self._config, stream_handle, exp_callback)
driver = DataSetDriver(parser, self._particle_data_handler)
driver.processFileStream()
return self._particle_data_handler
def process(source_file_path, particle_data_handler, particle_classes):
with open(source_file_path, "r") as stream_handle:
parser = Pco2aADclParser(
{
DataSetDriverConfigKeys.PARTICLE_MODULE: MODULE_NAME,
DataSetDriverConfigKeys.PARTICLE_CLASS: None,
DataSetDriverConfigKeys.PARTICLE_CLASSES_DICT: particle_classes
}, stream_handle,
lambda ex: particle_data_handler.setParticleDataCaptureFailure())
driver = DataSetDriver(parser, particle_data_handler)
driver.processFileStream()
def parse(basePythonCodePath, sourceFilePath, particleDataHdlrObj):
with open(sourceFilePath,"r") as fil :
parser = FlortDjDclRecoveredParser(
{DataSetDriverConfigKeys.PARTICLE_MODULE:"mi.dataset.parser.flort_dj_dcl",DataSetDriverConfigKeys.PARTICLE_CLASS:None},
fil,
None,
state_callback,
pub_callback,
exception_callback);
driver = DataSetDriver(parser, particleDataHdlrObj)
driver.processFileStream()
return particleDataHdlrObj
def parse(unused, source_file_path, particle_data_handler):
with open(source_file_path,"r") as fil :
parser = Flort_kn_stc_imodemParser({
DataSetDriverConfigKeys.PARTICLE_MODULE:"mi.dataset.parser.flort_kn__stc_imodem",
DataSetDriverConfigKeys.PARTICLE_CLASS:"Flort_kn_stc_imodemParserDataParticleTelemetered"},
None,
fil,
lambda state, f: None,
lambda state :None)
driver = DataSetDriver(parser, particle_data_handler)
driver.processFileStream()
return particle_data_handler
def process(source_file_path, particle_data_hdlr_obj, particle_classes):
with open(source_file_path, "r") as stream_handle:
parser = Pco2aADclParser(
{DataSetDriverConfigKeys.PARTICLE_MODULE: MODULE_NAME,
DataSetDriverConfigKeys.PARTICLE_CLASS: None,
DataSetDriverConfigKeys.PARTICLE_CLASSES_DICT: particle_classes},
stream_handle,
lambda ex: particle_data_hdlr_obj.setParticleDataCaptureFailure()
)
driver = DataSetDriver(parser, particle_data_hdlr_obj)
driver.processFileStream()
def process(self):
with open(self._source_file_path, 'rb') as stream_handle:
def exp_callback(exception):
self._particle_data_handler.setParticleDataCaptureFailure()
parser = GliderParser(self._config,
stream_handle,
exp_callback)
driver = DataSetDriver(parser, self._particle_data_handler)
driver.processFileStream()
return self._particle_data_handler
def process(source_file_path, particle_data_hdlr_obj, particle_class):
with open(source_file_path, "r") as stream_handle:
parser = MetbkADclParser(
{DataSetDriverConfigKeys.PARTICLE_MODULE: MODULE_NAME,
DataSetDriverConfigKeys.PARTICLE_CLASS: particle_class},
stream_handle,
lambda state, ingested: None,
lambda data: log.trace("Found data: %s", data),
lambda ex: particle_data_hdlr_obj.setParticleDataCaptureFailure()
)
driver = DataSetDriver(parser, particle_data_hdlr_obj)
driver.processFileStream()
def parse(unused, source_file_path, particle_data_handler):
with open(source_file_path, "r") as stream_handle:
def exception_callback(exception):
log.debug("Exception: %s", exception)
particle_data_handler.setParticleDataCaptureFailure()
parser = DeepProfilerParser({}, stream_handle, exception_callback)
driver = DataSetDriver(parser, particle_data_handler)
driver.processFileStream()
return particle_data_handler
def process(source_file_path, particle_data_hdlr_obj, particle_classes):
with open(source_file_path, "r") as stream_handle:
parser = Pco2aADclParser(
{
DataSetDriverConfigKeys.PARTICLE_MODULE: MODULE_NAME,
DataSetDriverConfigKeys.PARTICLE_CLASS: None,
DataSetDriverConfigKeys.PARTICLE_CLASSES_DICT: particle_classes
}, stream_handle, lambda state, ingested: None,
lambda data: log.trace("Found data: %s", data),
lambda ex: particle_data_hdlr_obj.setParticleDataCaptureFailure())
driver = DataSetDriver(parser, particle_data_hdlr_obj)
driver.processFileStream()
def parse(unused, source_file_path, particle_data_handler):
with open(source_file_path, "r") as stream_handle:
def exception_callback(exception):
log.debug("Exception: %s", exception)
particle_data_handler.setParticleDataCaptureFailure()
parser = DeepProfilerParser({}, stream_handle, exception_callback)
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'))
with open(sourceFilePath, "r") as stream_handle:
def exception_callback(exception):
log.debug("Exception: %s", exception)
particleDataHdlrObj.setParticleDataCaptureFailure()
parser = DeepProfilerParser({}, stream_handle, exception_callback)
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({}, stream_handle, 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'))
with open(sourceFilePath, "r") as stream_handle:
def exception_callback(exception):
log.debug("Exception: %s", exception)
particleDataHdlrObj.setParticleDataCaptureFailure()
parser = DeepProfilerParser({}, stream_handle, exception_callback)
driver = DataSetDriver(parser, particleDataHdlrObj)
driver.processFileStream()
return particleDataHdlrObj
def process(self):
with open(self._sourceFilePath, 'rb') as stream_handle:
parser_state = None
def exp_callback(exception):
self._particleDataHdlrObj.setParticleDataCaptureFailure()
parser = GliderParser(self._config, stream_handle, exp_callback)
driver = DataSetDriver(parser, self._particleDataHdlrObj)
driver.processFileStream()
return self._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):
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 = AdcpPd0Parser(self._parser_config, file_handle, exception_callback)
driver = DataSetDriver(parser, self._particle_data_handler)
driver.processFileStream()
return self._particle_data_handler
def process(self):
def exception_callback(exception):
log.debug("ERROR: %r", exception)
self._particleDataHdlrObj.setParticleDataCaptureFailure()
with open(self._sourceFilePath, 'r') as stream_handle:
parser = PresfAbcDclParser(parser_config.get(self._data_type_key),
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):
with open(self._sourceFilePath, "rb") as file_handle:
def exception_callback(exception):
log.debug("Exception: %s", exception)
self._particleDataHdlrObj.setParticleDataCaptureFailure()
parser = AdcpPd0Parser(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, "r") as file_handle:
def exception_callback(exception):
log.debug("Exception: %s", exception)
self._particle_data_handler.setParticleDataCaptureFailure()
parser = FlortDjDclParser(self._parser_config, file_handle, exception_callback)
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):
def exception_callback(exception):
log.debug("ERROR: %r", exception)
self._particleDataHdlrObj.setParticleDataCaptureFailure()
with open(self._sourceFilePath, 'r') as stream_handle:
parser = PresfAbcDclParser(parser_config.get(self._data_type_key),
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._particle_data_handler.setParticleDataCaptureFailure()
with open(self._source_file_path, 'r') as stream_handle:
parser = CgCpmEngCpmParser(self._parser_config, stream_handle,
exception_callback)
driver = DataSetDriver(parser, self._particle_data_handler)
driver.processFileStream()
return self._particle_data_handler
def process(self):
with open(self._sourceFilePath, 'rb') as stream_handle:
parser_state = None
def exp_callback(exception):
self._particleDataHdlrObj.setParticleDataCaptureFailure()
parser = GliderParser(self._config,
stream_handle,
exp_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
