python import instead of expose_module, LodelContext still used for getting module and other stuff

debian/changelog

-lodel2 (0.1) UNRELEASED; urgency=medium
-
-  * First debian package
-
- -- Yann Weber <yann.weber@openedition.org>  Fri, 23 Sep 2016 12:09:29 +0200

debian/compat

-9

debian/control

-Source: lodel2
-Section: python
-Priority: optional
-Maintainer: lodel2 dev team
-Build-Depends: make, dpkg-dev, dh-make, python3, python3-lxml
-Standards-Version: 0.1.1
-
-Package: lodel2
-Section: python
-Description: lodel2 debian package
-Architecture: any
-Depends: python3, python3-lxml, python3-jinja2, python3-werkzeug, python3-pymongo, uwsgi-plugin-python3, make
-Suggests: pwgen, wamerican, mongodb-server
-Provides: lodel

debian/debhelper.log

-dh_auto_configure
-dh_auto_build
-dh_auto_test
-dh_prep
-dh_auto_install
-dh_installdocs
-dh_installchangelogs
-dh_pysupport
-dh_perl
-dh_link
-dh_compress
-dh_fixperms
-dh_strip
-dh_makeshlibs
-dh_shlibdeps
-dh_installdeb
-dh_gencontrol
-dh_md5sums
-dh_builddeb
-dh_builddeb

debian/files

-lodel2_0.1_amd64.deb python optional

debian/rules

-#!/usr/bin/make -f
-# consulter debhelper(7) (décommenter lorsque nécessaire)
-# afficher chaque commande modifiant un fichier dans le système construit
-#DH_VERBOSE = 1
-
-# consulter EXAMPLES dans dpkg-buildflags(1) et lire /usr/share/dpkg/*
-DPKG_EXPORT_BUILDFLAGS = 1
-include /usr/share/dpkg/default.mk
-
-# consulter FEATURE AREAS dans dpkg-buildflags(1)
-#export DEB_BUILD_MAINT_OPTIONS = hardening=+all
-
-# consulter ENVIRONMENT dans dpkg-buildflags(1)
-# mainteneurs de paquet à ajouter à CFLAGS
-#export DEB_CFLAGS_MAINT_APPEND  = -Wall -pedantic
-# mainteneurs de paquet à ajouter à append LDFLAGS
-#export DEB_LDFLAGS_MAINT_APPEND = -Wl,--as-needed
-
-# principal script d’empaquetage basé sur la syntaxe de dh7
-%:
-	dh $@ --with python3
-

debian/substvars

-misc:Depends=

debian/tmp/DEBIAN/control

-Package: lodel2
-Version: 0.1
-Architecture: amd64
-Maintainer: lodel2 dev team
-Installed-Size: 25
-Depends: python3, python3-lxml, python3-jinja2, python3-werkzeug, python3-pymongo, uwsgi-plugin-python3
-Suggests: pwgen, wamerican, mongodb-server
-Provides: lodel
-Section: python
-Priority: optional

debian/tmp/DEBIAN/md5sums

-0377daa43e7232c06b702078dd86b850  usr/share/doc/lodel2/changelog.gz

doc/img/graphviz/Makefile

-dotfiles := $(wildcard *.dot)
-images := $(patsubst %.dot,%.png,$(wildcard *.dot))
-
-all: $(images)
-	
-%.png: %.dot
-	dot -Tpng $< > $@
-
-.PHONY: clean distclean
-
-clean:
-	-rm $(images)
-
-distclean: clean

editorial_models/em_simple.py

 import os, os.path
 
 sys.path.append(os.path.dirname(os.getcwd()+'/..'))
-from lodel.context import LodelContext
-LodelContext.init()
 
 from lodel.settings.settings import Settings as settings
 settings('globconf.d')

em_test.py

 #!/usr/bin/python3
-#-*- coding: utf-8 -*-
-
-from lodel.context import LodelContext
-LodelContext.init()
-
 from lodel.settings.settings import Settings as settings
 settings('globconf.d')
 from lodel.settings import Settings

lodel/auth/client.py

 import warnings
 import inspect
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.settings': ['Settings'],
-    'lodel.logger': 'logger',
-    'lodel.plugin': [('SessionHandlerPlugin', 'SessionHandler')],
-    'lodel.auth.exceptions': ['ClientError', 'ClientAuthenticationFailure',
-                              'ClientPermissionDenied', 'ClientAuthenticationError'],
-    'lodel.leapi.query': ['LeGetQuery'], })
+from lodel.settings import Settings
+from lodel.logger import logger,
+from lodel.plugin import SessionHandlerPlugin, SessionHandler
+from lodel.auth.exceptions import ClientError, ClientAuthenticationFailure, ClientPermissionDenied, ClientAuthenticationError
+from lodel.leapi.query import LeGetQuery
 
 ## @brief Client metaclass designed to implements container accessor on
 # Client Class

lodel/auth/exceptions.py

 # @package lodel.auth.exceptions
 # @brief Defines the specific exceptions used in the authentication process
 
-from lodel.context import LodelContext
-
-LodelContext.expose_modules(globals(), {
-    'lodel.logger': 'logger',
-    'lodel.plugin.hooks': ['LodelHook']})
+from lodel.logger import logger
+from lodel.plugin.hooks import LodelHook
 
 
 ## @brief Handles common errors with a Client

lodel/editorial_model/components.py

-#-*- coding: utf-8 -*-
-
 # @package lodel.editorial_model.components
 #@brief Defines all @ref lodel2_em "EM" components
 #@ingroup lodel2_em
 import copy
 import hashlib
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.utils.mlstring': ['MlString'],
-    'lodel.mlnamedobject.mlnamedobject': ['MlNamedObject'],
-    'lodel.settings': ['Settings'],
-    'lodel.editorial_model.exceptions': ['EditorialModelError', 'assert_edit'],
-    'lodel.leapi.leobject': ['CLASS_ID_FIELDNAME']})
+from lodel.utils.mlstring import MlString
+from lodel.mlnamedobject.mlnamedobject import MlNamedObject
+from lodel.settings import import Settings
+from lodel.editorial_model.exceptions import EditorialModelError, assert_edit
+from lodel.leapi.leobject import CLASS_ID_FIELDNAME
 
 ## @brief Abstract class to represent editorial model components
 # @see EmClass EmField

lodel/editorial_model/model.py

 import importlib
 import copy
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.utils.mlstring': ['MlString'],
-    'lodel.mlnamedobject.mlnamedobject': ['MlNamedObject'],
-    'lodel.logger': 'logger',
-    'lodel.settings': ['Settings'],
-    'lodel.settings.utils': ['SettingsError'],
-    'lodel.leapi.datahandlers.base_classes': ['DataHandler'],
-    'lodel.editorial_model.exceptions': ['EditorialModelError', 'assert_edit'],
-    'lodel.editorial_model.components': ['EmClass', 'EmField', 'EmGroup']})
 
+from lodel.utils.mlstring import MlString
+from lodel.mlnamedobject.mlnamedobject import MlNamedObject
+from lodel.settings import import Settings
+from lodel.editorial_model.exceptions import EditorialModelError, assert_edit
+from lodel.logger import logger
+from lodel.settings.utils import SettingsError
+from lodel.leapi.datahandlers.base_classes import DataHandler
+from lodel.editorial_model.components import EmClass, EmField, EmGroup
 
 ## @brief Describe an editorial model
 #@ingroup lodel2_em

lodel/editorial_model/translator/xmlfile.py

 import os
 from lxml import etree
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.editorial_model.model': ['EditorialModel'],
-    'lodel.editorial_model.components': ['EmComponent', 'EmClass', 'EmField',
-        'EmGroup'],
-    'lodel.utils.mlstring': ['MlString']})
+from lodel.editorial_model.model import EditorialModel
+from lodel.editorial_model.components import EmComponent, EmClass, EmField, EmGroup
+from lodel.utils.mlstring import MlString
 
 ## @package lodel.editorial_model.translator.xmlfile
 # This module is a translator toolkit between and editorial model and an XML file.

lodel/leapi/datahandlers/base_classes.py

 import inspect
 import warnings
 
-from lodel.context import LodelContext
-
-LodelContext.expose_modules(globals(), {
-    'lodel.exceptions': [
-        'LodelException',
-        'LodelExceptions',
-        'LodelFatalError',
-        'DataNoneValid',
-        'FieldValidationError'
-    ],
-    'lodel.mlnamedobject.mlnamedobject': ['MlNamedObject'],
-    'lodel.leapi.datahandlers.exceptions': [
-        'LodelDataHandlerConsistencyException',
-        'LodelDataHandlerException'
-    ],
-    'lodel.validator.validator': [
-        'ValidationError'
-    ],
-    'lodel.logger': 'logger',
-    'lodel.utils.mlstring': ['MlString']})
+from lodel.exceptions import LodelException, LodelExceptions, LodelFatalError, DataNoneValid, FieldValidationError
+from lodel.mlnamedobject.mlnamedobject import MlNamedObject
+from lodel.leapi.datahandlers.exceptions import LodelDataHandlerConsistencyException, LodelDataHandlerException
+from lodel.validator.validator import ValidationError
+from lodel.logger import logger
+from lodel.utils.mlstring import MlString
 
 ##
 # @brief Base class for all DataHandlers

lodel/leapi/datahandlers/datas.py

 import inspect
 import re
 
-from lodel.context import LodelContext
-
-LodelContext.expose_modules(globals(), {
-    'lodel.leapi.datahandlers.datas_base': ['Boolean', 'Integer', 'Varchar',
-                                            'DateTime', 'Text', 'File'],
-    'lodel.exceptions': ['LodelException', 'LodelExceptions',
-                         'LodelFatalError', 'DataNoneValid', 'FieldValidationError']})
+from lodel.leapi.datahandlers.datas_base import Boolean, Integer, Varchar, DateTime, Text, File
+from lodel.exceptions import LodelException, LodelExceptions, LodelFatalError, DataNoneValid, FieldValidationError
 
 
 ## @brief Data field designed to handle formated strings

lodel/leapi/datahandlers/datas_base.py

 import datetime
 import time
 import os
-from lodel.context import LodelContext
-
-
-LodelContext.expose_modules(globals(), {
-    'lodel.leapi.datahandlers.base_classes': ['DataField'],
-    'lodel.exceptions': ['LodelException', 'LodelExceptions',
-                         'LodelFatalError', 'DataNoneValid', 'FieldValidationError']})
 
+from lodel.leapi.datahandlers.base_classes import DataField
+from lodel.exceptions import LodelException, LodelExceptions, LodelFatalError, DataNoneValid, FieldValidationError
 
 ##
 ## @brief Data field designed to handle boolean values

lodel/leapi/datahandlers/references.py

-# -*- coding: utf-8 -*-
-
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.leapi.datahandlers.base_classes': ['Reference', 'MultipleRef',
-                                              'SingleRef'],
-    'lodel.logger': 'logger',
-    'lodel.exceptions': ['LodelException', 'LodelExceptions',
-                         'LodelFatalError', 'DataNoneValid',
-                         'FieldValidationError']})
+from lodel.leapi.datahandlers.base_classes import Reference, MultipleRef, SingleRef
+from lodel.logger import logger
+from lodel.exceptions import  LodelException, LodelExceptions, LodelFatalError, DataNoneValid, FieldValidationError
 
 ## @brief Child class of SingleRef. The object referenced must exist
 class Link(SingleRef):

lodel/leapi/exceptions.py

 #-*- coding: utf-8 -*-
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.exceptions': ['LodelExceptions', 'LodelException']})
+from lodel.exceptions import LodelExceptions, LodelException
+
 
 ##@brief Handles LeApi error
 class LeApiError(LodelException):

lodel/leapi/lefactory.py

 import os.path
 import functools
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.editorial_model.components': ['EmComponent', 'EmClass', 'EmField',
-                                         'EmGroup'],
-    'lodel.leapi.leobject': ['LeObject'],
-    'lodel.leapi.datahandlers.base_classes': ['DataHandler'],
-    'lodel.logger': 'logger'})
+from lodel.editorial_model.components import EmComponent, EmClass, EmField, EmGroup
+from lodel.leapi.leobject import LeObject
+from lodel.leapi.datahandlers.base_classes import DataHandler
+from lodel.logger import logger
 
 ## @brief Generates python module code from a given model
 # @param model lodel.editorial_model.model.EditorialModel
     cls_code, bootstrap_instr = generate_classes(model)
 
     # Header
-    imports = """from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.leapi.leobject': ['LeObject'],
-    'lodel.leapi.datahandlers.base_classes': ['DataField'],
-    'lodel.plugin.hooks': ['LodelHook']})
+    imports = """from lodel.leapi.leobject import LeObject
+    from lodel.leapi.datahandlers.base_classes import DataField
+    from lodel.plugin.hooksimport LodelHook
 """
     # generates the list of all classes in the editorial model
     class_list = [LeObject.name2objname(cls.uid) for cls in get_classes(model)]

lodel/leapi/lefactory_common.py

 def lodel2_dyncode_datasources_init(self, caller, payload):
     for cls in dynclasses:
         cls._init_datasources()
-    LodelContext.expose_modules(globals(), {'lodel.plugin.hooks': ['LodelHook']})
+    from lodel.plugin.hooks import LodelHook
     LodelHook.call_hook("lodel2_dyncode_loaded", __name__, dynclasses)

lodel/leapi/leobject.py

 import warnings
 import copy
 
-from lodel.context import LodelContext
-
-LodelContext.expose_modules(globals(), {
-    'lodel.logger': 'logger',
-    'lodel.settings': 'Settings',
-    'lodel.settings.utils': 'SettingsError',
-    'lodel.leapi.query': ['LeInsertQuery', 'LeUpdateQuery', 'LeDeleteQuery',
-                          'LeGetQuery'],
-    'lodel.leapi.exceptions': ['LeApiError', 'LeApiErrors',
-                               'LeApiDataCheckError', 'LeApiDataCheckErrors', 'LeApiQueryError',
-                               'LeApiQueryErrors'],
-    'lodel.plugin.exceptions': ['PluginError', 'PluginTypeError',
-                                'LodelScriptError', 'DatasourcePluginError'],
-    'lodel.exceptions': ['LodelFatalError'],
-    'lodel.plugin.hooks': ['LodelHook'],
-    'lodel.plugin': ['Plugin', 'DatasourcePlugin'],
-    'lodel.leapi.datahandlers.base_classes': ['DatasConstructor', 'Reference']})
+from lodel.logger import logger
+from lodel.settings import Settings
+from lodel.settings.utils import SettingsError
+from lodel.leapi.query import LeInsertQuery, LeUpdateQuery, LeDeleteQuery, LeGetQuery
+from lodel.leapi.exceptions import LeApiError, LeApiErrors, LeApiDataCheckError, LeApiDataCheckErrors, LeApiQueryError, LeApiQueryErrors
+from lodel.plugin.exceptions import PluginError, PluginTypeError, LodelScriptError, DatasourcePluginError
+from lodel.exceptions import LodelFatalError
+from lodel.plugin.hooks import LodelHook
+from lodel.plugin import Plugin, DatasourcePlugin
+from lodel.leapi.datahandlers.base_classes import DatasConstructor, Reference
+
 
 ## @brief Stores the name of the field present in each LeObject that indicates the name of LeObject subclass represented by this object
 CLASS_ID_FIELDNAME = "classname"

lodel/leapi/query.py

 import inspect
 import warnings
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.leapi.exceptions': ['LeApiError', 'LeApiErrors',
-                               'LeApiDataCheckError', 'LeApiDataCheckErrors', 'LeApiQueryError',
-                               'LeApiQueryErrors'],
-    'lodel.plugin.hooks': ['LodelHook'],
-    'lodel.logger': ['logger']})
+from lodel.leapi.exceptions import LeApiError, LeApiErrors, LeApiDataCheckError, LeApiDataCheckErrors, LeApiQueryError, LeApiQueryErrors
+from lodel.plugin.hooks import LodelHook
+from lodel.logger import logger
 
 # @todo check data when running query
 

lodel/logger.py

 ##@brief Module initialisation from settings
 #@return True if inited else False
 def __init_from_settings():
-    from lodel.context import LodelContext
-    try:
-        LodelContext.expose_modules(globals(), {
-            'lodel.settings': ['Settings']})
-    except Exception:
-        return False
-    LodelContext.expose_modules(globals(), {
-        'lodel.settings.settings': [('Settings', 'Lodel2Settings')]})
+    from lodel.settings import Settings
+    from lodel.settings.settings import Settings, Lodel2Settings
     if not Lodel2Settings.started():
         return False
     # capture warning disabled, because the custom format raises error (unable

lodel/mlnamedobject/mlnamedobject.py

 #-*- coding:utf-8 -*-
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.utils.mlstring': ['MlString']})
+from lodel.utils.mlstring import MlString
+
 
 ## @package lodel.mlnamedobject.mlnamedobject Lodel2 description of objects module
 #

lodel/plugin/__init__.py

 # - @ref lodel.plugin.interface.InterfacePlugin "InterfacePlugin"
 # - @ref lodel.plugin.sessionhandler.SessionHandlerPlugin "SessionHandlerPlugin"
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.plugin.hooks': ['LodelHook'],
-    'lodel.plugin.plugins': ['Plugin', 'CustomMethod'],
-    'lodel.plugin.datasource_plugin': ['DatasourcePlugin'],
-    'lodel.plugin.sessionhandler': ['SessionHandlerPlugin'],
-    'lodel.plugin.interface': ['InterfacePlugin'],
-    'lodel.plugin.extensions': ['Extension']})
+from lodel.plugin.hooks import LodelHook
+from lodel.plugin.plugins import Plugin, CustomMethod
+from lodel.plugin.datasource_plugin import DatasourcePlugin
+from lodel.plugin.sessionhandler SessionHandlerPlugin
+from lodel.plugin.interface import InterfacePlugin
+from lodel.plugin.extensions import Extension

lodel/plugin/core_hooks.py

 #-*- coding: utf-8 -*-
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.plugin': ['LodelHook'],
-    'lodel.settings': ['Settings'],
-    'lodel.logger': 'logger'})
+from lodel.plugin import LodelHook
+from lodel.settings import Setting
+from lodel.logger import logger
 
 ## @package lodel.plugin.core_hooks
 # @brief Lodel2 internal hooks declaration
 # @param payload * : data to be given to the hook
 @LodelHook('lodel2_bootstraped')
 def list_hook_debug_hook(name, caller, payload):
-    LodelContext.expose_modules(globals(), {
-        'lodel.logger': 'logger'})
+    from lodel.logger import logger
     hlist = LodelHook.hook_list()
     for name, reg_hooks in hlist.items():
         for hook, priority in reg_hooks:
 # @param dynclasses list : a list of classes in which the injection will occur
 @LodelHook("lodel2_dyncode_loaded")
 def lodel2_plugins_custom_methods(self, caller, dynclasses):
-    LodelContext.expose_modules(globals(), {
-        'lodel.plugin.plugins': ['CustomMethod']})
+    from lodel.plugin.plugins import CustomMethod
     CustomMethod.set_registered(dynclasses)

lodel/plugin/core_scripts.py

 import os
 import os.path
 import argparse
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.plugin.scripts': 'lodel_script',
-    'lodel.logger': 'logger'})
+
+from lodel.plugin.scripts import lodel_script
+from lodel.logger import logger
 
 # @package lodel.plugin.core_scripts
 #@brief Lodel2 internal scripts declaration

lodel/plugin/datasource_plugin.py

 # It contains the base classes for all the datasource plugins that could be added to Lodel
 
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.plugin.plugins': ['Plugin'],
-    'lodel.plugin.exceptions': ['PluginError', 'PluginTypeError',
-        'LodelScriptError', 'DatasourcePluginError'],
-    'lodel.validator.validator': ['Validator'],
-    'lodel.exceptions': ['LodelException', 'LodelExceptions',
-        'LodelFatalError', 'DataNoneValid', 'FieldValidationError']})
+
+from lodel.plugin.plugins import Plugin
+from lodel.plugin.exceptions import PluginError, PluginTypeError, LodelScriptError, DatasourcePluginError 
+from lodel.validator.validator import Validator
+from lodel.exceptions import LodelException, LodelExceptions, LodelFatalError, DataNoneValid, FieldValidationError
 
 ## @brief The plugin type that is used in the global settings of Lodel
 _glob_typename = 'datasource'
     # @throw SettingsError if there are misconfigured datasource settings.
     @staticmethod
     def plugin_name(ds_name, ro):
-        LodelContext.expose_modules(globals(), {
-            'lodel.settings': ['Settings']})
+        from lodel.settings import Settings
         # fetching connection identifier given datasource name
         try:
             ds_identifier = getattr(Settings.datasources, ds_name)
     # @throw DatasourcePluginError if a datasource plugin or instance cannot be found
     @staticmethod
     def _get_ds_connection_conf(ds_identifier,ds_plugin_name):
-        LodelContext.expose_modules(globals(), {
-            'lodel.settings': ['Settings']})
+        from lodel.settings import Settings
         if ds_plugin_name not in Settings.datasource._fields:
             msg = "Unknown or unconfigured datasource plugin %s"
             msg %= ds_plugin_name

lodel/plugin/extensions.py

 ## @package lodel.plugin.extensions A package to manage the Extension plugins
 
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.plugin.plugins': ['Plugin'],
-    'lodel.plugin.exceptions': ['PluginError', 'PluginTypeError',
-        'LodelScriptError', 'DatasourcePluginError'],
-    'lodel.validator.validator': ['Validator']})
+from lodel.plugin.plugins import Plugin
+from lodel.plugin.exceptions import PluginError, PluginTypeError, LodelScriptError, DatasourcePluginError
+from lodel.validator.validator import Validator
 
 _glob_typename = 'extension'
 

lodel/plugin/hooks.py

 
 import os
 import copy
-from lodel.context import LodelContext
-
 
 ## @brief Class designed to handle a hook's callback with a priority
 class DecoratedWrapper(object):
     # @return modified payload
     @classmethod
     def call_hook(cls, hook_name, caller, payload):
-        LodelContext.expose_modules(globals(), {'lodel.logger': 'logger'})
+        from lodel.logger import logger
         logger.debug("Calling hook '%s'" % hook_name)
         if hook_name in cls._hooks:
             for hook in cls._hooks[hook_name]:

lodel/plugin/interface.py

 ## @package lodel.plugin.interface Handles the Interface type plugins
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.plugin.plugins': ['Plugin'],
-    'lodel.plugin.exceptions': ['PluginError', 'PluginTypeError',
-        'LodelScriptError', 'DatasourcePluginError'],
-    'lodel.validator.validator': ['Validator']})
+from lodel.plugin.plugins import Plugin
+from lodel.plugin.exceptions import PluginError, PluginTypeError, LodelScriptError, DatasourcePluginError
+from lodel.validator.validator import Validator
+
 
 ## @brief Global type name used in the settings of Lodel for this type of plugins
 _glob_typename = 'ui'

lodel/plugin/plugins.py

 import json
 from importlib.machinery import SourceFileLoader
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.logger': 'logger',
-    'lodel.settings.utils': ['SettingsError'],
-    'lodel.plugin.hooks': ['LodelHook'],
-    'lodel.plugin.exceptions': ['PluginError', 'PluginVersionError',
-                                'PluginTypeError', 'LodelScriptError', 'DatasourcePluginError'],
-    'lodel.exceptions': ['LodelException', 'LodelExceptions',
-                         'LodelFatalError', 'DataNoneValid', 'FieldValidationError']})
+from lodel.logger import logger
+from lodel.settings.utils import SettingsError
+from lodel.plugin.hooks import LodelHook
+from lodel.plugin.exceptions import PluginError, PluginVersionError, PluginTypeError, LodelScriptError, DatasourcePluginError
+from lodel.exceptions import LodelException, LodelExceptions, LodelFatalError, DataNoneValid, FieldValidationError
+
 
 ##  @package lodel.plugins Lodel2 plugins management
 #@ingroup lodel2_plugins
 PLUGIN_DEPS_VARNAME = '__plugin_deps__'
 ## @brief Name of the optional activate method
 ACTIVATE_METHOD_NAME = '_activate'
-## @brief Default & failover value for plugins path list
-PLUGINS_PATH = os.path.join(LodelContext.context_dir(), 'plugins')
 
 ## @brief List storing the mandatory variables expected in a plugin __init__.py
 # file
 
         # Importing __init__.py infos in it
         plugin_module = self.module_name()
-        self.module = LodelContext.module(plugin_module)
+        self.module = LodelContext.module(plugin_module) # To be modified without LodelContext, i let it to raise an error and remember
 
         # loading confspecs
         try:
     # etc...
     @classmethod
     def plugin_list_confspec(cls):
-        LodelContext.expose_modules(globals(), {
-            'lodel.settings.validator': ['confspec_append']})
+        from lodel.settings.validator import confspec_append
         res = dict()
         for pcls in cls.plugin_types():
             plcs = pcls.plist_confspec()
     ## @brief Import init file from a plugin path
     #@param path str : Directory path
     #@return a tuple (init_module, module_name)
-    #@todo replace by LodelContext usage !!! (not mandatory, this fun
-    # is only used in plugin discover method)
     @classmethod
     def import_init(cls, path):
         cls._mod_cnt += 1  # in order to ensure module name unicity
     @classmethod
     def _discover(cls, path):
         # Ensure plugins symlink creation
-        LodelContext.expose_modules(globals(), {
-            'lodel.plugins': 'plugins'})
+        from lodel.plugins import plugins
         res = []
         to_explore = [path]
         while len(to_explore) > 0:

lodel/plugin/scripts.py

 import argparse
 import sys
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.logger': 'logger',
-    'lodel.exceptions': ['LodelException', 'LodelExceptions',
-        'LodelFatalError', 'DataNoneValid', 'FieldValidationError']})
+from lodel.logger import logger
+from lodel.exceptions import LodelException, LodelExceptions, LodelFatalError, DataNoneValid, FieldValidationError
+
 
 ## @defgroup lodel2_script Administration scripts
 # @ingroup lodel2_plugins

lodel/plugin/sessionhandler.py

-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.plugin.plugins': ['Plugin', 'MetaPlugType'],
-    'lodel.plugin.exceptions': ['PluginError', 'PluginTypeError',
-        'LodelScriptError', 'DatasourcePluginError'],
-    'lodel.validator.validator': ['Validator']})
+from lodel.plugin.plugins import Plugin, MetaPlugType
+from lodel.plugin.exceptions import PluginError, PluginTypeError, LodelScriptError, DatasourcePluginError
+from lodel.validator.validator import Validator
 
 
 ##@brief SessionHandlerPlugin metaclass designed to implements a wrapper

lodel/plugins/dummy/__init__.py

 ## @package lodel.plugins.dummy Basic plugin used as a template for developping new plugins
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.validator.validator': ['Validator']})
+from lodel.validator.validator import Validator
 
 ## @brief plugin's name (matching the package's name)
 __plugin_name__ = "dummy"

lodel/plugins/dummy/confspec.py

 
 ## @package lodel.plugins.dummy.confspec The module that defines the plugin's configuration options
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.validator.validator': ['Validator']})
+from lodel.validator.validator import Validator
 
 ## @brief Dictionary defining the plugin's configuration options and their validators
 CONFSPEC = {

lodel/plugins/dummy/main.py

 
 ## @package lodel.plugins.dummy.main Plugin's loader module
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.plugin': ['LodelHook', 'CustomMethod'],
-    'lodel.settings' : 'settings'})
+from lodel.plugin import LodelHook, CustomMethod,
+from lodel.settings import settings
 
 
 ## @brief callback method using lodel's hook system

lodel/plugins/dummy_datasource/__init__.py

 ## @package lodel.plugins.dummy_datasource Example of a datasource type plugin
 
 # Here we use the Lodel Context Manager to expose the modules which are specific to the application
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.validator.validator': ['Validator']})
+from lodel.validator.validator import Validator
 from .datasource import DummyDatasource as Datasource
 
 ## @brief plugin's category

lodel/plugins/dummy_datasource/datasource.py

 
 ## @package lodel.plugins.dummy_datasource.datasource This module contains the main class of the datasource, implementing the basic operations one can perform.
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.plugin.datasource_plugin': ['AbstractDatasource']})
+from lodel.plugin.datasource_plugin import AbstractDatasource
 
 ## @brief Datasource class, inherited from @ref lodel.plugin.datasource.AbstractDatasource
 class DummyDatasource(AbstractDatasource):

lodel/plugins/dummy_datasource/main.py

 
 ## @package lodel.plugins.dummy_datasource.main The main module of the plugin. 
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.plugin': ['LodelHook']})
+from lodel.plugin import LodelHook
 from .datasource import DummyDatasource as Datasource
 
 ## @brief returns the migration handler of this plugin. 

lodel/plugins/dummy_datasource/migration_handler.py

-#-*- coding: utf-8 -*-
-
 ## @package lodel.plugins.dummy_datasource.migration_handler Migration handler of the datasource plugin. 
 #
 # The migration handler is here to report the changes made in the editorial model to the data source. 

lodel/plugins/filesystem_session/__init__.py

 ## @package plugins.filesystem_session This package is a plugin for filesystem based session management
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.validator.validator': ['Validator']})
+from lodel.validator.validator import Validator
 
 __plugin_name__ = 'filesystem_session'
 __version__ = [0,0,1]

lodel/plugins/filesystem_session/confspec.py

 
 ## @package lodel.plugins.filesystem_session.confspec A module that defines the configuration options available for that plugin
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.validator.validator': ['Validator']})
+from lodel.validator.validator import Validator
 
 ## @brief Dictionary of the options and their corresponding validators
 CONFSPEC = {

lodel/plugins/filesystem_session/main.py

 import re
 import time
 from .filesystem_session import FileSystemSession
-from lodel.context import LodelContext
 
-
-LodelContext.expose_modules(globals(), {
-    'lodel.logger': 'logger',
-    'lodel.auth.exceptions': ['ClientAuthenticationFailure'],
-    'lodel.settings': ['Settings']})
+from lodel.logger import logger
+from lodel.auth.exceptions import ClientAuthenticationFailure,
+from lodel.settings import Settings
 
 __sessions = dict()
 

lodel/plugins/mongodb_datasource/confspec.py

-# -*- coding: utf-8 -*-
-
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.validator.validator': ['Validator']})
+from lodel.validator.validator import Validator
 
 ## @brief Mongodb datasource plugin confspec
 # @ingroup plugin_mongodb_datasource

lodel/plugins/mongodb_datasource/datasource.py

 import pymongo
 from pymongo.errors import BulkWriteError
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.logger': 'logger',
-    'lodel.leapi.leobject': ['CLASS_ID_FIELDNAME'],
-    'lodel.leapi.datahandlers.base_classes': ['Reference', 'MultipleRef'],
-    'lodel.exceptions': ['LodelException', 'LodelFatalError'],
-    'lodel.plugin.datasource_plugin': ['AbstractDatasource']})
+from lodel.logger import logger
+from lodel.leapi.leobject import CLASS_ID_FIELDNAME
+from lodel.leapi.datahandlers.base_classes import Reference, MultipleRef
+from lodel.exceptions import LodelException, LodelFatalError
+from lodel.plugin.datasource_plugin import AbstractDatasource
 
 from . import utils
 from .exceptions import *

lodel/plugins/mongodb_datasource/exceptions.py

-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.exceptions': ['LodelException', 'LodelExceptions',
-        'LodelFatalError', 'DataNoneValid', 'FieldValidationError']})
+from lodel.exceptions import LodelException, LodelExceptions, LodelFatalError, DataNoneValid, FieldValidationError
 
 #@ingroup plugin_mongodb_datasource
 class MongoDbDataSourceError(Exception):

lodel/plugins/mongodb_datasource/main.py

-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.plugin': ['LodelHook']})
+from lodel.plugin import LodelHook
 
 from .datasource import MongoDbDatasource as Datasource
 

lodel/plugins/mongodb_datasource/migration_handler.py

 # -*- coding: utf-8 -*-
 import datetime
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.editorial_model.components': ['EmClass', 'EmField'],
-    'lodel.editorial_model.model': ['EditorialModel'],
-    'lodel.leapi.datahandlers.base_classes': ['DataHandler'],
-    'lodel.plugin': ['LodelHook'],
-    'lodel.logger': 'logger'})
+from lodel.editorial_model.components import EmClass, EmField
+from lodel.editorial_model.model import EditorialModel
+from lodel.leapi.datahandlers.base_classes import DataHandler
+from lodel.plugin import LodelHook
+from lodel.logger import logger
 
 from leapi_dyncode import * #<-- TODO : handle this !!!
 

lodel/plugins/mongodb_datasource/utils.py

 import pymongo
 from pymongo import MongoClient
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.settings.settings': [('Settings', 'settings')],
-    'lodel.logger': 'logger'})
+from lodel.settings.settings import Settings, settings
+from lodel.logger logger
 
 common_collections = {
     'object': 'objects',

lodel/plugins/multisite/__init__.py

-from lodel.context import LodelContext, ContextError
+from lodel.validator.validator import Validator
 try:
-    LodelContext.expose_modules(globals(), {
-        'lodel.validator.validator': ['Validator']})
-
     __plugin_name__ = "multisite"
     __version__ = '0.0.1' #or __version__ = [0,0,1]
     __loader__ = "main.py"

lodel/plugins/multisite/confspecs.py

-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.validator.validator': ['Validator']})
+from lodel.validator.validator import Validator
 
 #Define a minimal confspec used by multisite loader
 LODEL2_CONFSPECS = {

lodel/plugins/multisite/loader.py

 #
 #This file (once bootstraped) start a new process for uWSGI. uWSGI then
 #run lodel.plugins.multisite.run.application function
-try:
-    from lodel.context import LodelContext
-except ImportError:
-    LODEL_BASE_DIR = os.path.dirname(
-        os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-    from lodel.context import LodelContext
 
 from lodel import buildconf
 
-LodelContext.init(LodelContext.MULTISITE)
-LodelContext.set(None) #Loading context creation
 #Multisite instance settings loading
 CONFDIR = os.path.join(os.getcwd(), 'conf.d')
 if not os.path.isdir(CONFDIR):
     warnings.warn('%s do not exists, default settings used' % CONFDIR)
-LodelContext.expose_modules(globals(), {
-    'lodel.settings.settings': [('Settings', 'settings')],
-    'lodel.plugins.multisite.confspecs': 'multisite_confspecs'})
+    
+from lodel.settings.settings import Settings,settings
+from lodel.plugins.multisite.confspecs import multisite_confspecs
+
 if not settings.started():
     settings('./conf.d', multisite_confspecs.LODEL2_CONFSPECS)
 
-LodelContext.expose_modules(globals(), {
-    'lodel.settings': ['Settings']})
+from lodel.settings import Settings
 
 ##@brief Starts uwsgi in background using settings
 def uwsgi_fork():

lodel/plugins/multisite/run.py

 CONFDIR = os.path.join(os.getcwd(), 'conf.d')
 if not os.path.isdir(CONFDIR):
     warnings.warn('%s do not exists, default settings used' % CONFDIR)
-LodelContext.expose_modules(globals(), {
-    'lodel.settings.settings': [('Settings', 'settings')],
-    'lodel.plugins.multisite.confspecs': 'multisite_confspecs'})
+from lodel.settings.settings import Settings, settings
+from lodel.plugins.multisite.confspecs import multisite_confspecs
+
 if not settings.started():
     settings('./conf.d', multisite_confspecs.LODEL2_CONFSPECS)
 
     LodelContext.set(ctx_name)
     os.chdir(lodelsite_path)
     # Loading settings
-    LodelContext.expose_modules(globals(), {
-        'lodel.settings.settings': [('Settings', 'settings')]})
+    from lodel.settings.settings import Settings, settings
     if not settings.started():
         settings('./conf.d')
-    LodelContext.expose_modules(globals(), {'lodel.settings': ['Settings']})
+    from lodel.settings import Settings
 
     # Loading hooks & plugins
-    LodelContext.expose_modules(globals(), {
-        'lodel.plugin': ['LodelHook'],
-        'lodel.plugin.core_hooks': 'core_hooks',
-        'lodel.plugin.core_scripts': 'core_scripts'
+    from lodel.plugin import LodelHook
+    from lodel.plugin.core_hooks import core_hooks
+    from lodel.plugin.core_scripts import core_scripts
     })
 
     #Load plugins
-    LodelContext.expose_modules(globals(), {
-        'lodel.logger': 'logger',
-        'lodel.plugin': ['Plugin']})
+    from lodel.logger import logger
+    from lodel.plugin import Plugin
     logger.debug("Loader.start() called")
     Plugin.load_all()
     #Import & expose dyncode
             "No site named '%s'" % site_id)
     #Calling webui
     return FAST_APP_EXPOSAL_CACHE[site_id].application(env, start_response)
-    #LodelContext.expose_modules(globals(), {
-    #    'lodel.plugins.webui.run': ['application']})
-    #return application(env, start_response)
+
 

lodel/plugins/ram_sessions/__init__.py

-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.validator.validator': ['Validator']})
+from lodel.validator.validator Validator
 
 __plugin_name__ = 'ram_sessions'
 __version__ = [0,0,1]

lodel/plugins/ram_sessions/main.py

 import copy
 import binascii
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.logger': 'logger',
-    'lodel.settings': ['Settings'],
-    'lodel.auth.exceptions': ['ClientError', 'ClientAuthenticationFailure',
-        'ClientPermissionDenied', 'ClientAuthenticationError']})
+from lodel.logger import logger
+from lodel.settings import Settings
+from lodel.auth.exceptions import ClientError, ClientAuthenticationFailure, ClientPermissionDenied, ClientAuthenticationError
 
 __sessions = dict()
 

lodel/plugins/webui/client.py

-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {'lodel.auth.client': ['Client']})
+from lodel.auth.client import Client
 
 class WebUiClient(Client):
     

lodel/plugins/webui/confspec.py

-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.validator.validator': ['Validator']})
+from lodel.validator.validator import Validator
 
 CONFSPEC = {
     'lodel2.webui': {

lodel/plugins/webui/exceptions.py

-#-*- coding: utf-8 -*-
-
 from werkzeug.wrappers import Response
-from lodel.context import LodelContext
 
 class HttpException(Exception):
 
     
     ##@brief Log exception with lodel logger
     def log(self):
-        LodelContext.expose_modules(globals(), {'lodel.logger': 'logger'})
+        from lodel.logger import logger
         msg = "Webui HTTP exception : %s" % self
         if self.status_code / 100 == 4:
             logger.security(msg)

lodel/plugins/webui/interface/controllers/admin.py

 from ...exceptions import *
 from .base import get_response
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.leapi.exceptions': [],
-    'lodel.logger': 'logger',
-    'lodel.leapi.datahandlers.base_classes': ['MultipleRef'],
-    'lodel.leapi.exceptions': ['LeApiDataCheckErrors'],
-    'lodel.exceptions': ['LodelExceptions']})
+import lodel.leapi.exceptions
+from lodel.logger import logger
+from lodel.leapi.datahandlers.base_classes import MultipleRef
+from lodel.leapi.exceptions import LeApiDataCheckErrors
+from lodel.exceptions import LodelExceptions
+
 LodelContext.expose_dyncode(globals(), 'dyncode')
 
 from ...client import WebUiClient

lodel/plugins/webui/interface/controllers/listing.py

 # -*- coding: utf-8 -*-
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {'lodel.logger': 'logger'})
+from lodel.logger import logger
+
 LodelContext.expose_dyncode(globals(), 'dyncode')
 
 from .base import get_response

lodel/plugins/webui/interface/controllers/users.py

 from ...exceptions import *
 from ...client import WebUiClient as WebUiClient
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {'lodel.logger': 'logger'})
+from lodel.logger import logger
+
 LodelContext.expose_dyncode(globals(), 'dyncode')
 
 ##@brief These functions are called by the rules defined in ../urls.py

lodel/plugins/webui/interface/router.py

 from .urls import urls
 from ..main import root_url
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.settings': ['Settings']})
+from lodel.settings import Settings
 
 def format_url_rule(url_rule):
     if url_rule.startswith('^'):

lodel/plugins/webui/interface/template/loader.py

 import jinja2
 import os
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {'lodel.settings': ['Settings']})
+from lodel.settings import Settings
 LodelContext.expose_dyncode(globals())
 
 from ...client import WebUiClient as WebUiClient

lodel/plugins/webui/main.py

 import sys
 import shlex
 
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.plugin': ['LodelHook'],
-    'lodel.settings': ['Settings']})
+from lodel.plugin import LodelHook
+from lodel.settings import Settings
 
 from lodel import buildconf #<-- This one is common to the build
 

lodel/plugins/webui/run.py

-# -*- coding: utf-8 -*-
-from lodel.context import LodelContext
-
-if not LodelContext.is_initialized():
-    import loader # Lodel2 loader
+import loader # Lodel2 loader
 
 import os
 import hashlib
 
 from werkzeug.wrappers import Response
 
-LodelContext.expose_modules(globals(), {
-    'lodel.settings': ['Settings'],
-    'lodel.logger': 'logger',
-    'lodel.auth.exceptions': ['ClientError', 'ClientAuthenticationFailure',
-        'ClientPermissionDenied', 'ClientAuthenticationError']})
+from lodel.settings import Settings
+from lodel.logger import logger
+from lodel.auth.exceptions import ClientError, ClientAuthenticationFailure, ClientPermissionDenied, ClientAuthenticationError
 
 from .interface.router import get_controller
 from .interface.lodelrequest import LodelRequest

lodel/settings/__init__.py

 #   print("DEBUG MODE !")
 # </pre>
 #
-from lodel.context import LodelContext
-LodelContext.expose_modules(globals(), {
-    'lodel.settings.settings': [('SettingsRO', 'Settings')]})
+from lodel.settings.settings import SettingsRO, Settings
 

lodel/settings/settings.py

 import types  # for dynamic bindings
 from collections import namedtuple
 
-from lodel.context import LodelContext
-
-LodelContext.expose_modules(globals(), {
-    'lodel.logger': 'logger',
-    'lodel.settings.utils': ['SettingsError', 'SettingsErrors'],
-    'lodel.validator.validator': ['Validator', 'LODEL2_CONF_SPECS',
-                                  'confspec_append'],
-    'lodel.settings.settings_loader': ['SettingsLoader']})
+from lodel.logger import logger
+from lodel.settings.utils import SettingsError, SettingsErrors
+from lodel.settings.settings_loader import SettingsLoader
+from lodel.validator.validator import Validator, LODEL2_CONF_SPECS, confspec_append
 
 
 ##  @package lodel.settings.settings Lodel2 settings module
 
     # @brief This method handles Settings instance bootstraping
     def __bootstrap(self):
-        LodelContext.expose_modules(globals(), {
-            'lodel.plugin.plugins': ['Plugin', 'PluginError']})
+        from lodel.plugin.plugins import Plugin, PluginError
         logger.debug("Settings bootstraping")
         if self.__conf_specs is None:
             lodel2_specs = LODEL2_CONF_SPECS

lodel/settings/settings_loader.py

 import glob
 import copy
 
-from lodel.context import LodelContext
-
 #  @package lodel.settings.settings_loader Lodel2 loader of configuration options
 #
 # From a filesystem directory, all ini files are loaded in a dict (key/value) for each option
 # The options are called one by one by lodel bootstrap, if one or more options remains 
 # then an exception is raised
 
-LodelContext.expose_modules(globals(), {
-    'lodel.logger': 'logger',
-    'lodel.settings.utils': ['SettingsError', 'SettingsErrors'],
-    'lodel.validator.validator': ['ValidationError']})
+from lodel.logger import logger
+from lodel.settings.utils import SettingsError, SettingsErrors
+from lodel.validator.validator import ValidationError
+
 
 ##@brief Merges and loads configuration files
 class SettingsLoader(object):

lodel/validator/validator.py

 import copy
 from lodel.context import LodelContext
 
-
-LodelContext.expose_modules(globals(), {
-    'lodel.mlnamedobject.mlnamedobject': ['MlNamedObject'],
-    'lodel.exceptions': ['LodelException', 'LodelExceptions',
-                         'LodelFatalError', 'FieldValidationError']})
+from lodel.mlnamedobject.mlnamedobject import MlNamedObject
+from lodel.exceptions import LodelException, LodelExceptions, LodelFatalError, FieldValidationError
 
 
 ##
 #
 # @todo modify the hardcoded dyncode import (it's a warning)
 def emfield_val(value):
-    LodelContext.expose_modules(globals(),
-                                {'lodel.plugin.hooks': ['LodelHook']})
+    from lodel.plugin.hooks import LodelHook
     spl = value.split('.')
     if len(spl) != 2:
         msg = "Expected a value in the form CLASSNAME.FIELDNAME but got : %s"
 # Able to check that the value is a plugin and if it is of a specific type
 def plugin_validator(value, ptype=None):
     if value:
-        LodelContext.expose_modules(globals(), {
-            'lodel.plugin.hooks': ['LodelHook']})
+        from lodel.plugin.hooks import LodelHook
         value = copy.copy(value)
 
         @LodelHook('lodel2_dyncode_bootstraped')
         def plugin_type_checker(hookname, caller, payload):
-            LodelContext.expose_modules(globals(), {
-                'lodel.plugin.plugins': ['Plugin'],
-                'lodel.plugin.exceptions': ['PluginError']})
+            from lodel.plugin.plugins import Plugin
+            from lodel.plugin.exceptions import PluginError
             if value is None:
                 return
             try:

nocontext_tests.py

-#-*- coding: utf-8 -*-
-
-# @brief Loader for tests which do not need an lodel installation
-#
-# Options
-################
-#
-# @note We can pass the path to a directory to write results file, nocontext_tests.log
-# It has to be at first, otherwise it will not be taken
-# and the default one, current directory, will be used.
-# The results are not displayed, only stored in nocontext_tests.log
-#
-# -f, --failfast
-#
-#    Stop the test run on the first error or failure.
-# -v --verbose
-#
-#   higher verbosity
-#
-#
-
-import sys
-import os
-import os.path
-import unittest
-
-
-loader = unittest.TestLoader()
-
-if ((len(sys.argv) > 1) and (sys.argv[1].startswith('-')) is False):
-    dpath = sys.argv[1]
-else:
-    dpath = '.'
-
-suite = loader.discover('tests', pattern='nc_test*.py')
-with open(dpath + '/nocontext_tests.log', 'w') as logfile:
-    unittest.TextTestRunner(
-        logfile,
-        failfast='-f' in sys.argv,
-        verbosity=2 if '-v' in sys.argv else 1).run(suite)

plugins

-lodel/plugins/

progs/slim/install_model/loader.py

     print(e)
     exit(1)
 
-#Set context to MONOSITE
-from lodel.context import LodelContext
-LodelContext.init()
-
 if 'LODEL2_NO_SETTINGS_LOAD' not in os.environ:
     #
     # Loading settings
     #
-    LodelContext.expose_modules(globals(), {
-        'lodel.settings.settings': [('Settings', 'settings')]})
+    from lodel.settings.settings import Settings, settings
     if not settings.started():
         settings('conf.d')
-    LodelContext.expose_modules(globals(), {
-        'lodel.settings': ['Settings']})
+    from lodel.settings import Settings
     
     #Starts hooks
-    LodelContext.expose_modules(globals(), {
-        'lodel.plugin': ['LodelHook'],
-	'lodel.plugin.core_hooks': 'core_hooks',
-	'lodel.plugin.core_scripts': 'core_scripts'})
+    from lodel.plugin import LodelHook
+	from lodel.plugin.core_hooks import core_hooks
+	from lodel.plugin.core_scripts import core_scripts
 
 def start():
     #Load plugins
-    LodelContext.expose_modules(globals(), {
-        'lodel.logger': 'logger',
-        'lodel.plugin': ['Plugin']})
+    from lodel.logger import logger
+    from lodel.plugin import Plugin
     logger.debug("Loader.start() called")
     Plugin.load_all()
     LodelHook.call_hook('lodel2_bootstraped', '__main__', None)