def test_module_path_sys_append():
"""
Tests if model directory is in sys.path to use importlib.module_import()
for child model classes.
"""
models_dir = MODEL_REPOSITORY
manage.set_model_repository(models_dir)
manage.action_new(MODEL_NAME)
utils.module_path(MODEL_NAME, 0)
assert sys.path[0] == models_dir
def run(self, input_source):
''' Executes a default predicton workflow '''
# path to endpoint
# path to endpoint
endpoint = utils.model_path(self.model, self.version)
if not os.path.isdir(endpoint):
self.conveyor.setError(f'Unable to find model {self.model}, version {self.version}')
#LOG.error(f'Unable to find model {self.model}')
if not self.conveyor.getError():
# uses the child classes within the 'model' folder,
# to allow customization of
# the processing applied to each model
modpath = utils.module_path(self.model, self.version)
idata_child = importlib.import_module(modpath+".idata_child")
apply_child = importlib.import_module(modpath+".apply_child")
odata_child = importlib.import_module(modpath+".odata_child")
# run idata object, in charge of generate model data from input
try:
idata = idata_child.IdataChild(self.param, self.conveyor, input_source)
except:
LOG.warning ('Idata child architecture mismatch, defaulting to Idata parent')
idata = Idata(self.param, self.conveyor, input_source)
idata.run()
LOG.debug(f'idata child {type(idata).__name__} completed `run()`')
if not self.conveyor.getError():
# make sure there is X data
if not self.conveyor.isKey('xmatrix'):
LOG.debug(f'Failed to compute MDs')
self.conveyor.setError(f'Failed to compute MDs')
if not self.conveyor.getError():
# run apply object, in charge of generate a prediction from idata
try:
apply = apply_child.ApplyChild(self.param, self.conveyor)
except:
LOG.warning ('Apply child architecture mismatch, defaulting to Apply parent')
apply = Apply(self.param, self.conveyor)
apply.run()
LOG.debug(f'apply child {type(apply).__name__} completed `run()`')
# run odata object, in charge of formatting the prediction results
# note that if any of the above steps failed, an error has been inserted in the
# conveyor and odata will take case of showing an error message
try:
odata = odata_child.OdataChild(self.param, self.conveyor)
except:
LOG.warning ('Odata child architecture mismatch, defaulting to Odata parent')
odata = Odata(self.param, self.conveyor)
return odata.run()
def test_module_path_module_name():
"""
Tests if importlib.module_import() works
"""
models_dir = MODEL_REPOSITORY
manage.set_model_repository(models_dir)
manage.action_new(MODEL_NAME)
module_name = utils.module_path(MODEL_NAME, 0)
assert module_name == (MODEL_NAME + '.dev')
def run(self, input_source):
''' Executes a default predicton workflow '''
results = {}
# path to endpoint
epd = utils.model_path(self.model, 0)
if not os.path.isdir(epd):
LOG.error(f'Unable to find model {self.model}')
results['error'] = 'unable to find model: '+self.model
if 'error' not in results:
# uses the child classes within the 'model' folder,
# to allow customization of the processing applied to each model
modpath = utils.module_path(self.model, 0)
idata_child = importlib.import_module(modpath+".idata_child")
learn_child = importlib.import_module(modpath+".learn_child")
odata_child = importlib.import_module(modpath+".odata_child")
LOG.debug('child modules imported: '
f' {idata_child.__name__},'
f' {learn_child.__name__},'
f' {odata_child.__name__}')
# run idata object, in charge of generate model
idata = idata_child.IdataChild(self.parameters, input_source)
results = idata.run()
LOG.debug(f'idata child {idata_child.__name__} completed `run()`')
if 'error' not in results:
if 'xmatrix' not in results:
LOG.error(f'Failed to compute MDs')
results['error'] = 'Failed to compute MDs'
if 'ymatrix' not in results:
LOG.error(f'No activity data (Y) found in training series')
results['error'] = 'No activity data (Y) found in training series'
if 'error' not in results:
# run learn object, in charge of generate a prediction from idata
learn = learn_child.LearnChild(self.parameters, results)
results = learn.run()
LOG.debug(f'learn child {learn_child.__name__} completed `run()`')
# run odata object, in charge of formatting the prediction results
# note that if any of the above steps failed, an error has been inserted in the
# results and odata will take case of showing an error message
odata = odata_child.OdataChild(self.parameters, results)
LOG.info('Building completed')
return odata.run()
def run(self, input_source):
''' Executes a default predicton workflow '''
results = {}
# path to endpoint
endpoint = utils.model_path(self.model, self.version)
if not os.path.isdir(endpoint):
LOG.debug('Unable to find model'
' {} version {}'.format(self.model, self.version))
results['error'] = 'unable to find model: ' + \
self.model+' version: '+str(self.version)
if 'error' not in results:
# uses the child classes within the 'model' folder,
# to allow customization of
# the processing applied to each model
modpath = utils.module_path(self.model, self.version)
idata_child = importlib.import_module(modpath + ".idata_child")
apply_child = importlib.import_module(modpath + ".apply_child")
odata_child = importlib.import_module(modpath + ".odata_child")
LOG.debug('child modules imported: '
f' {idata_child.__name__},'
f' {apply_child.__name__},'
f' {odata_child.__name__}')
# run idata object, in charge of generate model data from input
idata = idata_child.IdataChild(self.parameters, input_source)
results = idata.run()
LOG.debug(f'idata child {idata_child.__name__} completed `run()`')
if 'error' not in results:
if 'xmatrix' not in results:
LOG.debug(f'Failed to compute MDs')
results['error'] = 'Failed to compute MDs'
if 'error' not in results:
# run apply object, in charge of generate a prediction from idata
apply = apply_child.ApplyChild(self.parameters, results)
results = apply.run()
LOG.debug(f'apply child {apply_child.__name__} completed `run()`')
# run odata object, in charge of formatting the prediction results or any error
odata = odata_child.OdataChild(self.parameters, results)
LOG.info('Prediction completed')
return odata.run()
def run(self, input_source):
''' Executes a default predicton workflow '''
# path to endpoint
endpoint = utils.model_path(self.model, self.version)
# if not os.path.isdir(endpoint):
# self.conveyor.setError(f'Unable to find model {self.model}, version {self.version}')
# #LOG.error(f'Unable to find model {self.model}')
# if not self.conveyor.getError():
# uses the child classes within the 'model' folder,
# to allow customization of
# the processing applied to each model
modpath = utils.module_path(self.model, self.version)
idata_child = importlib.import_module(modpath+".idata_child")
apply_child = importlib.import_module(modpath+".apply_child")
odata_child = importlib.import_module(modpath+".odata_child")
# run idata object, in charge of generate model data from input
try:
idata = idata_child.IdataChild(self.param, self.conveyor, input_source)
except:
LOG.warning ('Idata child architecture mismatch, defaulting to Idata parent')
idata = Idata(self.param, self.conveyor, input_source)
idata.run()
LOG.debug(f'idata child {type(idata).__name__} completed `run()`')
if not self.conveyor.getError():
success, results = idata.preprocess_apply()
if not success:
self.conveyor.setError(results)
if not self.conveyor.getError():
# make sure there is X data
if not self.conveyor.isKey('xmatrix'):
LOG.debug(f'Failed to compute MDs')
self.conveyor.setError(f'Failed to compute MDs')
# for secret models avoid searching similar compounds
space_pkl = os.path.join(endpoint,'space.pkl')
if not os.path.isfile(space_pkl):
self.param.setVal('output_similar', False)
if not self.conveyor.getError():
if self.param.getVal('output_similar') is True:
from flame.sapply import Sapply
metric = self.param.getVal('similarity_metric')
numsel = self.param.getVal('similarity_cutoff_num')
cutoff = self.param.getVal('similarity_cutoff_distance')
# sapply = Sapply(self.param, self.conveyor)
sapply_child = importlib.import_module(modpath+".sapply_child")
# run apply object, in charge of generate a prediction from idata
try:
sapply = sapply_child.SapplyChild(self.param, self.conveyor)
except:
LOG.warning ('Sapply child architecture mismatch, defaulting to Sapply parent')
sapply = Sapply(self.param, self.conveyor)
sapply.run(cutoff, numsel, metric)
LOG.debug(f'sapply child {type(sapply).__name__} completed `run()`')
if not self.conveyor.getError():
# run apply object, in charge of generate a prediction from idata
try:
apply = apply_child.ApplyChild(self.param, self.conveyor)
except:
LOG.warning ('Apply child architecture mismatch, defaulting to Apply parent')
apply = Apply(self.param, self.conveyor)
apply.run()
LOG.debug(f'apply child {type(apply).__name__} completed `run()`')
# run odata object, in charge of formatting the prediction results
# note that if any of the above steps failed, an error has been inserted in the
# conveyor and odata will take case of showing an error message
try:
odata = odata_child.OdataChild(self.param, self.conveyor)
except:
LOG.warning ('Odata child architecture mismatch, defaulting to Odata parent')
odata = Odata(self.param, self.conveyor)
return odata.run()
def run(self, input_source):
''' Executes a default predicton workflow '''
# path to endpoint
epd = utils.model_path(self.model, 0)
if not os.path.isdir(epd):
self.conveyor.setError(f'Unable to find model {self.model}')
#LOG.error(f'Unable to find model {self.model}')
# import ichild classes
if not self.conveyor.getError():
# uses the child classes within the 'model' folder,
# to allow customization of the processing applied to each model
modpath = utils.module_path(self.model, 0)
idata_child = importlib.import_module(modpath + ".idata_child")
learn_child = importlib.import_module(modpath + ".learn_child")
odata_child = importlib.import_module(modpath + ".odata_child")
# run idata object, in charge of generate model data from input
try:
idata = idata_child.IdataChild(self.param, self.conveyor,
input_source)
except:
LOG.warning(
'Idata child architecture mismatch, defaulting to Idata parent'
)
idata = Idata(self.param, self.conveyor, input_source)
idata.run()
LOG.debug(f'idata child {type(idata).__name__} completed `run()`')
if not self.conveyor.getError():
# check there is a suitable X and Y
if not self.conveyor.isKey('xmatrix'):
self.conveyor.setError(f'Failed to compute MDs')
if not self.conveyor.isKey('ymatrix'):
self.conveyor.setError(
f'No activity data (Y) found in training series')
if not self.conveyor.getError():
# instantiate learn (build a model from idata) and run it
learn = learn_child.LearnChild(self.param, self.conveyor)
learn.run()
try:
learn = learn_child.LearnChild(self.param, self.conveyor)
except:
LOG.warning(
'Learn child architecture mismatch, defaulting to Learn parent'
)
learn = Learn(self.param, self.conveyor)
LOG.debug(f'learn child {type(learn).__name__} completed `run()`')
# run odata object, in charge of formatting the prediction results
# note that if any of the above steps failed, an error has been inserted in the
# conveyor and odata will take case of showing an error message
try:
odata = odata_child.OdataChild(self.param, self.conveyor)
except:
LOG.warning(
'Odata child architecture mismatch, defaulting to Odata parent'
)
odata = Odata(self.param, self.conveyor)
return odata.run()
