def test_config_value_float(self): config = RawConfigParser() config["section"] = {"key": 2.0} val = get_config_value(config, "section", "key", dtype=float) self.assertEqual(type(val), float) self.assertEqual(val, 2.0)
def test_config_value_bool(self): config = RawConfigParser() config["section"] = {"key": "True"} val = get_config_value(config, "section", "key", dtype=bool) self.assertEqual(type(val), bool) self.assertEqual(val, True)
def test_get_config_value_int(self): config = RawConfigParser() config["section"] = {"key": 3} val = get_config_value(config, "section", "key", dtype=int) self.assertEqual(type(val), int) self.assertEqual(val, 3)
def unpack_config(self, config, protected_values=None): """ Unpacks config data, sets relevant entries to values instance attribute :type config: configparser.RawConfigParser :param config: config data """ protected_values = [] if protected_values is None else protected_values for section in config.sections(): for name in config[section].keys(): if name not in protected_values: value = get_config_value(config, section, name) self.set_config_value(name, value)
def unpack_scheduler_config(scheduler_config): """ Returns information from scheduler configuration information :type scheduler_config: configparser.RawConfigParser :param scheduler_config: scheduler configuration :rtype: dict :return: scheduler configuration information, with entries (defaults occur if entry omitted from config file): * seconds (int) - Scheduled job repeat interval in seconds, default None (if not None minutes and hours are None) * minutes (int) - Scheduled job repeat interval in minutes, default None (if not None seconds and hours are None) * hours (int) - Scheduled job repeat interval in hour, default None (if not None seconds and minutes are None) * start_time (datetime.datetime) - Scheduled time to start running tasks, default None (means start now) * parallel (bool) - Switch to run scheduled jobs on different threads, default False * jobs_list (str) - Path of jobs list file, to run on schedule """ scheduler_config_dict = dict() sections = [sch for sch in scheduler_config.sections()] sections.remove("Log") for sch in sections: scheduler_config_dict[sch] = {} # Schedule Configuration scheduler_config_dict[sch]["seconds"] = get_config_value( scheduler_config, sch, "seconds", dtype=int) scheduler_config_dict[sch]["minutes"] = get_config_value( scheduler_config, sch, "minutes", dtype=int) scheduler_config_dict[sch]["hours"] = get_config_value( scheduler_config, sch, "hours", dtype=int) scheduler_config_dict[sch]["start_time"] = get_config_value( scheduler_config, sch, "start_time", dtype=str) scheduler_config_dict[sch]["parallel"] = get_config_value( scheduler_config, sch, "seconds", dtype=bool) # Use custom jobs list provided, else use default scheduler_config_dict[sch]["jobs_list"] = get_config_value( scheduler_config, sch, "jobs_list", dtype=str) if scheduler_config_dict[sch]["jobs_list"] is None: scheduler_config_dict[sch]["jobs_list"] = JOBS_FILE_PATH # todo - sort out start time format # Checks # Check only have hours, minutes or seconds intervals = [ scheduler_config_dict[sch]["seconds"], scheduler_config_dict[sch]["minutes"], scheduler_config_dict[sch]["hours"] ] if intervals.count(None) != 2: raise ValueError( "job repeat interval must be defined as 1 of seconds, minutes or hours for " + sch) return scheduler_config_dict
def test_get_config_value_dtype_bool(self): config = RawConfigParser() config["section"] = {"key": "False"} val = get_config_value(config, "section", "key") self.assertEqual(val, False)
def test_get_config_value_dtype_None(self): config = RawConfigParser() config["section"] = {"key": "val"} val = get_config_value(config, "section", "key") self.assertEqual(val, "val")
def test_get_config_value_None_bool(self): config = RawConfigParser() config["section"] = {"key": None} val = get_config_value(config, "section", "key", dtype=bool) self.assertEqual(val, False)
def test_get_config_value_None(self): config = RawConfigParser() config["section"] = {"key": None} val = get_config_value(config, "section", "key") self.assertIsNone(val)
def test_get_config_value_empty_string(self): config = RawConfigParser() config["section"] = {"key": ""} val = get_config_value(config, "section", "key") self.assertIsNone(val)
def configure_logging(fname=None, verbose=None, quiet=None, config=None, name=None): """ Configure logger :type fname: str :param fname: path to write log to, if None output log as stdout :type verbose: bool :param verbose: Option for verbose log output (DEBUG level) :type quiet: bool :param quiet: Option for quiet log output (WARNING level) :type config: configparser.RawConfigParser :param config: Config file with logging configuration information. This finds fname, verbose and quiet if not specifed as arguments :type name: str :param name: (optional) set name of logger to get :return: logger :rtype: logging.logger """ global loggers if name is not None: if loggers.get(name): return loggers.get(name) if config is not None: fname = get_config_value(config, "Log", "log_path", dtype=str) verbose = get_config_value(config, "Log", "verbose", dtype=bool) quiet = get_config_value(config, "Log", "quiet", dtype=bool) # Configure logger if name is None: name = __name__ logger = logging.getLogger(name) # Define verboseness levels if verbose: logger.setLevel(logging.DEBUG) elif quiet: logger.setLevel(logging.WARNING) else: logger.setLevel(logging.INFO) # Define logging to file if fname provided if fname is not None: file_formatter = logging.Formatter( '%(asctime)s : %(levelname)s : %(message)s') file_handler = logging.FileHandler(fname) file_handler.setFormatter(file_formatter) logger.addHandler(file_handler) # Define logging to stdout if no fname provided else: stream_formatter = logging.Formatter('%(message)s') stream_handler = logging.StreamHandler(sys.stdout) stream_handler.setFormatter(stream_formatter) logger.addHandler(stream_handler) loggers[name] = logger return logger