Source code for ecpi.process.generic.composant

"""
Implementation of generic module components ran by ECPI.

@author: COLLEY, Jean-Marc, BACON Philippe, APC/IN2P3/CNRS
"""

import os.path
import logging
import json
import configparser
import ecpi.common.params.tools_check as tpars
import ecpi.common.instru.model_effect as me

s_logger = logging.getLogger(__name__)


class GenericComposantProcessing(object):
    """.
    Mother class for all ECPI modules.
    """

    def __init__(self, file_schema):
        """**constructor**
        
        :param file_schema: path to the .json scheme
        :type file_schema: str
        """
        self.composant_name = ""
        self.error_range = 0
        self.d_pars = {}
        self.d_data_in = {}
        self.d_data_out = {}
        self.status = 0
        self.mod_effect = None
        self.d_status = {
            0: "OK",
            1: "parameter validation error",
            2: "input working isn't present in the parameter dict",
            3: "input working directory does not exist",
            4: "convert error : configparser to dictionary",
            5: "ECLAIRs model effect is not valid"
        }   
        with open(file_schema, "r") as fichier:
            self.json_schem = json.load(fichier)
    
        
    def __str__(self):
        s = f"\n#### [{self.composant_name.upper()}] module parameters:\n[{self.composant_name}]"
        for k, v in sorted(list(self.d_pars.items())):
#             if type(v) == list and type(v[0]) is str:
            v = v.__str__().replace("'",'"')
            s += f"\n{k} = {v}"
        s += "\n####"
        return s
    
    def _check_add_default_dict(self):
        """Check only with json scheme
        """
        return tpars.check_add_default_dict(self.json_schem, self.d_pars)
                          
    def _load_check_file_in(self):
        """Load file in memory d_data_in attribut 
        and check_params input data file: presence, type ,coherence, ...
        
        #TODO: utilisation du paramètre dir_in pour y lire les fichiers
        """
        # must be defined in derived class
        # initialize self.d_data_in
        if not "working_in" in self.d_pars:
            self.status = 2
            return False
        elif not os.path.exists(self.d_pars["working_in"]):
            self.status = 3
            return False
        return True          
    
    def _check_unknown_pars(self):
        """Return False if d_pars content a parameters 
        not content in his scheme json
        
        #TODO: pour éviter les typos dans les paramètres 
        passe sous silence par une redéfinition par 
        sa valeur par défaut
        """
        pass

    def _create_output_files(self):
        """
        must be defined in derived class
        """
        raise
    
    def _process_composant(self):
        """
        must be defined in derived class
        """        
        raise

    def _check_extra(self):
        """Check more complex rules
        
        must be defined in derived class        
        """        
        pass

    #
    # User interface
    #
    def set_model_effect_detector(self, mod_dpix):
        if not isinstance(mod_dpix, me.ECLAIRsDetectorEffect):
            self.status = 5
            return False
        self.mod_effect = mod_dpix
        return True
        
    
    def set_dict_params(self, dict_pars):
        """Set dictionary parameters
        
        :param dict_pars:
        :type dict_pars:
        """#         try:     
#             detectim, eclo, error_code, error_msg = bube(self.d_data_in)
#             s_logger.debug(f"{error_code}: {error_msg} [bube]")
#         except Exception:
#             self.status = 24
#             return False
#         if error_code == "NOK":
#             self.status = 24
#             return False    
        self.d_pars = dict_pars
    
    def set_cfg_params(self, cfg_pars, section):
        """Set parameters for config,
        
        :param cfg_pars:
        :type cfg_aprs: dic
        :param section: name of ecpi section
        :type section: str
        """
        cfg = configparser.ConfigParser(interpolation=configparser.ExtendedInterpolation())
        if type(cfg_pars) is dict:            
            cfg.read_dict(cfg_pars)
        else:
            cfg.read(cfg_pars)        

        ret_parser = tpars.cfgparser_to_dict4json(cfg, section)
        if ret_parser is None:
            self.status = 4
            return False
        self.d_pars = ret_parser
        self.sections = cfg.sections
        self.composant_name = section
        return True

    def complete_params_with_dict(self, new_dict_pars):
        """Add params from section if not present in self.d_pars
        """
        self.d_pars.update(new_dict_pars)
        
    def check_params(self):
        if self._check_add_default_dict():
            return self._check_extra()
        else:
            self.status = 1
            return False
        
    def run(self, data_in_obj=None):
        """Run/processing composant with parameters and d_data_in
        """
        if data_in_obj is None:
            if not self._load_check_file_in():
                return False
        else:
            self.d_data_in = data_in_obj
        if self._process_composant():
            return self._create_output_files()
    
    def get_data_out(self):
        return self.d_data_out
    
    def status_int(self):
        return self.status + self.error_range
    
    def status_msg(self):
        msg_err = self.d_status[self.status]
        return f"[{self.name}]: {msg_err}"