Added importlib to load evaluation and preevaluation scritps

* #29

Author: Ezetowers

MLC/Application.py

@@ -11,24 +11,17 @@
 from MLC.Population.Creation.CreationFactory import CreationFactory
 from MLC.Population.Evaluation.EvaluatorFactory import EvaluatorFactory
 from MLC.Population.Population import Population
-from MLC.Scripts.Evaluation import toy_problem
-from MLC.Scripts.Evaluation import toy_problem_python_ev
-from MLC.Scripts.Evaluation import arduino
-from MLC.Scripts.Evaluation import simulink_ev
-from MLC.Scripts.Preevaluation import default
-from MLC.Scripts.Preevaluation import simulink_preev
 from MLC.Simulation import Simulation
 
 
 class Application(object):
 
     def __init__(self, simulation, log_mode='console'):
         self._config = Config.get_instance()
-        self._set_ev_callbacks()
-        self._set_preev_callbacks()
 
         # Set logger mode of the App
         set_logger(log_mode)
+        self._project_validations()
         self._simulation = simulation
 
         # Gen creator
@@ -170,16 +163,10 @@ def show_best(self, population):
         stop_no_graph = self._config.getboolean('BEHAVIOUR', 'stopongraph')
         EvaluatorFactory.get_ev_callback().show_best(best_index, best_indiv, stop_no_graph)
 
-    def _set_ev_callbacks(self):
-        # Set the callbacks to be called at the moment of the evaluation
-        # FIXME: Dinamically get instances from "MLC.Scripts import *"
-        EvaluatorFactory.set_ev_callback('toy_problem', toy_problem)
-        EvaluatorFactory.set_ev_callback('toy_problem_python_ev', toy_problem_python_ev)
-        EvaluatorFactory.set_ev_callback('arduino', arduino)
-        EvaluatorFactory.set_ev_callback('simulink_ev', simulink_ev)
-
-    def _set_preev_callbacks(self):
-        # Set the callbacks to be called at the moment of the preevaluation
-        # FIXME: To this dynamically searching .pys in the directory
-        PreevaluationManager.set_callback('default', default)
-        PreevaluationManager.set_callback('simulink_preev', simulink_preev)
+
+    def _project_validations(self):
+        # Check that the evaluation and preevaluation modules can be loaded
+        EvaluatorFactory.get_ev_callback()
+        PreevaluationManager.get_callback()
+
+    # TODO: Add another validations

MLC/Common/PreevaluationManager.py

@@ -1,4 +1,5 @@
 import MLC.Log.log as lg
+import importlib
 import sys
 from MLC.mlc_parameters.mlc_parameters import Config
 
@@ -8,11 +9,6 @@
 
 
 class PreevaluationManager(object):
-    callback = {}
-
-    @staticmethod
-    def set_callback(callback_name, ev_callback):
-        PreevaluationManager.callback[callback_name] = ev_callback
 
     @staticmethod
     def get_callback():
@@ -22,10 +18,14 @@ def get_callback():
         """
         # Check if the preevaluation is activated
         if Config.get_instance().getboolean('EVALUATOR', 'preevaluation'):
-            callback_name = Config.get_instance().get('EVALUATOR', 'preev_function')
+            module_name = Config.get_instance().get('EVALUATOR', 'preev_function')
+            lg.logger_.debug('[PREEV_MANAGER] Importing module {0}'.format(module_name))
             try:
-                return PreevaluationManager.callback[callback_name]
-            except KeyError:
-                lg.logger_.debug("Preevaluation function doesn't exists. Aborting program...")
+                callback = importlib.import_module('MLC.Scripts.Preevaluation.' + module_name)
+                return callback
+            except ImportError:
+                lg.logger_.debug("[PREEV_MANAGER] Preevaluation function doesn't exists. " +
+                                 "Aborting program...")
+                sys.exit(-1)
+
 
-        return None

MLC/Population/Evaluation/EvaluatorFactory.py

@@ -1,32 +1,30 @@
 import MLC.Log.log as lg
+import importlib
 import sys
 
 from MLC.mlc_parameters.mlc_parameters import Config
 from MLC.Population.Evaluation.StandaloneEvaluator import StandaloneEvaluator
 
 
 class EvaluatorFactory(object):
-    callback = {}
-
-    @staticmethod
-    def set_ev_callback(callback_name, ev_callback):
-        EvaluatorFactory.callback[callback_name] = ev_callback
-
     @staticmethod
     def get_ev_callback():
-        callback_name = Config.get_instance().get('EVALUATOR', 'evaluation_function')
+        module_name = Config.get_instance().get('EVALUATOR', 'evaluation_function')
+        lg.logger_.debug('[EV_FACTORY] Importing module {0}'.format(module_name))
         try:
-            return EvaluatorFactory.callback[callback_name]
-        except KeyError:
-            lg.logger_.debug("Evaluation function doesn't exists. " +
+            callback = importlib.import_module('MLC.Scripts.Evaluation.' + module_name)
+            return callback
+        except ImportError:
+            lg.logger_.debug("[EV_FACTORY] Evaluation function doesn't exists. " +
                              "Aborting program...")
+            sys.exit(-1)
 
     @staticmethod
     def make(strategy):
         if strategy == "mfile_standalone":
             ev_callback = EvaluatorFactory.get_ev_callback()
             return StandaloneEvaluator(ev_callback)
         else:
-            lg.logger_.error("[CREATION_FACTORY] Evaluation method " +
+            lg.logger_.error("[EV_FACTORY] Evaluation method " +
                              strategy + " is not valid. Aborting program")
             sys.exit(-1)

conf/configuration.ini

@@ -69,8 +69,8 @@ badvalue = 1e36
 badvalues_elim = first
 %badvalues_elim = none
 %badvalues_elim = all
-preevaluation = false
-preev_function = simulink_preev
+preevaluation = true
+preev_function = default
 problem_variables.gamma = 0.1
 
 [BEHAVIOUR]

main.py

@@ -1,5 +1,6 @@
 #!/usr/bin/python2.7
 import numpy as np
+import importlib
 from MLC.Application import Application
 from MLC.mlc_parameters.mlc_parameters import Config
 from MLC.matlab_engine import MatlabEngine
@@ -22,11 +23,11 @@ def main():
 
     eng = MatlabEngine.engine()
     config = initialize_config()
-    MatlabEngine.load_random_values("./tests/integration_tests/matlab_randoms.txt")
 
     # Create the MLC2 object and store it in the workspace. With this
     # feature we will be able to call every function of the MATLAB code
     # from any part of the code where the engine is available
+    # MatlabEngine.load_random_values("./tests/integration_tests/matlab_randoms.txt")
     eng.workspace['wmlc'] = eng.MLC2()
 
     simulation = Simulation()