New settings handler

Lodel/settings.py

 #-*- coding: utf-8 -*-
-try:
-    import settings_local
-except ImportError:
-    settings_local = None
-
-class Settings:
-    # List of accepted settings
-    datasource = None
-
-    @staticmethod
-    # @throw AttributeError if the setting is not defined in this class
-    def get(attribute):
-        value = None
-        # find the value in settings itself, if not set search in settings_local
-        value = getattr(Settings, attribute)
-        if value is None:
-            try:
-                value = getattr(settings_local, attribute)
-            except AttributeError:
-                pass
 
-        if value is not None:
+import types
+import warnings
+from . import settings_format
+
+## @package Lodel.settings
+#
+# @brief Defines stuff to handles Lodel2 configuration
+#
+# To access the confs use the Lodel.settings.Settings SettingsHandler instance
+
+## @brief A class designed to handles Lodel2 settings
+#
+# When instanciating a SettingsHandler, the new instance is filled with the content of settings.py (in the root directory of lodel2
+#
+# @important You don't have to instanciate this class, you can access to the global instance with the Settings variable in this module
+# @todo Forbid module assignement in settings ! and disable tests about this
+# @todo Implements a type checking of config value
+# @todo Implements default values for config keys
+class SettingsHandler(object):
+    
+    ## @brief Shortcut
+    _allowed = settings_format.ALLOWED + settings_format.MANDATORY
+    ## @brief Shortcut
+    _mandatory = settings_format.MANDATORY
+
+    def __init__(self):
+        try:
+            import settings as default_settings
+            self._load_module(default_settings)
+        except ImportError:
+            warnings.warn("Unable to find global default settings")
+
+        ## @brief A flag set to True when the instance is fully loaded
+        self._set_loaded(False if len(self._missings()) > 0 else True)
+    
+    ## @brief Compat wrapper for getattr
+    def get(self, name):
+        return getattr(self, name)
+    
+    ## @brief Compat wrapper for setattr
+    def set(self, name, value):
+        return setattr(self, name, value)
+
+    ## @brief Load every module properties in the settings instance
+    #
+    # Load a module content into a SettingsHandler instance and checks that no mandatory settings are missing
+    # @note Example : <pre> import my_cool_settings;
+    # Settings._load_module(my_cool_settings);</pre>
+    # @param module module|None: a loaded module (if None just check for missing settings)
+    # @throw LookupError if invalid settings found or if mandatory settings are missing
+    def load_module(self, module = None):
+        if not(module is None):
+            self._load_module(module)
+        missings = self._missings()
+        if len(missings) > 0:
+            self._loaded = False
+            raise LookupError("Mandatory settings are missing : %s"%missings)
+        self._set_loaded(True)
+    
+    ## @brief supersede of default __setattr__ method
+    def __setattr__(self, name, value):
+        if not hasattr(self, name):
+            if name not in self._allowed:
+                raise LookupError("Invalid setting : %s"%name)
+        super().__setattr__(name, value)
+
+    ## @brief This method do the job for SettingsHandler.load_module()
+    #
+    # @note The difference with SettingsHandler.load_module() is that it didn't check if some settings are missing
+    # @throw LokkupError if an invalid settings is given
+    # @param module : a loaded module
+    def _load_module(self, module):
+        errors = []
+        fatal_errors = []
+        conf_dict = {
+            name: getattr(module, name)
+            for name in dir(module) 
+            if not name.startswith('__') and not isinstance(getattr(module, name), types.ModuleType)
+        }
+        for name, value in conf_dict.items():
             try:
-                func = getattr(Settings, attribute + '_args')
-                value = func(value)
-            except AttributeError:
-                pass
+                setattr(self, name, value)
+            except LookupError:
+                errors.append(name)
+        if len(errors) > 0:
+            err_msg = "Found invalid settings in %s : %s"%(module.__name__, errors)
+            raise LookupError(err_msg)
+
+    ## @brief If some settings are missings return their names
+    # @return an array of string
+    def _missings(self):
+        return [ confname for confname in self._mandatory if not hasattr(self, confname) ]
 
-        return value
+    def _set_loaded(self, value):
+        super().__setattr__('_loaded', bool(value))
 
-    @staticmethod
-    # @throw AttributeError if the setting is not defined in this class
-    def set(attribute, value):
-        setattr(Settings, attribute, value)
+Settings = SettingsHandler()
 
-    @staticmethod
-    def datasource_args(value):
-        return value
+## @page lodel_settings Lodel SettingsHandler
+#
+# This page describe the way settings are handled in Lodel2.
+#
+# @section lodel_settings_files Lodel settings files
+#
+# - Lodel/settings.py defines the Lodel.settings package, the SettingsHandler class and the Lodel.settings.Settings instance
+# - Lodel/settings_format.py defines the mandatory and allowed configurations keys lists
+# - install/instance_settings.py is a model of the file that will be deployed in Lodel2 instances directories
+#
+# @section Using Lodel.settings.Settings SettingsHandler instance
+#
+# @subsection lodel_settings_without_loader Without loader
+#
+# Without any loader you can import Lodel.settings.Settings and acces its property with getattr (or . ) or with SettingsHandler.get() method.
+# In the same way you can set a settings by standart affectation of a propery or with SettingsHandler.set() method.
+#
+# @subsection lodel_settings_loader With a loader in a lodel2 instance
+#
+# The loader will import Lodel.settings.Settings and then calls the SettingsHandler.load_module() method to load the content of the instance_settings.py file into the SettingsHandler instance
+#
+# @subsection lodel_settings_example Examples
+#
+# <pre>
+# #!/usr/bin/python
+# from Lodel.settings import Settings
+# if Settings.debug:
+#   print("DEBUG")
+# #or
+# if Settings.get('debug'):
+#   print("DEBUG")
+# Settings.debug = False
+# #or
+# Settings.set('debug', False)
+# </pre>
+# 

install/loader.py

-import settings as instance_settings
+import instance_settings
 import importlib
 import sys
 import os
 
 from Lodel.settings import Settings
 
-# Update the settings
-for name in [ name for name in dir(instance_settings) if not name.startswith('__') ]:
-    Settings.set(name, getattr(instance_settings, name))
+# Settings initialisation
+Settings.load_module(instance_settings)
+globals()['Settings'] = Settings
 
 # Import dynamic code
-if os.path.isfile(Settings.get('dynamic_code')):
+if os.path.isfile(Settings.dynamic_code_file):
     from dynleapi import *
 
 # Import wanted datasource objects
     print("""
      Running interactive python in Lodel2 %s instance environment
 
-"""%settings.name)
+"""%Settings.sitename)
     code.interact(local=locals())

install/utils.py

 # -*- coding: utf-8 -*-
 
-import settings
-from settings import *
 from loader import *
 
 def refreshdyn():
     from leapi.lefactory import LeFactory
     from EditorialModel.backend.json_backend import EmBackendJson
     from DataSource.MySQL.leapidatasource import LeDataSourceSQL
-    OUTPUT = dynamic_code
-    EMJSON = emfile
+    OUTPUT = Settings.dynamic_code_file
+    EMJSON = Settings.em_file
     # Load editorial model
     em = Model(EmBackendJson(EMJSON))
     # Generate dynamic code
 def db_init():
     from EditorialModel.backend.json_backend import EmBackendJson
     from EditorialModel.model import Model
-    mh = getattr(migrationhandler,settings.mh_classname)()
-    em = Model(EmBackendJson(settings.emfile))
+    mh = getattr(migrationhandler,Settings.mh_classname)()
+    em = Model(EmBackendJson(Settings.em_file))
     em.migrate_handler(mh)
 
 

lodel_init.sh

 libdir="${libdir:=$(realpath $(dirname $0))}"
 
 emfilename="em.json"
-settings="$instdir/settings.py"
+settings="$instdir/instance_settings.py"
 em="$instdir/em.json"
 dyncode="$instdir/${name}.py"