Merge branch 'master' of git@git.labocleo.org:lodel2

lodel/auth/client.py

     'lodel.logger': 'logger',
     'lodel.plugin': [('SessionHandlerPlugin', 'SessionHandler')],
     'lodel.auth.exceptions': ['ClientError', 'ClientAuthenticationFailure',
-        'ClientPermissionDenied', 'ClientAuthenticationError'],
-    'lodel.leapi.query': ['LeGetQuery'],})
+                              'ClientPermissionDenied', 'ClientAuthenticationError'],
+    'lodel.leapi.query': ['LeGetQuery'], })
 
-##@brief Client metaclass designed to implements container accessor on 
-#Client Class
+# @brief Client metaclass designed to implements container accessor on
+# Client Class
 #
 #@todo Maybe we can delete this metaclass....
+
+
 class ClientMetaclass(type):
-    
+
     def __init__(self, name, bases, attrs):
         return super(ClientMetaclass, self).__init__(name, bases, attrs)
 
     def __getitem__(self, key):
-        return self.datas()[key]
+        return self.data()[key]
 
     def __delitem__(self, key):
-        del(self.datas()[key])
+        del(self.data()[key])
 
     def __setitem__(self, key, value):
         if self.get_session_token() is None:
             self.set_session_token(SessionHandler.start())
-        datas = self.datas()
-        datas[key] = value
+        data = self.data()
+        data[key] = value
 
     def __str__(self):
         return str(self._instance)
 
-##@brief Abstract singleton class designed to handle client informations
+# @brief Abstract singleton class designed to handle client informations
 #
 # This class is designed to handle client authentication and sessions
-class Client(object, metaclass = ClientMetaclass):
-    
-    ##@brief Singleton instance
+
+
+class Client(object, metaclass=ClientMetaclass):
+
+    # @brief Singleton instance
     _instance = None
-    ##@brief List of dict that stores field ref for login and password
+    # @brief List of dict that stores field ref for login and password
     #
-    # Storage specs : 
+    # Storage specs :
     #
     # A list of dict, with keys 'login' and 'password', items are tuple.
-    #- login tuple contains (LeObjectChild, FieldName, link_field) with:
+    # - login tuple contains (LeObjectChild, FieldName, link_field) with:
     # - LeObjectChild the dynclass containing the login
     # - Fieldname the fieldname of LeObjectChild containing the login
     # - link_field None if both login and password are in the same
     # LeObjectChild. Else contains the field that make the link between
     # login LeObject and password LeObject
-    #- password typle contains (LeObjectChild, FieldName)
+    # - password typle contains (LeObjectChild, FieldName)
     _infos_fields = None
-    
-    ##@brief Constant that stores the session key that stores authentication
-    #informations
+
+    # @brief Constant that stores the session key that stores authentication
+    # informations
     _AUTH_DATANAME = '__auth_user_infos'
-    
 
-    ##@brief Constructor
+    # @brief Constructor
     #@param session_token mixed : Session token provided by client to interface
-    def __init__(self,session_token = None):
+    def __init__(self, session_token=None):
         logger.debug(session_token)
         if self.__class__ == Client:
             raise NotImplementedError("Abstract class")
         logger.debug("New instance of Client child class %s" %
-            self.__class__.__name__)
+                     self.__class__.__name__)
         if Client._instance is not None:
             old = Client._instance
             Client._instance = None
             del(old)
             logger.debug("Replacing old Client instance by a new one")
         else:
-            #first instanciation, fetching settings
+            # first instanciation, fetching settings
             self.fetch_settings()
-        ##@brief Stores infos for authenticated users (None == anonymous)
+        # @brief Stores infos for authenticated users (None == anonymous)
         self.__user = None
-        ##@brief Stores the session handler
+        # @brief Stores the session handler
         Client._instance = self
-        ##@brief Stores LodelSession instance
-        
-        self.__datas = dict()
+        # @brief Stores LodelSession instance
+        self.__data = dict()
         if session_token is not None:
-            self.__datas = SessionHandler.restore(session_token)
+            self.__data = SessionHandler.restore(session_token)
         self.__session_token = session_token
-        
+
         logger.debug("New client : %s" % self)
-    
+
     def __del__(self):
         del(self.__session_token)
-        del(self.__datas)
+        del(self.__data)
+    # @brief Returns session
+    #@ returns the dict which stores session
 
     @classmethod
-    def datas(cls):
-        return cls._instance.__datas
-    
+    def data(cls):
+        return cls._instance.__data
+
+    # @brief Returns the user's information contained in the session's data
     @classmethod
     def user(cls):
-        if '__auth_user_infos' in cls._instance.__datas:
-            return cls._instance.__datas['__auth_user_infos']
+        if '__auth_user_infos' in cls._instance.__data:
+            return cls._instance.__data['__auth_user_infos']
         else:
             return None
+
+    # @brief Returns the session's token
     @classmethod
     def get_session_token(cls):
         return cls._instance.__session_token
-    
+
+    # @brief Set the session's token
+    #@param the value of the token
     @classmethod
     def set_session_token(cls, value):
         cls._instance.__session_token = value
-    
-    ##@brief Try to authenticate a user with a login and a password
+
+    # @brief Try to authenticate a user with a login and a password
     #@param login str : provided login
     #@param password str : provided password (hash)
     #@warning brokes composed UID
-    #@note implemets multiple login/password sources (useless ?)
+    #@note implements multiple login/password sources (useless ?)
     #@todo composed UID broken method
     #@todo allow to provide an authentication source
     @classmethod
-    def authenticate(self, login = None, password = None):
-        #Authenticate
+    def authenticate(self, login=None, password=None):
+        # Authenticate
         for infos in self._infos_fields:
             logger.debug(self._infos_fields)
             login_cls = infos['login'][0]
             pass_cls = infos['password'][0]
             qfilter = "{passfname} = {passhash}"
-            uid_fname = login_cls.uid_fieldname()[0] #COMPOSED UID BROKEN
+            uid_fname = login_cls.uid_fieldname()[0]  # COMPOSED UID BROKEN
             if login_cls == pass_cls:
-                #Same EmClass for login & pass
+                # Same EmClass for login & pass
                 qfilter = qfilter.format(
-                    passfname = infos['password'][1],
-                    passhash = password)
+                    passfname=infos['password'][1],
+                    passhash=password)
             else:
-                #Different EmClass, building a relational filter
+                # Different EmClass, building a relational filter
                 passfname = "%s.%s" % (infos['login'][2], infos['password'][1])
                 qfilter = qfilter.format(
-                    passfname = passfname,
-                    passhash = password)
+                    passfname=passfname,
+                    passhash=password)
             getq = LeGetQuery(infos['login'][0], qfilter,
-                field_list = [uid_fname], limit = 1)
+                              field_list=[uid_fname], limit=1)
             req = getq.execute()
             if len(req) == 1:
-                self.__set_authenticated(infos['login'][0],req[0][uid_fname])
+                self.__set_authenticated(infos['login'][0], req[0][uid_fname])
                 break
         if self.is_anonymous():
-            self.authentication_failure() #Security logging
-    
-    ##@brief Attempt to restore a session given a session token
+            self.authentication_failure()  # Security logging
+
+    # @brief Attempt to restore a session given a session token
     #@param token mixed : a session token
-    #@return Session datas (a dict)
+    #@return Session data (a dict)
     #@throw ClientAuthenticationFailure if token is not valid or not
-    #existing
+    # existing
     @classmethod
     def restore_session(cls, token):
         cls._assert_instance()
         if cls._instance.__session_token is not None:
             raise ClientAuthenticationError("Trying to restore a session, but \
-a session is allready started !!!")
+a session is already started !!!")
         try:
-            cls._instance.__datas = SessionHandler.restore(token)
+            cls._instance.__data = SessionHandler.restore(token)
             cls._instance.__session_token = token
         except ClientAuthenticationFailure:
-            logger.warning("Session restoring fails")
-        return copy.copy(cls._instance.datas)
-    
-    ##@brief Return the current session token or None
+            logger.warning("Session restoring failed")
+        return copy.copy(cls._instance.data)
+
+    # @brief Returns the current session token or None
     #@return A session token or None
     @classmethod
     def session_token(cls):
         cls._assert_instance()
         return cls._instance.__session_token
 
-   
-    ##@brief Delete current session
+    # @brief Deletes current session
     @classmethod
     def destroy(cls):
         cls._assert_instance()
         SessionHandler.destroy(cls._instance.__session_token)
         cls._instance.__session_token = None
-        cls._instance.__datas = dict()
-    
-    ##@brief Delete current client and save its session
+        cls._instance.__data = dict()
+
+    # @brief Deletes current client and saves its session
     @classmethod
     def clean(cls):
         if cls._instance.__session_token is not None:
-            SessionHandler.save(cls._instance.__session_token, cls._instance.__datas)
+            SessionHandler.save(cls._instance.__session_token, cls._instance.__data)
         if Client._instance is not None:
             del(Client._instance)
         Client._instance = None
-    
-    ##@brief Test wether a client is anonymous or logged in
+
+    # @brief Tests if a client is anonymous or logged in
     #@return True if client is anonymous
     @classmethod
     def is_anonymous(cls):
         return Client._instance.user() is None
-        
-    ##@brief Method to call on authentication failure
+
+    # @brief Method to be called on authentication failure
     #@throw ClientAuthenticationFailure
-    #@throw LodelFatalError if no Client child instance found
+    #@throw LodelFatalError if no Client child instance is found
     @classmethod
     def authentication_failure(cls):
         cls._generic_error(ClientAuthenticationFailure)
-    
-    ##@brief Method to call on authentication error
+
+    # @brief Method to be called on authentication error
     #@throw ClientAuthenticationError
-    #@throw LodelFatalError if no Client child instance found
+    #@throw LodelFatalError if no Client child instance is found
     @classmethod
-    def authentication_error(cls, msg = "Unknow error"):
+    def authentication_error(cls, msg="Unknow error"):
         cls._generic_error(ClientAuthenticationError, msg)
 
-    ##@brief Method to call on permission denied error
+    # @brief Method to be called on permission denied error
     #@throw ClientPermissionDenied
-    #@throw LodelFatalError if no Client child instance found
+    #@throw LodelFatalError if no Client child instance is found
     @classmethod
-    def permission_denied_error(cls, msg = ""):
+    def permission_denied_error(cls, msg=""):
         cls._generic_error(ClientPermissionDenied, msg)
-    
-    ##@brief Generic error method
+
+    # @brief Generic error method
     #@see Client::authentication_failure() Client::authentication_error()
-    #Client::permission_denied_error()
-    #@throw LodelFatalError if no Client child instance found
+    # Client::permission_denied_error()
+    #@throw LodelFatalError if no Client child instance is found
     @classmethod
-    def _generic_error(cls, expt, msg = ""):
+    def _generic_error(cls, expt, msg=""):
         cls._assert_instance()
         raise expt(Client._instance, msg)
-    
-    ##@brief Assert that an instance of Client child class exists
-    #@throw LodelFataError if no instance of Client child class found
+
+    # @brief Asserts that an instance of Client child class exists
+    #@throw LodelFataError if no instance of Client child class is found
     @classmethod
     def _assert_instance(cls):
         if Client._instance is None:
             raise LodelFatalError("No client instance found. Abording.")
 
-    ##@brief Class method that fetches conf
+    # @brief Class method that fetches conf
     #
-    #This method populates Client._infos_fields . This attribute stores
-    #informations on login and password location (LeApi object & field)
+    # This method populates Client._infos_fields . This attribute stores
+    # informations on login and password location (LeApi object & field)
     @classmethod
     def fetch_settings(cls):
         LodelContext.expose_dyncode(globals(), 'dyncode')
         if cls._infos_fields is None:
             cls._infos_fields = list()
         else:
-            #Allready fetched
+            # Already fetched
             return
         infos = (
             Settings.auth.login_classfield,
                 if fdh.is_reference() and res_infos[1][0] in fdh.linked_classes():
                     link_field = fname
             if link_field is None:
-                #Unable to find link between login & password EmClasses
+                # Unable to find link between login & password EmClass
                 raise AuthenticationError("Unable to find a link between \
 login EmClass '%s' and password EmClass '%s'. Abording..." % (
                     res_infos[0][0], res_infos[1][0]))
         res_infos[0] = (res_infos[0][0], res_infos[0][1], link_field)
         cls._infos_fields.append(
-            {'login':res_infos[0], 'password':res_infos[1]})
+            {'login': res_infos[0], 'password': res_infos[1]})
 
-    ##@brief Set a user as authenticated and start a new session
+    # @brief Sets a user as authenticated and starts a new session
     #@param leo LeObject child class : the LeObject the user is stored in
     #@param uid str : uniq id (in leo)
     #@return None
     @classmethod
     def __set_authenticated(cls, leo, uid):
         cls._instance.__user = {'classname': leo.__name__, 'uid': uid, 'leoclass': leo}
-        #Store auth infos in session
-        cls._instance.__datas[cls._instance.__class__._AUTH_DATANAME] = copy.copy(cls._instance.__user)
-
+        # Store auth infos in session
+        cls._instance.__data[cls._instance.__class__._AUTH_DATANAME] = copy.copy(
+            cls._instance.__user)

lodel/editorial_model/components.py

         self.group = group
         super().__init__(display_name, help_text)
 
+    # @brief Returns the display_name of the component if it is not None, its uid else
     def __str__(self):
         if self.display_name is None:
             return str(self.uid)
         return str(self.display_name)
 
+    # @brief Returns a hash code for the component
     def d_hash(self):
         m = hashlib.md5()
         for data in (
 #@ingroup lodel2_em
 class EmClass(EmComponent):
 
-    # @brief Instanciate a new EmClass
+    # @brief Instanciates a new EmClass
     #@param uid str : uniq identifier
     #@param display_name MlString|str|dict : component display_name
     #@param abstract bool : set the class as asbtract if True
         self.pure_abstract = bool(pure_abstract)
         self.__datasource = datasources
         if not isinstance(datasources, str) and len(datasources) != 2:
-            raise ValueError("datasources arguement can be a single datasource\
+            raise ValueError("datasources argument can be a single datasource\
  name or two names in a tuple or a list")
         if self.pure_abstract:
             self.abtract = True
                 internal=True,
                 group=group)
 
-    # @brief Property that represent a dict of all fields (the EmField defined in this class and all its parents)
-    # @todo use Settings.editorialmodel.groups to determine wich fields should be returned
+    # @brief Property that represents a dict of all fields 
+    # (the EmField objects defined in this class and all their parents)
+    # @todo use Settings.editorialmodel.groups to determine which fields should be returned
     @property
     def __all_fields(self):
         res = dict()
     def datasource(self):
         return self.__datasource
 
-    # @brief Return the list of all dependencies
+    # @brief Returns the list of all dependencies
     #
-    # Reccursive parents listing
+    # Recursive parents listing
     @property
     def parents_recc(self):
         if len(self.parents) == 0:
         except KeyError:
             raise EditorialModelError("No such EmField '%s'" % uid)
 
-    # @brief Keep in __fields only fields contained in active groups
+    # @brief Keeps in __fields only fields contained in active groups
     def _set_active_fields(self, active_groups):
         if not Settings.editorialmodel.editormode:
             active_fields = []
             self.__fields = {fname: fdh for fname, fdh in self.__fields.items()
                              if fdh in active_fields}
 
-    # @brief Add a field to the EmClass
+    # @brief Adds a field to the EmClass
     # @param emfield EmField : an EmField instance
-    # @warning do not add an EmField allready in another class !
-    # @throw EditorialModelException if an EmField with same uid allready in this EmClass (overwritting allowed from parents)
+    # @warning do not add an EmField already in another class !
+    # @throw EditorialModelException if an EmField with same uid already in this EmClass (overwriting allowed from parents)
     # @todo End the override checks (needs methods in data_handlers)
     def add_field(self, emfield):
         assert_edit()
             parent_field = self.__all_fields[emfield.uid]
             if not emfield.data_handler_instance.can_override(parent_field.data_handler_instance):
                 raise AttributeError(
-                    "'%s' field override a parent field, but data_handles are not compatible" % emfield.uid)
+                    "'%s' field overrides a parent field, but data_handlers are not compatible" % emfield.uid)
         self.__fields[emfield.uid] = emfield
         return emfield
 
-    # @brief Create a new EmField and add it to the EmClass
+    # @brief Creates a new EmField and adds it to the EmClass
     # @param data_handler str : A DataHandler name
     # @param uid str : the EmField uniq id
     # @param **field_kwargs :  EmField constructor parameters ( see @ref EmField.__init__() )
 #@ingroup lodel2_em
 class EmField(EmComponent):
 
-    # @brief Instanciate a new EmField
+    # @brief Instanciates a new EmField
     # @param uid str : uniq identifier
     # @param display_name MlString|str|dict : field display_name
     # @param data_handler str : A DataHandler name
     def get_data_handler_cls(self):
         return copy.copy(self.data_handler_cls)
 
-    ##@brief Returne the uid of the emclass which contains this field
+    ##@brief Returns the uid of the emclass which contains this field
     def get_emclass_uid(self):
         return self._emclass.uid
 
 
 class EmGroup(MlNamedObject):
 
-    # @brief Create a new EmGroup
+    # @brief Creates a new EmGroup
     # @note you should NEVER call the constructor yourself. Use Model.add_group instead
     # @param uid str : Uniq identifier
     # @param depends list : A list of EmGroup dependencies
             for grp in depends:
                 if not isinstance(grp, EmGroup):
                     raise ValueError("EmGroup expected in depends argument but %s found" % grp)
-                self.add_dependencie(grp)
+                self.add_dependency(grp)
 
-    # @brief Returns EmGroup dependencie
-    # @param recursive bool : if True return all dependencies and their dependencies
+    # @brief Returns EmGroup dependencies
+    # @param recursive bool : if True returns all dependencies and their own dependencies
     # @return a dict of EmGroup identified by uid
     def dependencies(self, recursive=False):
         res = copy.copy(self.require)
         return res
 
     # @brief Returns EmGroup applicants
-    # @param recursive bool : if True return all dependencies and their dependencies
+    # @param recursive bool : if True returns all dependencies and their dependencies
     # @returns a dict of EmGroup identified by uid
     def applicants(self, recursive=False):
         res = copy.copy(self.required_by)
         return (self.__components).copy()
 
     # @brief Returns EmGroup display_name
-    #  @param lang str | None : If None return default lang translation
+    #  @param lang str | None : If None returns default lang translation
     #  @returns None if display_name is None, a str for display_name else
     def get_display_name(self, lang=None):
         name = self.display_name
         return name.get(lang)
 
     # @brief Returns EmGroup help_text
-    #  @param lang str | None : If None return default lang translation
+    #  @param lang str | None : If None returns default lang translation
     #  @returns None if display_name is None, a str for display_name else
     def get_help_text(self, lang=None):
         help = self.help_text
             return None
         return help.get(lang)
 
-    # @brief Add components in a group
+    # @brief Adds components in a group
     # @param components list : EmComponent instances list
     def add_components(self, components):
         assert_edit()
                     "Expecting components to be a list of EmComponent, but %s found in the list" % type(component))
         self.__components |= set(components)
 
-    # @brief Add a dependencie
-    # @param em_group EmGroup|iterable : an EmGroup instance or list of instance
-    def add_dependencie(self, grp):
+    # @brief Add a dependency
+    # @param em_group EmGroup|iterable : an EmGroup instance or list of instances
+    def add_dependency(self, grp):
         assert_edit()
         try:
             for group in grp:
-                self.add_dependencie(group)
+                self.add_dependency(group)
             return
         except TypeError:
             pass
 
         if grp.uid in self.require:
             return
-        if self.__circular_dependencie(grp):
+        if self.__circular_dependency(grp):
             raise EditorialModelError("Circular dependencie detected, cannot add dependencie")
         self.require[grp.uid] = grp
         grp.required_by[self.uid] = self
         self.required_by[grp.uid] = grp
         grp.require[self.uid] = self
 
-    # @brief Search for circular dependencie
+    # @brief Search for circular dependency
     # @return True if circular dep found else False
-    def __circular_dependencie(self, new_dep):
+    def __circular_dependency(self, new_dep):
         return self.uid in new_dep.dependencies(True)
 
     # @brief Search for circular applicant
         else:
             return self.display_name.get()
 
+    # @brief Computes a d-hash code for the EmGroup
+    # @return a string
     def d_hash(self):
 
         payload = "%s%s%s" % (

lodel/editorial_model/exceptions.py

 #-*- coding: utf-8 -*-
 
+## @package lodel.editorial_model.exceptions
+# This module contains the specific exceptions related to the EditorialModel Management.
+
+
+## @brief Raises an Editorial Model specific exception.
 class EditorialModelError(Exception):
     pass
 
 
+## @brief Tries to import the settings module.
+# @raise EditorialModelError
 def assert_edit():
     try:
         from lodel import Settings
-    except ImportError: #Very dirty, but don't know how to fix the tests
+    except ImportError:  # Very dirty, but don't know how to fix the tests
         return
     if not Settings.editorialmodel.editormode:
         raise EditorialModelError("EM is readonly : editormode is OFF")

lodel/editorial_model/model.py

         super().__init__(display_name, help_text)
 
     # @brief EmClass uids accessor
-    #@return a dict of emclasses
+    #@return a copy of the dict containing all emclasses of the model if uid is None
+    # else a copy the class with uid uid
     def all_classes(self, uid=None):
         if uid is None:
             return copy.copy(self.__classes)
             except KeyError:
                 raise EditorialModelException("EmClass not found : '%s'" % uid)
 
+    # @brief EmClass uids accessor
+    #@return the dict containing all emclasses of the model if uid is None
+    # else the class with uid uid
     def all_classes_ref(self, uid=None):
         if uid is None:
             return self.__classes
                 raise EditorialModelException("EmGroup not found : '%s'" % uid)
 
     # @brief active EmClass uids accessor
-    #@return a list of class uids
+    #@return a list of active class uids
     def active_classes_uids(self):
         return list(self.__active_classes.keys())
 
     # @brief EmGroups accessor
-    #@return a dict of groups
+    #@return a copy of the dict of the model's group if uid is None
+    # else a copy of the group with uniq id uid
     def all_groups(self, uid=None):
         if uid is None:
             return copy.copy(self.__groups)
                 raise EditorialModelException("EmGroup not found : '%s'" % uid)
 
     # @brief EmGroups accessor
-    #@return a dict of groups
+    #@return the dict of the model's group if uid is None
+    # else the group with uniq id uid
     def all_groups_ref(self, uid=None):
         if uid is None:
             return self.__groups
                 raise EditorialModelException("EmGroup not found : '%s'" % uid)
 
     # @brief active EmClass uids accessor
-    #@return a list of class uids
+    #@return a list of active group uids
     def active_groups_uids(self):
         return list(self.__active_groups.keys())
 
     #@param uid None | str : give this argument to get a specific EmClass
     #@return if uid is given returns an EmClass else returns an EmClass
     # iterator
-    #@todo use Settings.editorialmodel.groups to determine wich classes should
+    #@todo use Settings.editorialmodel.groups to determine which classes should
     # be returned
     def classes(self, uid=None):
         try:

lodel/editorial_model/translator/__init__.py

 ## @package lodel.editorial_model.translator Editorial model translators
 #
-# This package contains modules that provides a save and a load function able to load and save
-# lodel.editorial_model.model.EditorialModel
+# This package is dedicated to the translation of an EditorialModel as several formats like pickle files or XML files. \n
+# Each module provides save and load functions to read/write an lodel.editorial_model.model.EditorialModel object from and to a file.

lodel/editorial_model/translator/xmlfile.py

         'EmGroup'],
     'lodel.utils.mlstring': ['MlString']})
 
-##@package lodel.editorial_model.translator.xmlfile Translator module designed
-#to load & save EM in XML
+## @package lodel.editorial_model.translator.xmlfile
+# This module is a translator toolkit between and editorial model and an XML file.
 #
-# Structure of a xml file which represents an editorial model:
+# The XML file representing an editorial is composed by several nodes.
+#
+# @par \<name\>
+# The name of the model. It matches with the <b><em>name</em></b> field of the <b><em>EditorialModel class</em></b>
+#
+# @par \<description\>
+# This is the description of a composed element. Inside this node, we can have as many child node as there are languages in which it is translated. \n
+# Each translation is notified by a node, using the following scheme :
 # <ul>
-# <li>\<name\>: name of the model, field <b><em>name</em></b>  in class <b><em>EditorialModel</em></b> 
-# <li>\<description\>: field <b><em>description</em></b>  of a composed element, one for each language translation named 
-#               <ul><li>\<fre\> for french, 
-#               <li>\<eng\> for english,
-#               <li>\<esp\> for spanish,
-#               <li>\<ger\> for german</ul>
-# <li>\<classes\>: set of all <b><em>EmClass</em></b> in the model \n
-#    for each classe: \n
-#       \<class\><ul>
-#       <li>\<uid\>the class's id
-#       <li>\<display_name\> The name of the class, field <b><em>display_name</em></b>  of the <b><em>EmClass</em></b> , in different languages if they're available :
-#               <ul><li>\<fre\> for french, 
-#               <li>\<eng\> for english,
-#               <li>\<esp\> for spanish,
-#               <li>\<ger> for german</ul>
-#       <li>\<help_text\> Short explanation of the class's purpose, in different languages, as above
-#       <li>\<abstract\> True or False, field <b><em>abstract</em></b> of the <b><em>EmClass</em></b> 
-#       <li>\<pure_abstract\> True or False, field <b><em>pure_bastract</em></b> of the <b><em>EmClass</em></b>
-#       <li>\<group\><b><em>uid</em></b> of the group of the field <b><em>group</em></b> of the <b><em>EmClass</em></b>
-#       <li>\<fields\>: set of all the <b><em>EmField</em></b> of the <b><em>EmClass</em></b>\n
-#         for each field: \n
-#           \<field\>
-#               <ul><li>\<uid\> uid of the <b><em>EmField</em></b>
-#               <li>\<display_name\> field <b><em>display_name</em></b>  of the <b><em>EmField</em></b>, in different languages, as above
-#               <li>\<help_text\> Short explanation of the class's purpose, in different languages, as above
-#               <li>\<group\><b><em>uid</em></b> of the group of the field <b><em>group</em></b> of the <b><em>EmClass</em></b>
-#               <li>\<datahandler_name\> field <b><em>datahandler_name</em></b> of the Emfield, the name of a datahandler
-#               <li>\<datahandler_options\>, a list of xml items, each of them named with an option name and contains its value</ul></ul>
-# <li>\<groups\>: set of all the groups <b><em>EmGroup</em></b> in the model\n
-#    for each group:\n
-#       <ul><li>\<uid\> uid of the <b><em>EmField</em></b>
-#       <li>\<display_name\> field <b><em>display_name</em></b>  of the <b><em>EmField</em></b>, in different languages, as above
-#       <li>\<help_text\> Short explanation of the class's purpose, in different languages, as above
-#       <li>\<requires\> all uids of the <b><em>EmGroups</em></b> required by this group and which are in the fields <b><em>require</em></b>
-#       <li>\<components\> Set of all components of the <b><em>EmGroups</em></b>, representation of the field <b><em>__components</em></b> \n
-#         this item is splitted in two parts :\
-#           <ul><li>\<emfields\> all the emfields with, for each of them:\n
-#               \<emfield\> \n
-#                  <ul><li> \<uid\> <b><em>uid</em></b> of the <b><em>EmField</em></b></ul>
-#           <li>\<emclasses\> all the emclasses with, for each of them:\n
-#               \<emclass\> \n
-#                   <ul><li> \<uid\> <b><em>uid</em></b> of the <b><em>EmClass</em></b></ul></ul></ul>
-
-
-
-
+#   <li><b>\<fre\></b> : french
+#   <li><b>\<eng\></b> : english
+#   <li><b>\<esp\></b> : spanish
+#   <li><b>\<ger\></b> : german
+# </ul>
+#
+# @par \<classes\>
+# This node contains a set of all the <b><em>EmClass</em></b> classes we can find in the model, each represented by a <b>\<class\></b> child node.
+#
+# @par \<class\>
+# It is the representation of a single <b><em>EmClass</em></b> class. It is contained in the <b><em>\<classes\></em></b> node. It contains the following child nodes :
+# <ul>
+# <li><b>\<uid\></b> : The identifier of the class.
+# <li><b>\<display_name\></b> : The class' name, given by the <b><em>display_name</em></b> field of the <b><em>EmClass</em></b> class. This node contains the same language child nodes as the \<description\> node.
+# <li><b>\<help_text\></b> : A short description of the purpose of this class, using the same child nodes for each language, as above.
+# <li><b>\<abstract\></b> : Boolean node, with True or False as values, corresponding to the field <b><em>abstract</em></b> of the <b><em>EmClass</em></b> object.
+# <li><b>\<abstract\></b> : Boolean node, with True or False as values, corresponding to the field <b><em>pure_abstract</em></b> of the <b><em>EmClass</em></b> object.
+# <li><b>\<group\></b> : The unique identifier of the group stored in the <b><em>group</em></b> field of the <b><em>EmClass</em></b> object.
+# <li><b>\<fields\></b> : A set of all the <b><em>EmField</em></b> fields attached to an <b></em>EmClass</em></b> class. Each of them is represented by a <b>\<field\></b> child node.
+# </ul>
+#
+# @par \<field\>
+# This node is the XML representation of an <b><em>EmField</em></b> class. It contains the following child nodes :
+# <ul>
+# <li><b>\<uid\></b> : The identifier of the field.
+# <li><b>\<display_name\></b> : Displayed name, in different languages (same child nodes as above), corresponding to the <b><em>display_name</em></b> property of the <b><em>EmField</em></b>.
+# <li><b>\<help_text\></b> : Short explanation of the purpose of the field, in different languages (one child node for each translation, see above).
+# <li><b>\<group\></b> : <b><em>uid</em></b> of the group of the field <b><em>group</em></b> in the <b><em>EmField</em></b>
+# <li><b>\<datahandler_name\></b> : The name of the datahandler attached to this field (corresponds to the field <b><em>datahandler_name</em></b> of the Emfield)
+# <li><b>\<datahandler_options\></b> : A list of xml items, each of them named with an option name and containing its value
+# </ul>
+#
+# @par \<groups\>
+# This node contains a set of all the groups in the model (represented by <b><em>EmGroup</em></b> objects) with a <b>\<group\></b> child node for each one.
+#
+# @par \<group\>
+# Represents a single group. This node contains the following child nodes :
+# <ul>
+# <li><b>\<uid\></b> : unique id of the <b><em>EmField</em></b>.
+# <li><b>\<display_name\></b> : Corresponds to the <b><em>display_name</em></b>  property of the <b><em>EmField</em></b>, in different languages (see above)
+# <li><b>\help_text\></b> : Short explanation of the group's purpose, in different languages (see above)
+# <li><b>\<requires\></b> : All the unique identifiers of the <b><em>EmGroups</em></b> required by this group and which are in the fields <b><em>require</em></b>.
+# <li><b>\<components\></b> : A set of all components of the <b><em>EmGroups</em></b>, representation of the field <b><em>__components</em></b>. This node is splitted in two parts :
+#     <ul>
+#         <li><b>\<emfields\></b> : all the emfields with, for each of them:\n
+#               <b>\<emfield\></b> \n
+#                  <b>\<uid\></b> : <b><em>uid</em></b> of the <b><em>EmField</em></b>
+#           <li><b>\<emclasses\></b> : all the emclasses with, for each of them:\n
+#               <b>\<emclass\></b> \n
+#                  <b>\<uid\></b> : <b><em>uid</em></b> of the <b><em>EmClass</em></b>
+#     </ul>
+# </ul>
 
 
-##@brief Saves a model in a xml file
+## @brief Saves a model in a XML file
 # @param model EditorialModel : the model to save
-# @param filename str|None : if None display on stdout else writes in the file filename
-
+# @param kwargs dict : additional options.
+#                     - filename str|None : if None display on stdout else writes in the file filename
 def save(model, **kwargs):
     Em = etree.Element("editorial_model")
     em_name = etree.SubElement(Em, 'name')
         outfile.close()
     
     
-##@brief Writes a representation of a MlString in xml
-# @param etree : the xml object
-# @param elem : the element which represents a MlString
-# @param mlstr : the mlstr to write
+## @brief Writes a representation of a MlString in XML
+# @param etree Element : the XML object
+# @param elem Element : the element which represents a MlString
+# @param mlstr MlString: the mlstr to write
 def write_mlstring_xml(etree, elem, mlstr):
     for lang in mlstr.values:
         ss_mlstr = etree.SubElement(elem,lang)
         ss_mlstr.text = mlstr.get(lang)
         
-##@brief Writes the definition of a datahandler in xml
+## @brief Writes the definition of a datahandler in xml
 # @param etree : the xml object
-# @param elem : the element which defines a datahandler
-# @param dhdl_name : the name of the datahandler
+# @param elem Element : the element which defines a datahandler
+# @param dhdl_name str : the name of the datahandler
 # @param kwargs : the options of the datahandler
 def write_datahandler_xml(etree, elem, dhdl_name, **kwargs):
     dhdl = etree.SubElement(elem,'datahandler_name')
                     opt_val = str(argu)
         arg.text = opt_val
         
-##@brief Writes a representation in xml of a EmField
+## @brief Writes a representation in xml of a EmField
 # @param etree : the xml object
-# @param elem : the element for the EmField
-# @param uid : the uid of the EmField
-# @param name : the name of the field
-# @param help_text : explanations of the EmField
-# @param group_uid : the uid of a group, can be None
-# @datahandler_name
-# @**kwargs : options of the datahandler
+# @param elem Element: the element for the EmField
+# @param uid str : the uid of the EmField
+# @param name str : the name of the field
+# @param help_text MlString: explanations of the EmField
+# @param group str|None: the uid of a group, can be None
+# @param datahandler_name str: Name of the datahandler attached to the field
+# @param **kwargs dict : options of the datahandler
 def write_emfield_xml(etree, elem, uid, name, help_text, group, datahandler_name, **kwargs):
     emfield = etree.SubElement(elem,'field')
     emfield_uid = etree.SubElement(emfield, 'uid')
 
 ##@brief Writes a representation of a EmGroup in xml
 # @param etree : the xml object
-# @param elem : the element for the EmGroup
-# @param name  : the name of the group
-# @param help_text : explanations of the EmGroup
-# @param requires : a list of the group's uids whose this group depends
+# @param elem Element : the element for the EmGroup
+# @param uid str : the uid of the EmGroup
+# @param name str : the name of the group
+# @param help_text MlString : explanations of the EmGroup
+# @param requires list : a list of the group's uids whose this group depends
+# @param components list : a list of the EmComponent objects contained in the group
 def write_emgroup_xml(etree, elem, uid, name, help_text, requires, components):
     emgroup = etree.SubElement(elem, 'group')
     emgroup_uid = etree.SubElement(emgroup, 'uid')
             em_group_comp_cls_ins = etree.SubElement(emgroup_comp_cls, 'emclass')
             em_group_comp_cls_ins.text = component.uid
 
-##@brief Writes a representation of a EmClass in xml
-# @param etree : the xml object
-# @param elem : the element for the EmClass
-# @param name  : the name of the group
-# @param help_text : explanations of the EmClass
-# @param fields : a dict
-# @param parents : a list of EmClass uids
-# @param abstract : a boolean
-# @param pure_abstract : a boolean
+## @brief Writes a representation of a EmClass in XML
+# @param etree : the XML object
+# @param elem Element : the element for the EmClass
+# @param uid str : the unique identifier of the EmClass
+# @param name str : the name of the group
+# @param help_text MlString : explanations of the EmClass
+# @param fields dict : a dict representing all the fields of the class
+# @param parents list : a list of the EmClass uids of this class' parents
+# @param abstract bool : a boolean
+# @param pure_abstract bool : a boolean
 def write_emclass_xml(etree, elem, uid, name, help_text, group, fields, parents, abstract = False, pure_abstract = False):
     emclass = etree.SubElement(elem, 'class')
     emclass_uid  = etree.SubElement(emclass, 'uid')
     emclass_parents = etree.SubElement(emclass, 'parents')
     emclass_parents.text = ",".join(parents_list)
 
-##@brief Loads a model from a xml file
-# @param model EditorialModel : the model to load
+## @brief Loads a model from a XML file
+# @param filename str : The file from which the editorial model will be loaded
 # @return a new EditorialModel object
 def load(filename):
-
     Em = etree.parse(filename)
     emodel = Em.getroot()
     name = emodel.find('name')
             grp = model.add_group(grp)
     return model
 
-##@brief Creates a EmClass from a xml description
-# @param elem : the element which represents the EmClass
-# @param model  : the model which will contain the new class
+
+## @brief Creates a EmClass from a xml description
+# @param model EditorialModel : the model which will contain the new class
+# @param elem Element: the element which represents the EmClass
 # @return a new EmClass object
 def load_class_xml(model, elem):
     uid = elem.find('uid').text
             
     return emclass
     
-##@brief Creates a EmField from a xml description
-#@param elem : the element which represents the EmField
-#@param model  : the model which will contain the new field
-#@param emclass EmClass : the EmClass of the field
-#@return a new EmField object
+## @brief Creates a EmField from a XML description
+# @param model EditorialModel: the model which will contain the new field
+# @param elem Element : the element which represents the EmField
+# @param emclass EmClass : the EmClass of the field
+# @return a new EmField object
 def load_field_xml(model, elem, emclass):
     uid = elem.find('uid').text
     if elem.find('display_name').text is None:
     
     return emfield
 
-##@brief Returns datahandler options from a xml description
-# @param elem : the element which represents the datahandler
-# @param model  : the model which will contain the new field
-# @return datahandler options
+
+## @brief Returns datahandler options from a XML description
+# @param elem Element : the element which represents the datahandler
+# @param model EditorialModel : the model which will contain the new field
+# @return dict
 def load_dhdl_options_xml(model, elem):
     dhdl_options=dict()
     for opt in elem:
     return dhdl_options
              
     
-##@brief Creates a EmGroup from a xml description
-# @param elem : the element which represents the EmGroup
-# @param model  : the model which will contain the new group
-# @return a new EmGroup object
+## @brief Creates a EmGroup from a XML description
+# @param model EditorialModel : the model which will contain the new group
+# @param elem Element : the element which represents the EmGroup
+# @return EmGroup
 def load_group_xml(model, elem):
     uid = elem.find('uid')
     
         group = model.all_groups_ref(uid.text)
         group.display_name = name
         group.help_text = help_text
-        group.add_dependencie(requires)
+        group.add_dependency(requires)
     else:
         group = EmGroup(uid.text, requires, name, help_text)
 
     group.add_components(comp)     
     return group
 
-##@brief Constructs a MlString from a xml description
-# @param elem : the element which represents the MlString
-# @param model  : the model which will contain the new group
-# @return a new MlString object
+## @brief Constructs a MlString from a XML description
+# @param elem Element : the element which represents the MlString
+# @return MlString
 def load_mlstring_xml(elem):
     mlstr = dict()
     for lang in elem:

lodel/leapi/datahandlers/datas.py

 #-*- coding: utf-8 -*-
+
+## @package lodel.leapi.datahandlers.datas
+# This module contains specific datahandlers extending the basic ones from the lodel.leapi.datahandlers.datas_base module.
+
+
 import warnings
 import inspect
 import re
                          'LodelFatalError', 'DataNoneValid', 'FieldValidationError']})
 
 
-##@brief Data field designed to handle formated strings
+## @brief Data field designed to handle formated strings
 class FormatString(Varchar):
 
-    help = 'Automatic string field, designed to use the str % operator to \
-build its content'
+    help = 'Automatic string field, designed to use the str % operator to build its content'
     base_type = 'char'
     
-    ##@brief Build its content with a field list and a format string
-    # @param format_string str
-    # @param field_list list : List of field to use
-    # @param **kwargs
+    ## @brief Constructor
+    # @param _field_list list : List of fields to use
+    # @param _format_string str : formatted string
+    # @param **kwargs : additional options
     def __init__(self, format_string, field_list, **kwargs):
         self._field_list = field_list
         self._format_string = format_string
         super().__init__(internal='automatic', **kwargs)
 
+    ## @brief constructs the formatted string data
+    # The string can be truncated depending on the maximum length defined for this field.
+    #
+    # @param emcomponent EmComponent
+    # @param fname str
+    # @param datas dict
+    # @param cur_value str
+    # @return str
     def _construct_data(self, emcomponent, fname, datas, cur_value):
         ret = self._format_string % tuple(
             datas[fname] for fname in self._field_list)
             warnings.warn("Format field overflow. Truncating value")
             ret = ret[:self.max_length]
         return ret
-    
-##@brief Varchar validated by a regex
+
+
+## @brief Varchar validated by a regex
 class Regex(Varchar):
 
     help = 'String field validated with a regex. Takes two options : \
 max_length and regex'
     base_type = 'char'
 
-    ##@brief A string field validated by a regex
-    # @param regex str : a regex string (passed as argument to re.compile())
+    ## @brief A string field validated by a regex
+    # @param regex str : a regex string (passed as argument to re.compile()), default value is an empty string
     # @param max_length int : the max length for this field (default : 10)
-    # @param **kwargs
+    # @param **kwargs : additional options
     def __init__(self, regex='', max_length=10, **kwargs):
         self.regex = regex
         self.compiled_re = re.compile(regex)  # trigger an error if invalid regex
         super(self.__class__, self).__init__(max_length=max_length, **kwargs)
 
-    ##@brief Check and cast value in appropriate type
-    #@param value *
-    #@throw FieldValidationError if value is unappropriate or can not be cast 
-    #@return value
+    ## @brief Check and cast value in appropriate type
+    # @param value *
+    # @throw FieldValidationError if value is unappropriate or can not be cast
+    # @return str
     def _check_data_value(self, value):
         value = super()._check_data_value(value)
         if not self.compiled_re.match(value) or len(value) > self.max_length:
             raise FieldValidationError(msg)
         return value
 
+    ## @brief checks if another datahandler can override this one
+    #
+    # @param data_handler Datahandler
+    # @return bool
     def can_override(self, data_handler):
         if not super().can_override(data_handler):
             return False
             return False
         return True
 
+
 ##@brief Handles uniq ID
 class UniqID(Integer):
 
     help = 'Fieldtype designed to handle editorial model UID'
     base_type = 'int'
 
-    ##@brief A uid field
-    # @param **kwargs
+    ## @brief A uid field
+    #
+    # @param **kwargs dict
     def __init__(self, **kwargs):
         kwargs['internal'] = 'automatic'
         super(self.__class__, self).__init__(primary_key = True, **kwargs)
 
+    ## @brief Constructs the field's data
+    # @param emcomponent EmComponent : Component corresponding to the field
+    # @param fname
+    # @param datas
+    # @param cur_value str : current value to use (is retrieved from the datasource if not given)
+    # @return str
+    # @remarks fname and datas are not used and should become non mandatory, cur_value should have a None default value
     def construct_data(self, emcomponent, fname, datas, cur_value):
         if cur_value is None:
             #Ask datasource to provide a new uniqID
             return emcomponent._ro_datasource.new_numeric_id(emcomponent)
         return cur_value
 
+
+## @brief Class representing a LeObject subclass
 class LeobjectSubclassIdentifier(Varchar):
     
     help = 'Datahandler designed to handle LeObject subclass identifier in DB'
     base_type = 'varchar'
 
+    ## @brief Constructor
+    # @param kwargs dict : additional options
+    # @throw RuntimeError
+    # @todo define the "internal" option that can be given in the kwargs, and document its meaning
     def __init__(self, **kwargs):
         if 'internal' in kwargs and not kwargs['internal']:
             raise RuntimeError(self.__class__.__name__+" datahandler can only \
 be internal")
         kwargs['internal'] = True
         super().__init__(**kwargs)
-    
+
+    ## @brief Returns the class' name
+    # @param emcomponent EmComponent : Component correponding to the field
+    # @param fname
+    # @param datas
+    # @param cur_value
+    # @return str
+    # @remarks fname, datas and cur_value should be given default values as they are not mandatory here.
     def construct_data(self, emcomponent, fname, datas, cur_value):
         cls = emcomponent
         if not inspect.isclass(emcomponent):
         return cls.__name__
 
 
-##@brief Data field designed to handle concatenated fields
+## @brief Data field designed to handle concatenated fields
 class Concat(FormatString):
     help = 'Automatic strings concatenation'
     base_type = 'char'
     
-    ##@brief Build its content with a field list and a separator
-    # @param field_list list : List of field to use
+    ## @brief Build its content with a field list and a separator
+    # @param field_list list : List of fields to concatenate
     # @param separator str
     # @param **kwargs    
     def __init__(self, field_list, separator=' ', **kwargs):
                          **kwargs)
 
 
+## @brief Datahandler managing a password
 class Password(Varchar):
     help = 'Handle passwords'
     base_type = 'password'
     pass
 
-
+## @brief Datahandler turning a string into a list
 class VarcharList(Varchar):
     help = 'DataHandler designed to make a list out of a string.'
     base_type = 'varchar'
-    
+
+    ## @brief Constructor
+    # @param delimiter str : default value is a whitespace character
+    # @param **kwargs : additional options
+    # @throw LodelException : this exception is raised when the delimiter is not a string
     def __init__(self, delimiter=' ', **kwargs):
         if not isinstance(delimiter, str):
             raise LodelException("The delimiter has to be a string, %s given" % type(delimiter))
         self.delimiter = str(delimiter)
         super().__init__(**kwargs)
 
+    ## @brief Constructs the field's data
+    # @param emcomponent EmComponent
+    # @param fname
+    # @param datas
+    # @param cur_value : current value to use
+    # @return list
+    # @remarks emcomponent, fname and datas should be given a default value as they seem to be non mandatory
     def construct_data(self, emcomponent, fname, datas, cur_value):
         result = cur_value.split(self.delimiter)
         return result

lodel/leapi/datahandlers/exceptions.py

+## @brief Exception classes for datahandlers
+
 class LodelDataHandlerException(Exception):
     pass
 

lodel/leapi/datahandlers/references.py

                          'LodelFatalError', 'DataNoneValid',
                          'FieldValidationError']})
 
-
+## @brief Child class of SingleRef. The object referenced must exist
 class Link(SingleRef):
     pass
 
 
 ## @brief Child class of MultipleRef where references are represented in the form of a python list
+# All the objects referenced must exist
 class List(MultipleRef):
 
     ## @brief instanciates a list reference
 
 ## @brief This Reference class is designed to handler hierarchy with some constraint
 class Hierarch(MultipleRef):
-    
+
     directly_editable = False
 
     ## @brief Instanciate a data handler handling hierarchical relation with constraints
     # @param back_reference tuple : Here it is mandatory to have a back ref (like a parent field)
     # @param max_depth int | None :  limit of depth
     # @param max_childs int | Nine : maximum number of childs by nodes
+    # @param kwargs : 
+    #   - allowed_classes list | None : list of allowed em classes if None no restriction
+    #   - internal bool : if False, the field is not internal
     def __init__(self, back_reference, max_depth=None, max_childs=None, **kwargs):
         super().__init__(back_reference=back_reference,
                          max_depth=max_depth,

lodel/leapi/exceptions.py

 LodelContext.expose_modules(globals(), {
     'lodel.exceptions': ['LodelExceptions', 'LodelException']})
 
+##@brief Handles LeApi error
 class LeApiError(LodelException):
     pass
 
     pass
 
 
-##@brief When an error concerns a datas
+##@brief When an error concerns a data
 class LeApiDataCheckError(LeApiError):
     pass
 
-
+##@brief Handles LeApi data errors
 class LeApiDataCheckErrors(LodelExceptions, LeApiError):
     pass
 
 
+##@brief Handles leapi query errors
 class LeApiQueryError(LeApiError):
     pass
 
 
-##@brief Handles mulitple query errors
+##@brief Handles multiple query errors
 class LeApiQueryErrors(LodelExceptions, LeApiQueryError):
     pass
-

lodel/leapi/lefactory.py

 #-*- coding: utf-8 -*-
 
-import os, os.path
+import os
+import os.path
 import functools
 
 from lodel.context import LodelContext
 LodelContext.expose_modules(globals(), {
     'lodel.editorial_model.components': ['EmComponent', 'EmClass', 'EmField',
-        'EmGroup'],
+                                         'EmGroup'],
     'lodel.leapi.leobject': ['LeObject'],
     'lodel.leapi.datahandlers.base_classes': ['DataHandler'],
     'lodel.logger': 'logger'})
 
-##@brief Generate python module code from a given model
+# @brief Generates python module code from a given model
 # @param model lodel.editorial_model.model.EditorialModel
+
+
 def dyncode_from_em(model):
-    
+
     # Generation of LeObject child classes code
-    cls_code, modules, bootstrap_instr = generate_classes(model)
+    cls_code, bootstrap_instr = generate_classes(model)
 
     # Header
     imports = """from lodel.context import LodelContext
     'lodel.leapi.datahandlers.base_classes': ['DataField'],
     'lodel.plugin.hooks': ['LodelHook']})
 """
-    for module in modules:
-        imports += "import %s\n" % module
-    
-    class_list = [ LeObject.name2objname(cls.uid) for cls in get_classes(model) ]
+    # generates the list of all classes in the editorial model
+    class_list = [LeObject.name2objname(cls.uid) for cls in get_classes(model)]
 
     # formating all components of output
     res_code = """#-*- coding: utf-8 -*-
 dynclasses_dict = {class_dict}
 {common_code}
 """.format(
-            imports = imports,
-            classes = cls_code,
-            bootstrap_instr = bootstrap_instr,
-            class_list = '[' + (', '.join([cls for cls in class_list]))+']',
-            class_dict = '{' + (', '.join([ "'%s': %s" % (cls, cls)
-                for cls in class_list]))+'}',
-            common_code = common_code(),
+        imports=imports,
+        classes=cls_code,
+        bootstrap_instr=bootstrap_instr,
+        class_list='[' + (', '.join([cls for cls in class_list])) + ']',
+        class_dict='{' + (', '.join(["'%s': %s" % (cls, cls)
+                                     for cls in class_list])) + '}',
+        common_code=common_code(),
     )
     return res_code
 
-##@brief Return the content of lodel.leapi.lefactory_common
+# @brief Returns the content of lodel.leapi.lefactory_common
+#
+# @return a string
+
+
 def common_code():
     res = ""
     fname = os.path.dirname(__file__)
             if not line.startswith('#-'):
                 res += line
     return res
-    
 
-##@brief return A list of EmClass sorted by dependencies
+
+# @brief return A list of EmClass sorted by dependencies
 #
-# The first elts in the list depends on nothing, etc.
+# The first elts in the list depend on nothing, etc.
+# @param a list of Emclass instances to be sorted
 # @return a list of EmClass instances
 def emclass_sorted_by_deps(emclass_list):
     def emclass_deps_cmp(cls_a, cls_b):
         return len(cls_a.parents_recc) - len(cls_b.parents_recc)
-    ret = sorted(emclass_list, key = functools.cmp_to_key(emclass_deps_cmp))
+    ret = sorted(emclass_list, key=functools.cmp_to_key(emclass_deps_cmp))
     return ret
 
-##@brief Returns a list of EmClass that will be represented as LeObject child classes
+# @brief Returns a list of EmClass instances that will be represented as LeObject child classes
+# @param model : an EditorialModel instance
+# @return a list of EmClass instances
+
+
 def get_classes(model):
-    return [ cls for cls in emclass_sorted_by_deps(model.classes()) if not cls.pure_abstract ]
+    return [cls for cls in emclass_sorted_by_deps(model.classes()) if not cls.pure_abstract]
+
+# @brief Given an EmField returns the data_handler constructor suitable for dynamic code
+# @param a EmField instance
+# @return a string
+
 
-##@brief Given an EmField returns the data_handler constructor suitable for dynamic code
 def data_handler_constructor(emfield):
     #dh_module_name = DataHandler.module_name(emfield.data_handler_name)+'.DataHandler'
     get_handler_class_instr = 'DataField.from_name(%s)' % repr(emfield.data_handler_name)
     for name, val in emfield.data_handler_options.items():
         if name == 'back_reference' and isinstance(val, tuple):
             options.append('{optname}: ({leo_name}, {fieldname})'.format(
-                optname = repr(name),
-                leo_name = LeObject.name2objname(val[0]),
-                fieldname = repr(val[1]),))
+                optname=repr(name),
+                leo_name=LeObject.name2objname(val[0]),
+                fieldname=repr(val[1]),))
         else:
-            options.append(repr(name)+': '+forge_optval(val))
+            options.append(repr(name) + ': ' + forge_optval(val))
 
     return '{handler_instr}(**{{ {options} }})'.format(
-                                                        handler_instr = get_handler_class_instr,
-                                                        options = ', '.join(options))
-            
-##@brief Return a python repr of option values
+        handler_instr=get_handler_class_instr,
+        options=', '.join(options))
+
+# @brief Return a python repr of option values
+# @param A value of any type which represents option
+# @return a string
+
+
 def forge_optval(optval):
     if isinstance(optval, dict):
-        return '{' + (', '.join( [ '%s: %s' % (repr(name), forge_optval(val)) for name, val in optval.items()])) + '}'
+        return '{' + (', '.join(['%s: %s' % (repr(name), forge_optval(val)) for name, val in optval.items()])) + '}'
 
     if isinstance(optval, (set, list, tuple)):
         return '[' + (', '.join([forge_optval(val) for val in optval])) + ']'
-        
+
     if isinstance(optval, EmField):
         return "{leobject}.data_handler({fieldname})".format(
-                leobject = LeObject.name2objname(optval._emclass.uid),
-                fieldname = repr(optval.uid)
-            )
-    elif isinstance(optval, EmClass):
+            leobject=LeObject.name2objname(optval._emclass.uid),
+            fieldname=repr(optval.uid)
+        )
+    if isinstance(optval, EmClass):
         return LeObject.name2objname(optval.uid)
-    else:
-        return repr(optval)
 
-##@brief Generate dyncode from an EmClass
-# @param model EditorialModel : 
-# @todo delete imports. It is never use, consequently changed return parameters.
+    return repr(optval)
+
+# @brief Generate dyncode from an EmClass
+# @param model EditorialModel :
 # @return a tuple with emclass python code, a set containing modules name to import, and a list of python instruction to bootstrap dynamic code, in this order
+
+
 def generate_classes(model):
     res = ""
-    imports = list()
+
     bootstrap = ""
     # Generating field list for LeObjects generated from EmClass
     for em_class in get_classes(model):
         logger.info("Generating a dynamic class for %s" % em_class.uid)
-        uid = list()        # List of fieldnames that are part of the EmClass primary key
-        parents = list()    # List of parents EmClass
-        # Determine pk
+        uid = list()        # List for fieldnames that are part of the EmClass primary key
+        parents = list()    # List for em_class's parents
+        # Determines primary key
         for field in em_class.fields():
             if field.data_handler_instance.is_primary_key():
                 uid.append(field.uid)
-        # Determine parent for inheritance
+        # Determines parentsfor inheritance
         if len(em_class.parents) > 0:
             for parent in em_class.parents:
-               parents.append(LeObject.name2objname(parent.uid))
+                parents.append(LeObject.name2objname(parent.uid))
         else:
             parents.append('LeObject')
         datasource_name = em_class.datasource
-        
-        # Dynamic code generation for LeObject childs classes
+
+        # Dynamic code generation for LeObject child classes
         em_cls_code = """
 class {clsname}({parents}):
     _abstract = {abstract}
     _child_classes = None
 
 """.format(
-    clsname = LeObject.name2objname(em_class.uid),
-    parents = ', '.join(parents),
-    abstract = 'True' if em_class.abstract else 'False',
-    uid_list = repr(uid),
-    datasource_name = repr(datasource_name),
-)
+            clsname=LeObject.name2objname(em_class.uid),
+            parents=', '.join(parents),
+            abstract='True' if em_class.abstract else 'False',
+            uid_list=repr(uid),
+            datasource_name=repr(datasource_name),
+        )
         res += em_cls_code
         # Dyncode fields bootstrap instructions
         child_classes = model.get_class_childs(em_class.uid)
             child_classes = 'tuple()'
         else:
             child_classes = '(%s,)' % (', '.join(
-                [ LeObject.name2objname(emcls.uid) for emcls in child_classes]))
+                [LeObject.name2objname(emcls.uid) for emcls in child_classes]))
         bootstrap += """{classname}._set__fields({fields})
 {classname}._child_classes = {child_classes}
 """.format(
-    classname = LeObject.name2objname(em_class.uid),
-    fields = '{' + (', '.join(['\n\t%s: %s' % (repr(emfield.uid),data_handler_constructor(emfield)) for emfield in em_class.fields()])) + '}',
-    child_classes = child_classes,
-)
+            classname=LeObject.name2objname(em_class.uid),
+            fields='{' + (', '.join(['\n\t%s: %s' % (repr(emfield.uid),
+                                                     data_handler_constructor(emfield)) for emfield in em_class.fields()])) + '}',
+            child_classes=child_classes,
+        )
     bootstrap += "\n"
-    return res, set(imports), bootstrap
-    
+    return res, bootstrap

lodel/leapi/lefactory_common.py

 #- All lines that begins with #- will be deleted from dynamically generated
 #- code...
 
-##@brief Return a dynamically generated class given it's name
+##@brief Returns a dynamically generated class given its name
 #@param name str : The dynamic class name
 #@return False or a child class of LeObject
 def name2class(name):
     return dynclasses_dict[name]
 
 
-##@brief Return a dynamically generated class given it's name
+##@brief Returns a dynamically generated class given its name
 #@note Case insensitive version of name2class
 #@param name str
 #@return False or a child class of LeObject
     return new_dict[name]
 
 
-##@brief Trigger dynclasses datasources initialisation
+##@brief Triggers dynclasses datasources initialisation
 @LodelHook("lodel2_plugins_loaded")
 def lodel2_dyncode_datasources_init(self, caller, payload):
     for cls in dynclasses:
         cls._init_datasources()
     LodelContext.expose_modules(globals(), {'lodel.plugin.hooks': ['LodelHook']})
     LodelHook.call_hook("lodel2_dyncode_loaded", __name__, dynclasses)
-

lodel/leapi/leobject.py

 #-*- coding: utf-8 -*-
 
+## @package lodel.leapi.leobject
+# This module is centered around the basic LeObject class, which is the main class for all the objects managed by lodel.
+
+
 import importlib
 import warnings
 import copy
     'lodel.plugin': ['Plugin', 'DatasourcePlugin'],
     'lodel.leapi.datahandlers.base_classes': ['DatasConstructor', 'Reference']})
 
-# @brief Stores the name of the field present in each LeObject that indicates
-# the name of LeObject subclass represented by this object
+## @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"
 
-# @brief Wrapper class for LeObject getter & setter
+
+## @brief Wrapper class for LeObject getter & setter
 #
-# This class intend to provide easy & friendly access to LeObject fields values
-# without name collision problems
+# This class intend to provide easy & friendly access to LeObject fields values without name collision problems
 # @note Wrapped methods are : LeObject.data() & LeObject.set_data()
-
-
 class LeObjectValues(object):
 
-    # @brief Construct a new LeObjectValues
     # @param fieldnames_callback method
     # @param set_callback method : The LeObject.set_datas() method of corresponding LeObject class
     # @param get_callback method : The LeObject.get_datas() method of corresponding LeObject class
         self._setter = set_callback
         self._getter = get_callback
 
-    # @brief Provide read access to datas values
+    ## @brief Provides read access to datas values
     # @note Read access should be provided for all fields
     # @param fname str : Field name
+    # @return method
     def __getattribute__(self, fname):
         getter = super().__getattribute__('_getter')
         return getter(fname)
 
-    # @brief Provide write access to datas values
+    ## @brief Provides write access to datas values
     # @note Write acces shouldn't be provided for internal or immutable fields
     # @param fname str : Field name
     # @param fval * : the field value
+    # @return method
     def __setattribute__(self, fname, fval):
         setter = super().__getattribute__('_setter')
         return setter(fname, fval)
 
 
+## @brief Represents a handled object in Lodel.
 class LeObject(object):
 
-    # @brief boolean that tells if an object is abtract or not
+    ## @brief boolean that tells if an object is abtract or not
     _abstract = None
-    # @brief A dict that stores DataHandler instances indexed by field name
+    ## @brief A dict that stores DataHandler instances indexed by field name
     _fields = None
-    # @brief A tuple of fieldname (or a uniq fieldname) representing uid
+    ## @brief A tuple of fieldname (or a uniq fieldname) representing uid
     _uid = None
-    # @brief Read only datasource ( see @ref lodel2_datasources )
+    ## @brief Read only datasource ( see @ref lodel2_datasources )
     _ro_datasource = None
-    # @brief Read & write datasource ( see @ref lodel2_datasources )
+    ## @brief Read & write datasource ( see @ref lodel2_datasources )
     _rw_datasource = None
-    # @brief Store the list of child classes
+    ## @brief Store the list of child classes
     _child_classes = None
-    # @brief Name of the datasource plugin
+    ## @brief Name of the datasource plugin
     _datasource_name = None
 
     def __new__(cls, **kwargs):
-
         self = object.__new__(cls)
-        # @brief A dict that stores fieldvalues indexed by fieldname
+        ## @brief A dict that stores fieldvalues indexed by fieldname
         self.__datas = {fname: None for fname in self._fields}
-        # @brief Store a list of initianilized fields when instanciation not complete else store True
+        ## @brief Store a list of initianilized fields when instanciation not complete else store True
         self.__initialized = list()
-        # @brief Datas accessor. Instance of @ref LeObjectValues
+        ## @brief Datas accessor. Instance of @ref LeObjectValues
         self.d = LeObjectValues(self.fieldnames, self.set_data, self.data)
         for fieldname, fieldval in kwargs.items():
             self.__datas[fieldname] = fieldval
         self.__set_initialized()
         return self
 
-    # @brief Construct an object representing an Editorial component
     # @note Can be considered as EmClass instance
+    # @param **kwargs
+    # @throw NotImplementedError when the class being instanciated is noted as abstract and then should not be instanciated.
+    # @throw LeApiError in case of missing or invalid data.
     def __init__(self, **kwargs):
         if self._abstract:
             raise NotImplementedError(
     #   Fields datas handling methods   #
     #-----------------------------------#
 
-    # @brief Property method True if LeObject is initialized else False
+    ## @brief Property method True if LeObject is initialized else False
+    # @return bool
     @property
     def initialized(self):
         return self.__is_initialized
 
-    # @return The uid field name
+    ## @brief Returns the uid field name
+    # @return str
     @classmethod
     def uid_fieldname(cls):
         return cls._uid
 
-    # @brief Return a list of fieldnames
-    # @param include_ro bool : if True include read only field names
-    # @return a list of str
+    ## @brief Returns a list of fieldnames
+    # @param include_ro bool : if True includes the read only field names
+    # @return list of string
     @classmethod
     def fieldnames(cls, include_ro=False):
         if not include_ro:
         else:
             return list(cls._fields.keys())
 
+    ## @brief Returns a name, capitalizing the first character of each word
+    # @param name str
+    # @return str
     @classmethod
     def name2objname(cls, name):
         return name.title()
 
-    # @brief Return the datahandler asssociated with a LeObject field
-    # @param fieldname str : The fieldname
+    ## @brief Returns the datahandler asssociated with a LeObject field
+    # @param fieldname str : The field's name
     # @return A data handler instance
+    # @throw NameError when the given field name doesn't exist
     #@todo update class of exception raised
     @classmethod
     def data_handler(cls, fieldname):
             raise NameError("No field named '%s' in %s" % (fieldname, cls.__name__))
         return cls._fields[fieldname]
 
-    # @brief Getter for references datahandlers
-    #@param with_backref bool : if true return only references with back_references
-    #@return <code>{'fieldname': datahandler, ...}</code>
+    ## @brief Returns a dictionary containing the reference datahandlers
+    # @param with_backref bool : if true return only references with back_references
+    # @return dict : <code>{'fieldname': datahandler, ...}</code>
     @classmethod
     def reference_handlers(cls, with_backref=True):
         return {fname: fdh
                 if fdh.is_reference() and
                 (not with_backref or fdh.back_reference is not None)}
 
-    # @brief Return a LeObject child class from a name
+    ## @brief Returns a LeObject child class from a name
     # @warning This method has to be called from dynamically generated LeObjects
     # @param leobject_name str : LeObject name
     # @return A LeObject child class
-    # @throw NameError if invalid name given
+    # @throw NotImplementedError if the method is abstract (if we use the LeObject class)
+    # @throw LeApiError if an unexisting name is given
     @classmethod
     def name2class(cls, leobject_name):
         if cls.__module__ == 'lodel.leapi.leobject':
         except (AttributeError, TypeError):
             raise LeApiError("No LeObject named '%s'" % leobject_name)
 
+    ## @brief Checks if the class is abstract or not
+    # @return bool
     @classmethod
     def is_abstract(cls):
         return cls._abstract
 
-    # @brief Field data handler getter
-    #@param fieldname str : The field name
-    #@return A datahandler instance
-    #@throw NameError if the field doesn't exist
+    ## @brief Field data handler getter
+    # @param fieldname str : The field name
+    # @return A datahandler instance
+    # @throw NameError if the field doesn't exist
     @classmethod
     def field(cls, fieldname):
         try:
         except KeyError:
             raise NameError("No field named '%s' in %s" % (fieldname,
                                                            cls.__name__))
-    # @return A dict with fieldname as key and datahandler as instance
-
+    ## @brief Returns the fields' datahandlers as a dictionary
+    # @param include_ro bool : if True, includes the read-only fields (default value : False)
+    # @return dict
     @classmethod
     def fields(cls, include_ro=False):
         if include_ro:
             return {fname: cls._fields[fname] for fname in cls._fields\
                     if not cls._fields[fname].is_internal()}
 
-    # @brief Return the list of parents classes
+    ## @brief Return the list of parents classes
     #
-    #@note the first item of the list is the current class, the second is it's
-    # parent etc...
-    #@param cls
-    #@warning multiple inheritance broken by this method
-    #@return a list of LeObject child classes
-    #@todo multiple parent capabilities implementation
+    # @note the first item of the list is the current class, the second is its parent etc...
+    # @warning multiple inheritance broken by this method
+    # @return a list of LeObject child classes
+    # @todo multiple parent capabilities implementation
     @classmethod
     def hierarch(cls):
         res = [cls]
                 res.append(cur)
         return res
 
-    # @brief Return a tuple a child classes
-    #@return a tuple of child classes
+    ## @brief Returns a tuple of child classes
+    # @return tuple
     @classmethod
     def child_classes(cls):
         return copy.copy(cls._child_classes)
 
-    # @brief Return the parent class that is the "source" of uid
+    ## @brief Returns the parent class that defines the unique id
     #
-    # The method goal is to return the parent class that defines UID.
-    #@return a LeObject child class or false if no UID defined
+    # @return a LeObject child class or false if no UID defined
     @classmethod
     def uid_source(cls):
         if cls._uid is None or len(cls._uid) == 0:
             prev = pcls
         return prev
 
-    # @brief Initialise both datasources (ro and rw)
+    ## @brief Initialise both datasources (ro and rw)
     #
     # This method is used once at dyncode load to replace the datasource string
     # by a datasource instance to avoid doing this operation for each query
-    #@see LeObject::_init_datasource()
+    # @see LeObject::_init_datasource()
     @classmethod
     def _init_datasources(cls):
         if isinstance(cls._datasource_name, str):
             log_msg %= (ro_ds, cls.__name__)
             logger.debug(log_msg)
 
-    # @brief Return the uid of the current LeObject instance
-    #@return the uid value
-    #@warning Broke multiple uid capabilities
+    ## @brief Returns the uid of the current LeObject instance
+    # @return str
+    # @warning Broke multiple uid capabilities
     def uid(self):
         return self.data(self._uid[0])
 
-    # @brief Read only access to all datas
+    ## @brief Returns the value of a field
     # @note for fancy data accessor use @ref LeObject.g attribute @ref LeObjectValues instance
-    # @param field_name str : field name
-    # @return the Value
+    # @param field_name str : field's name
+    # @return the value
     # @throw RuntimeError if the field is not initialized yet
     # @throw NameError if name is not an existing field name
     def data(self, field_name):
                 "The field %s is not initialized yet (and have no value)" % field_name)
         return self.__datas[field_name]
 
-    # @brief Read only access to all datas
-    #@return a dict representing datas of current instance
+    ## @brief Returns a dictionary containing all the fields' values
+    # @return dict
     def datas(self, internal=False):
         return {fname: self.data(fname) for fname in self.fieldnames(internal)}
 
-    # @brief Datas setter
+    ## @brief Datas setter
     # @note for fancy data accessor use @ref LeObject.g attribute @ref LeObjectValues instance
-    # @param fname str : field name
+    # @param fname str : field's name
     # @param fval * : field value
     # @return the value that is really set
     # @throw NameError if fname is not valid
     # @throw AttributeError if the field is not writtable
+    # @throw LeApiErrors if the data check generates an error
     def set_data(self, fname, fval):
         if fname not in self.fieldnames(include_ro=False):
             if fname not in self._fields.keys():
             else:
                 self.__datas[fname] = val
 
-    # @brief Update the __initialized attribute according to LeObject internal state
+    ## @brief Updates the __initialized attribute according to LeObject internal state
     #
-    # Check the list of initialized fields and set __initialized to True if all fields initialized
+    # Checks the list of initialized fields and sets __initialized at True if all fields initialized
     def __set_initialized(self):
         if isinstance(self.__initialized, list):
             expected_fields = self.fieldnames(include_ro=False) + self._uid
             if set(expected_fields) == set(self.__initialized):
                 self.__is_initialized = True
 
-    # @brief Designed to be called when datas are modified
+    ## @brief Designed to be called when datas are modified
     #
-    # Make different checks on the LeObject given it's state (fully initialized or not)
+    # Makes different checks on the LeObject given it's state (fully initialized or not)
     # @return None if checks succeded else return an exception list
     def __check_modified_values(self):
         err_list = dict()
     #   Other methods    #
     #--------------------#
 
-    # @brief Temporary method to set private fields attribute at dynamic code generation
+    ## @brief Temporary method to set private fields attribute at dynamic code generation
     #
     # This method is used in the generated dynamic code to set the _fields attribute
     # at the end of the dyncode parse
     # @warning This method is deleted once the dynamic code loaded
-    # @param field_list list : list of EmField instance
     # @param cls
+    # @param field_list list : list of EmField instance
     @classmethod
     def _set__fields(cls, field_list):
         cls._fields = field_list
 
-    # @brief Check that datas are valid for this type
+    ## @brief Checks if the data is valid for this type
     # @param datas dict : key == field name value are field values
-    # @param complete bool : if True expect that datas provide values for all non internal fields
-    # @param allow_internal bool : if True don't raise an error if a field is internal
+    # @param complete bool : if True expects that values are provided for all non internal fields
+    # @param allow_internal bool : if True does not raise an error if a field is internal
     # @param cls
     # @return Checked datas
-    # @throw LeApiDataCheckError if errors reported during check
+    # @throw LeApiDataCheckErrors if errors are reported during check
     @classmethod
     def check_datas_value(cls, datas, complete=False, allow_internal=True):
         err_l = dict()  # Error storing
             raise LeApiDataCheckErrors("Error while checking datas", err_l)
         return checked_datas
 
-    # @brief Check and prepare datas
+    ## @brief Checks and prepares all the data
     #
     # @warning when complete = False we are not able to make construct_datas() and _check_data_consistency()
     #
     # @param datas dict : {fieldname : fieldvalue, ...}
-    # @param complete bool : If True you MUST give all the datas
-    # @param allow_internal : Wether or not interal fields are expected in datas
-    # @param cls
+    # @param complete bool : If True you MUST give all the datas (default value : False)
+    # @param allow_internal : Wether or not interal fields are expected in datas (default value : True)
     # @return Datas ready for use
     # @todo: complete is very unsafe, find a way to get rid of it
     @classmethod
             cls._check_datas_consistency(ret_datas)
         return ret_datas
 
-    # @brief Construct datas values
+    ## @brief Constructs datas values
     #
-    # @param cls
     # @param datas dict : Datas that have been returned by LeCrud.check_datas_value() methods
     # @return A new dict of datas
     # @todo IMPLEMENTATION
         }
         return ret
 
-    # @brief Check datas consistency
+    ## @brief Checks datas consistency
     # 
     # @warning assert that datas is complete
     # @param cls
     # @param datas dict : Datas that have been returned by LeCrud._construct_datas() method
-    # @throw LeApiDataCheckError if fails
+    # @throw LeApiDataCheckError in case of failure
     @classmethod
     def _check_datas_consistency(cls, datas):
         err_l = []
         if len(err_l) > 0:
             raise LeApiDataCheckError("Datas consistency checks fails", err_l)
 
-    # @brief Check datas consistency
+    ## @brief Checks data consistency
     # 
     # @warning assert that datas is complete
-    # @param cls
-    # @param datas dict : Datas that have been returned by LeCrud.prepare_datas() method
+    # @param datas dict : Data that have been returned by prepare_datas() method
     # @param type_query str : Type of query to be performed , default value : insert
     @classmethod
     def make_consistency(cls, datas, type_query='insert'):
         for fname, dh in cls._fields.items():
             ret = dh.make_consistency(fname, datas, type_query)
 
-    # @brief Add a new instance of LeObject
-    # @return a new uid en case of success, False otherwise
+    ## @brief Adds a new instance of LeObject
+    # @param datas dict : LeObject's data
+    # @return a new uid in case of success, False otherwise
     @classmethod
     def insert(cls, datas):
         query = LeInsertQuery(cls)
         return query.execute(datas)
 
-    # @brief Update an instance of LeObject
+    ## @brief Update an instance of LeObject
     #
-    #@param datas : list of new datas
+    # @param datas : list of new datas
+    # @return LeObject
     def update(self, datas=None):
         datas = self.datas(internal=False) if datas is None else datas
         uids = self._uid
 
         return result
 
-    # @brief Delete an instance of LeObject
+    ## @brief Delete an instance of LeObject
     #
-    #@return 1 if the objet has been deleted
+    # @return 1 if the objet has been deleted
     def delete(self):
         uids = self._uid
         query_filter = list()
 
         return result
 
-    # @brief Delete instances of LeObject
-    #@param query_filters list
-    #@returns the number of deleted items
+    ## @brief Deletes instances of LeObject
+    # @param query_filters list
+    # @return the number of deleted items
     @classmethod
     def delete_bundle(cls, query_filters):
         deleted = 0
             deleted += result
         return deleted
 
-    # @brief Get instances of LeObject
+    ## @brief Gets instances of LeObject
     #
-    #@param query_filters dict : (filters, relational filters), with filters is a list of tuples : (FIELD, OPERATOR, VALUE) )
-    #@param field_list list|None : list of string representing fields see
-    #@ref leobject_filters
-    #@param order list : A list of field names or tuple (FIELDNAME,[ASC | DESC])
-    #@param group list : A list of field names or tuple (FIELDNAME,[ASC | DESC])
-    #@param limit int : The maximum number of returned results
-    #@param offset int : offset
-    #@return a list of items (lists of (fieldname, fieldvalue))
+    # @param query_filters dict : (filters, relational filters), with filters is a list of tuples : (FIELD, OPERATOR, VALUE) )
+    # @param field_list list|None : list of string representing fields see
+    # @ref leobject_filters
+    # @param order list : A list of field names or tuple (FIELDNAME,[ASC | DESC])
+    # @param group list : A list of field names or tuple (FIELDNAME,[ASC | DESC])
+    # @param limit int : The maximum number of returned results
+    # @param offset int : offset (default value : 0)
+    # @return a list of items (lists of (fieldname, fieldvalue))
     @classmethod
     def get(cls, query_filters, field_list=None, order=None, group=None, limit=None, offset=0):
         if field_list is not None:
 
         return objects
 
-    # @brief Retrieve an object given an UID
+    ## @brief Retrieves an object given an UID
+    # @param uid str : Unique ID of the searched LeObject
+    # @return LeObject
+    # @throw LodelFatalError if the class does not have such a UID defined or if duplicates are found
     #@todo broken multiple UID
     @classmethod
     def get_from_uid(cls, uid):
             while len(res_cp) > 0:
                 cur_res = res_cp.pop()
                 if cur_res.uid() in [r.uid() for r in res_cp]:
-                    logger.error("DOUBLON detected in query results !!!")
+                    logger.error("Duplicates detected in query results !!!")
                 else:
                     res.append(cur_res)
         if len(res) > 1:

lodel/leapi/query.py

 from lodel.context import LodelContext
 LodelContext.expose_modules(globals(), {
     'lodel.leapi.exceptions': ['LeApiError', 'LeApiErrors',
-        'LeApiDataCheckError', 'LeApiDataCheckErrors', 'LeApiQueryError',
-        'LeApiQueryErrors'],
+                               'LeApiDataCheckError', 'LeApiDataCheckErrors', 'LeApiQueryError',
+                               'LeApiQueryErrors'],
     'lodel.plugin.hooks': ['LodelHook'],
     'lodel.logger': ['logger']})
 
-##@todo check datas when running query
+# @todo check data when running query
+
+
 class LeQuery(object):
 
-    ##@brief Hookname prefix
+    # @brief Hookname prefix
     _hook_prefix = None
-    ##@brief arguments for the LeObject.check_data_value()
+    # @brief arguments for the LeObject.check_data_value()
     _data_check_args = {'complete': False, 'allow_internal': False}
 
-    ##@brief Abstract constructor
+    # @brief Abstract constructor
     # @param target_class LeObject : class of object the query is about
     def __init__(self, target_class):
         from .leobject import LeObject
             raise NotImplementedError("Abstract class")
         if not inspect.isclass(target_class) or \
            not issubclass(target_class, LeObject):
-            raise TypeError("target class has to be a child class of LeObject but %s given"% target_class)
+            raise TypeError(
+                "target class has to be a child class of LeObject but %s given" % target_class)
         self._target_class = target_class
         self._ro_datasource = target_class._ro_datasource
         self._rw_datasource = target_class._rw_datasource
 
-    ##@brief Execute a query and return the result
-    #@param **datas
+    # @brief Executes a query and returns the result
+    #@param **data
     #@return the query result
     #@see LeQuery._query()
     #@todo check that the check_datas_value is not duplicated/useless
-    def execute(self, datas):
-        if not datas is None:
+    def execute(self, data):
+        if data is not None:
             self._target_class.check_datas_value(
-                                                    datas,
-                                                    **self._data_check_args)
-            self._target_class.prepare_datas(datas) #not yet implemented
+                data,
+                **self._data_check_args)
+            self._target_class.prepare_datas(data)  # not yet implemented
         if self._hook_prefix is None:
             raise NotImplementedError("Abstract method")
-        LodelHook.call_hook(self._hook_prefix+'pre',
-                                self._target_class,
-                                datas)
-        ret = self._query(datas=datas)
-        ret = LodelHook.call_hook(self._hook_prefix+'post',
-                                    self._target_class,
-                                    ret)
+        LodelHook.call_hook(self._hook_prefix + 'pre',
+                            self._target_class,
+                            data)
+        ret = self._query(data=data)
+        ret = LodelHook.call_hook(self._hook_prefix + 'post',
+                                  self._target_class,
+                                  ret)
         return ret
 
-    ##@brief Childs classes implements this method to execute the query
-    #@param **datas
+    # @brief Child classes implement this method to execute the query
+    #@param **data
     #@return query result
-    def _query(self, **datas):
+    def _query(self, **data):
         raise NotImplementedError("Asbtract method")
 
-    ##@return a dict with query infos
+    # @return a dict with query infos
     def dump_infos(self):
         return {'target_class': self._target_class}
 
     def __repr__(self):
         ret = "<{classname} target={target_class}>"
         return ret.format(
-                            classname=self.__class__.__name__,
-                            target_class = self._target_class)
+            classname=self.__class__.__name__,
+            target_class=self._target_class)
+
+# @brief Abstract class handling query with filters
+
 
-##@brief Abstract class handling query with filters
 class LeFilteredQuery(LeQuery):
-    ##@brief The available operators used in query definitions
+    # @brief The available operators used in query definitions
     _query_operators = [
-                        ' = ',
-                        ' <= ',
-                        ' >= ',
-                        ' != ',
-                        ' < ',
-                        ' > ',
-                        ' in ',
-                        ' not in ',
-                        ' like ',
-                        ' not like ']
-
-    ##@brief Regular expression to process filters
+        ' = ',
+        ' <= ',
+        ' >= ',
+        ' != ',
+        ' < ',
+        ' > ',
+        ' in ',
+        ' not in ',
+        ' like ',
+        ' not like ']
+
+    # @brief Regular expression to process filters
     _query_re = None
 
-    ##@brief Abtract constructor for queries with filter
+    # @brief Abtract constructor for queries with filter
     #@param target_class LeObject : class of object the query is about
     #@param query_filters list : with a tuple (only one filter) or a list of
     # tuple or a dict: {OP,list(filters)} with OP = 'OR' or 'AND for tuple
     # (FIELD,OPERATOR,VALUE)
     def __init__(self, target_class, query_filters=None):
         super().__init__(target_class)
-        ##@brief The query filter tuple(std_filter, relational_filters)
+        # @brief The query filter tuple(std_filter, relational_filters)
         self._query_filter = None
-        ##@brief Stores potential subqueries (used when a query implies
+        # @brief Stores potential subqueries (used when a query implies
         # more than one datasource.
         #
         # Subqueries are tuple(target_class_ref_field, LeGetQuery)
         query_filters = [] if query_filters is None else query_filters
         self.set_query_filter(query_filters)
 
-    ##@brief Abstract FilteredQuery execution method
+    # @brief Abstract FilteredQuery execution method
     #
     # This method takes care to execute subqueries before calling super execute
-    def execute(self, datas=None):
-        #copy originals filters
+    def execute(self, data=None):
+        # copy originals filters
         orig_filters = copy.copy(self._query_filter)
         std_filters, rel_filters = self._query_filter
 
         try:
 
             filters, rel_filters = self._query_filter
-            res = super().execute(datas)
+            res = super().execute(data)
         except Exception as e:
-            #restoring filters even if an exception is raised
+            # restoring filters even if an exception is raised
             self.__query_filter = orig_filters
 
-            raise e #reraise
-        #restoring filters
+            raise e  # reraise
+        # restoring filters
         self._query_filter = orig_filters
         return res
 
-    ##@brief Add filter(s) to the query
+    # @brief Add filter(s) to the query
     #
     # This method is also able to slice query if different datasources are
     # implied in the request
     def set_query_filter(self, query_filter):
         if isinstance(query_filter, str):
             query_filter = [query_filter]
-        #Query filter prepration
+        # Query filter prepration
         filters_orig, rel_filters = self._prepare_filters(query_filter)
         # Here we now that each relational filter concern only one datasource
         # thank's to _prepare_relational_fields
 
-        #Multiple datasources detection
+        # Multiple datasources detection
         self_ds_name = self._target_class._datasource_name
-        result_rel_filters = list() # The filters that will stay in the query
+        result_rel_filters = list()  # The filters that will stay in the query
         other_ds_filters = dict()
         for rfilter in rel_filters:
             (rfield, ref_dict), op, value = rfilter
-            #rfield : the field in self._target_class
-            tmp_rel_filter = dict() #designed to stores rel_field of same DS
+            # rfield : the field in self._target_class
+            tmp_rel_filter = dict()  # designed to stores rel_field of same DS
             # First step : simplification
             # Trying to delete relational filters done on referenced class uid
             for tclass, tfield in copy.copy(ref_dict).items():
-                #tclass : reference target class
-                #tfield : referenced field from target class
+                # tclass : reference target class
+                # tfield : referenced field from target class
                 #
                 #   !!!WARNING!!!
                 # The line below brake multi UID support
                 #
                 if tfield == tclass.uid_fieldname()[0]:
-                    #This relational filter can be simplified as
+                    # This relational filter can be simplified as
                     # ref_field, op, value
                     # Note : we will have to dedup filters_orig
                     filters_orig.append((rfield, op, value))
                     del(ref_dict[tclass])
             if len(ref_dict) == 0:
                 continue
-            #Determine what to do with other relational filters given
+            # Determine what to do with other relational filters given
             # referenced class datasource
-            #Remember : each class in a relational filter has the same
+            # Remember : each class in a relational filter has the same
             # datasource
             tclass = list(ref_dict.keys())[0]
             cur_ds = tclass._datasource_name
                     other_ds_filters[cur_ds] = list()
                 other_ds_filters[cur_ds].append(
                     ((rfield, ref_dict), op, value))
-        #deduplication of std filters
+        # deduplication of std filters
         filters_cp = set()
         if not isinstance(filters_orig, set):
             for i, cfilt in enumerate(filters_orig):
                 a, b, c = cfilt
-                if isinstance(c, list): #list are not hashable
+                if isinstance(c, list):  # list are not hashable
                     newc = tuple(c)
                 else:
                     newc = c
                 old_len = len(filters_cp)
-                filters_cp |= set((a,b,newc))
+                filters_cp |= set((a, b, newc))
                 if len(filters_cp) == old_len:
                     del(filters_orig[i])
         # Sets _query_filter attribute of self query
         self._query_filter = (filters_orig, result_rel_filters)
 
-        #Sub queries creation
+        # Sub queries creation
         subq = list()
         for ds, rfilters in other_ds_filters.items():
             for rfilter in rfilters:
                     subq.append((rfield, query))
         self.subqueries = subq
 
-    ##@return informations
+    # @return informations
     def dump_infos(self):
         ret = super().dump_infos()
         ret['query_filter'] = self._query_filter
         res += '>'
         return res
 
-    ## @brief Prepare filters for datasource
+    # @brief Prepare filters for datasource
     #
-    #A filter can be a string or a tuple with len = 3.
+    # A filter can be a string or a tuple with len = 3.
     #
-    #This method divide filters in two categories :
+    # This method divide filters in two categories :
     #
     #@par Simple filters
     #
-    #Those filters concerns fields that represent object values (a title,
-    #the content, etc.) They are composed of three elements : FIELDNAME OP
+    # Those filters concerns fields that represent object values (a title,
+    # the content, etc.) They are composed of three elements : FIELDNAME OP
     # VALUE . Where :
     #- FIELDNAME is the name of the field
     #- OP is one of the authorized comparison operands (see
     #
     #@par Relational filters
     #
-    #Those filters concerns on reference fields (see the corresponding
-    #abstract datahandler @ref lodel.leapi.datahandlers.base_classes.Reference)
-    #The filter as quite the same composition than simple filters :
+    # Those filters concerns on reference fields (see the corresponding
+    # abstract datahandler @ref lodel.leapi.datahandlers.base_classes.Reference)
+    # The filter as quite the same composition than simple filters :
     # FIELDNAME[.REF_FIELD] OP VALUE . Where :
     #- FIELDNAME is the name of the reference field
     #- REF_FIELD is an optionnal addon to the base field. It indicate on wich
-    #field of the referenced object the comparison as to be done. If no
-    #REF_FIELD is indicated the comparison will be done on identifier.
+    # field of the referenced object the comparison as to be done. If no
+    # REF_FIELD is indicated the comparison will be done on identifier.
     #
     #@param cls
     #@param filters_l list : This list of str or tuple (or both)
     #@todo move this doc in another place (a dedicated page ?)
     #@warning Does not supports multiple UID for an EmClass
     def _prepare_filters(self, filters_l):
-        filters=list()
+        filters = list()
         res_filters = list()
         rel_filters = list()
         err_l = dict()
-        #Splitting in tuple if necessary
+        # Splitting in tuple if necessary
         for i, fil in enumerate(filters_l):
             if len(fil) == 3 and not isinstance(fil, str):
                 filters.append(tuple(fil))
                     err_l["filter %d" % i] = e
 
         for field, operator, value in filters:
-            err_key = "%s %s %s" % (field, operator, value) #to push in err_l
+            err_key = "%s %s %s" % (field, operator, value)  # to push in err_l
             # Spliting field name to be able to detect a relational field
             field_spl = field.split('.')
             if len(field_spl) == 2:
                 # inconsistency
                 err_l[field] = NameError("The field '%s' in %s is not \
 a relational field, but %s.%s was present in the filter"
-                                            % (field,
-                                                self._target_class.__name__,
-                                                field,
-                                                ref_field))
+                                         % (field,
+                                            self._target_class.__name__,
+                                            field,
+                                            ref_field))
             if field_datahandler.is_reference():
-                #Relationnal field
+                # Relationnal field
                 if ref_field is None:
                     # ref_field default value
                     #
                 value, error = field_datahandler.check_data_value(value)
                 if isinstance(error, Exception):
                     value = value_orig
-                res_filters.append((field,operator, value))
+                res_filters.append((field, operator, value))
         if len(err_l) > 0:
             raise LeApiDataCheckErrors(
-                                        "Error while preparing filters : ",
-                                        err_l)
+                "Error while preparing filters : ",
+                err_l)
         return (res_filters, rel_filters)
 
-    ## @brief Check and split a query filter
+    # @brief Check and split a query filter
     # @note The query_filter format is "FIELD OPERATOR VALUE"
     # @param query_filter str : A query_filter string
     # @param cls
                 raise ValueError(msg % query_filter)
         return result
 
-    ## @brief Compile the regex for query_filter processing
+    # @brief Compile the regex for query_filter processing
     # @note Set _LeObject._query_re
     @classmethod
     def __compile_query_re(cls):
         op_re_piece = '(?P<operator>(%s)'
         op_re_piece %= cls._query_operators[0].replace(' ', '\s')
         for operator in cls._query_operators[1:]:
-            op_re_piece += '|(%s)'%operator.replace(' ', '\s')
+            op_re_piece += '|(%s)' % operator.replace(' ', '\s')
         op_re_piece += ')'
 
         re_full = '^\s*(?P<field>([a-z_][a-z0-9\-_]*\.)?[a-z_][a-z0-9\-_]*)\s*'
-        re_full += op_re_piece+'\s*(?P<value>.*)\s*$'
+        re_full += op_re_piece + '\s*(?P<value>.*)\s*$'
 
         cls._query_re = re.compile(re_full, flags=re.IGNORECASE)
         pass
             msg %= (fieldname, target_class.__name__)
             return NameError(msg)
 
-    ##@brief Prepare a relational filter
+    # @brief Prepare a relational filter
     #
-    #Relational filters are composed of a tuple like the simple filters
-    #but the first element of this tuple is a tuple to :
+    # Relational filters are composed of a tuple like the simple filters
+    # but the first element of this tuple is a tuple to :
     #
     #<code>((FIELDNAME, {REF_CLASS: REF_FIELD}), OP, VALUE)</code>
     # Where :
     # - REF_CLASS as key. It's a LeObject child class
     # - REF_FIELD as value. The name of the referenced field in the REF_CLASS
     #
-    #Visibly the REF_FIELD value of the dict will vary only when
-    #no REF_FIELD is explicitly given in the filter string notation
-    #and REF_CLASSES has differents uid
+    # Visibly the REF_FIELD value of the dict will vary only when
+    # no REF_FIELD is explicitly given in the filter string notation
+    # and REF_CLASSES has differents uid
     #
     #@par String notation examples
     #<pre>contributeur IN (1,2,3,5)</pre> will be transformed into :
     #
     #@param fieldname str : The relational field name
     #@param ref_field str|None : The referenced field name (if None use
-    #uniq identifiers as referenced field
+    # uniq identifiers as referenced field
     #@return a well formed relational filter tuple or an Exception instance
     def _prepare_relational_fields(self, fieldname, ref_field=None):
         datahandler = self._target_class.field(fieldname)
                     logger.debug(msg)
         if len(ref_dict) == 0:
             return NameError("No field named '%s' in referenced objects [%s]"
-                                % (ref_field,
-                                    ','.join([rc.__name__ for rc in ref_classes])))
+                             % (ref_field,
+                                ','.join([rc.__name__ for rc in ref_classes])))
         return (fieldname, ref_dict)
 
 
-##@brief A query to insert a new object
+# @brief A query to insert a new object
 class LeInsertQuery(LeQuery):
     _hook_prefix = 'leapi_insert_'
     _data_check_args = {'complete': True, 'allow_internal': False}
 abstract LeObject : %s" % target_class)
         super().__init__(target_class)
 
-    ## @brief Implements an insert query operation, with only one insertion
-    # @param datas : datas to be inserted
-    def _query(self, datas):
-        datas = self._target_class.prepare_datas(datas, True, False)
-        id_inserted = self._rw_datasource.insert(self._target_class, datas)
+    #  @brief Implements an insert query operation, with only one insertion
+    # @param data : data to be inserted
+    def _query(self, data):
+        data = self._target_class.prepare_datas(data, True, False)
+        id_inserted = self._rw_datasource.insert(self._target_class, data)
         return id_inserted
     """
     ## @brief Implements an insert query operation, with multiple insertions
-    # @param datas : list of **datas to be inserted
-    def _query(self, datas):
+    # @param data : list of **data to be inserted
+    def _query(self, data):
         nb_inserted = self._datasource.insert_multi(
-            self._target_class,datas_list)
+            self._target_class,data_list)
         if nb_inserted < 0:
             raise LeApiQueryError("Multiple insertions error")
         return nb_inserted
     """
 
-    ## @brief Execute the insert query
-    def execute(self, datas):
-        return super().execute(datas=datas)
+    #  @brief Execute the insert query
+    def execute(self, data):
+        return super().execute(data=data)
 
 
-##@brief A query to update datas for a given object
+# @brief A query to update data for a given object
 #
 #@todo Change behavior, Huge optimization problem when updating using filters
-#and not instance. We have to run a GET and then 1 update by fecthed object...
+# and not instance. We have to run a GET and then 1 update by fecthed object...
 class LeUpdateQuery(LeFilteredQuery):
     _hook_prefix = 'leapi_update_'
     _data_check_args = {'complete': False, 'allow_internal': False}
 
-    ##@brief Instanciate an update query
+    # @brief Instanciate an update query
     #
-    #If a class and not an instance is given, no query_filters are expected
-    #and the update will be fast and simple. Else we have to run a get query
-    #before updating (to fetch datas, update them and then, construct them
-    #and check their consistency)
+    # If a class and not an instance is given, no query_filters are expected
+    # and the update will be fast and simple. Else we have to run a get query
+    # before updating (to fetch data, update them and then, construct them
+    # and check their consistency)
     #@param target LeObject clas or instance
     #@param query_filters list|None
-    #@todo change strategy with instance update. We have to accept datas for
-    #the execute method
+    #@todo change strategy with instance update. We have to accept data for
+    # the execute method
     def __init__(self, target, query_filters=None):
-        ##@brief This attr is set only if the target argument is an
-        #instance of a LeObject subclass
+        # @brief This attr is set only if the target argument is an
+        # instance of a LeObject subclass
         self.__leobject_instance_datas = None
         target_class = target
 
 
         super().__init__(target_class, query_filters)
 
-    ##@brief Implements an update query
-    #@param datas dict : datas to update
+    # @brief Implements an update query
+    #@param data dict : data to be updated
     #@returns the number of updated items
-    #@todo change stategy for instance update. Datas should be allowed
-    #for execute method (and query)
-    def _query(self, datas):
+    #@todo change stategy for instance update. Data should be allowed
+    # for execute method (and query)
+    def _query(self, data):
         uid_name = self._target_class._uid[0]
         if self.__leobject_instance_datas is not None:
-            #Instance update
-            #Building query_filter
+            # Instance update
+            # Building query_filter
             filters = [(
                 uid_name,
                 '=',
                 self._target_class, filters, [],
                 self.__leobject_instance_datas)
         else:
-            #Update by filters, we have to fetch datas before updating
+            # Update by filters, we have to fetch data before updating
             res = self._ro_datasource.select(
                 self._target_class, self._target_class.fieldnames(True),
                 self._query_filter[0],
                 self._query_filter[1])
-            #Checking and constructing datas
-            upd_datas = dict()
+            # Checking and constructing data
+            upd_data = dict()
             for res_data in res:
-                res_data.update(datas)
-                res_datas = self._target_class.prepare_datas(
+                res_data.update(data)
+                res_data = self._target_class.prepare_datas(
                     res_data, True, True)
                 filters = [(uid_name, '=', res_data[uid_name])]
                 res = self._rw_datasource.update(
                     self._target_class, filters, [],
-                    res_datas)
+                    res_data)
         return res
 
-    ## @brief Execute the update query
-    def execute(self, datas=None):
-        if self.__leobject_instance_datas is not None and datas is not None:
-            raise LeApiQueryError("No datas expected when running an update \
+    #  @brief Execute the update query
+    def execute(self, data=None):
+        if self.__leobject_instance_datas is not None and data is not None:
+            raise LeApiQueryError("No data expected when running an update \
 query on an instance")
-        if self.__leobject_instance_datas is None and datas is None:
-            raise LeApiQueryError("Datas are mandatory when running an update \
+        if self.__leobject_instance_datas is None and data is None:
+            raise LeApiQueryError("Data are mandatory when running an update \
 query on a class with filters")
-        return super().execute(datas=datas)
+        return super().execute(data=data)
 
 
-##@brief A query to delete an object
+# @brief A query to delete an object
 class LeDeleteQuery(LeFilteredQuery):
     _hook_prefix = 'leapi_delete_'
 
     def __init__(self, target_class, query_filter):
         super().__init__(target_class, query_filter)
 
-    ## @brief Execute the delete query
-    # @param datas
-    def execute(self, datas=None):
+    #  @brief Execute the delete query
+    # @param data
+    def execute(self, data=None):
         return super().execute()
 
-    ##@brief Implements delete query operations
-    # @param datas
+    # @brief Implements delete query operations
+    # @param data
     #@returns the number of deleted items
-    def _query(self, datas=None):
+    def _query(self, data=None):
         filters, rel_filters = self._query_filter
         nb_deleted = self._rw_datasource.delete(
             self._target_class, filters, rel_filters)
         return nb_deleted
 
+
 class LeGetQuery(LeFilteredQuery):
     _hook_prefix = 'leapi_get_'
 
-    ##@brief Instanciate a new get query
+    # @brief Instanciate a new get query
     #@param target_class LeObject : class of object the query is about
     #@param query_filters dict : {OP, list of query filters}
     # or tuple (FIELD, OPERATOR, VALUE) )
     #   - offset int : offset
     def __init__(self, target_class, query_filters, **kwargs):
         super().__init__(target_class, query_filters)
-        ##@brief The fields to get
+        # @brief The fields to get
         self._field_list = None
-        ##@brief An equivalent to the SQL ORDER BY
+        # @brief An equivalent to the SQL ORDER BY
         self._order = None
-        ##@brief An equivalent to the SQL GROUP BY
+        # @brief An equivalent to the SQL GROUP BY
         self._group = None
-        ##@brief An equivalent to the SQL LIMIT x
+        # @brief An equivalent to the SQL LIMIT x
         self._limit = None
-        ##@brief An equivalent to the SQL LIMIT x, OFFSET
+        # @brief An equivalent to the SQL LIMIT x, OFFSET
         self._offset = 0
 
         # Checking kwargs and assigning default values if there is some
         for argname in kwargs:
             if argname not in (
-                'field_list', 'order', 'group', 'limit', 'offset'):
+                    'field_list', 'order', 'group', 'limit', 'offset'):
                 raise TypeError("Unexpected argument '%s'" % argname)
 
         if 'field_list' not in kwargs:
-            self.set_field_list(target_class.fieldnames(include_ro = True))
+            self.set_field_list(target_class.fieldnames(include_ro=True))
         else:
             self.set_field_list(kwargs['field_list'])
 
         if 'order' in kwargs:
-            #check kwargs['order']
+            # check kwargs['order']
             self._order = kwargs['order']
         if 'group' in kwargs:
-            #check kwargs['group']
+            # check kwargs['group']
             self._group = kwargs['group']
         if 'limit' in kwargs and kwargs['limit'] is not None:
             try:
                 msg = "offset argument expected to be an integer >= 0"
                 raise ValueError(msg)
 
-    ##@brief Set the field list
+    # @brief Set the field list
     # @param field_list list | None : If None use all fields
     # @return None
     # @throw LeApiQueryError if unknown field given
                     msg = "No field named '%s' in %s"
                     msg %= (fieldname, self._target_class.__name__)
                     expt = NameError(msg)
-                    err_l[fieldname] =  expt
+                    err_l[fieldname] = expt
             if len(err_l) > 0:
                 msg = "Error while setting field_list in a get query"
-                raise LeApiQueryErrors(msg = msg, exceptions = err_l)
+                raise LeApiQueryErrors(msg=msg, exceptions=err_l)
             self._field_list = list(set(field_list))
 
-    ##@brief Execute the get query
-    def execute(self, datas=None):
+    # @brief Execute the get query
+    def execute(self, data=None):
         return super().execute()
 
-    ##@brief Implements select query operations
+    # @brief Implements select query operations
     # @returns a list containing the item(s)
-    def _query(self, datas=None):
-        # select datas corresponding to query_filter
+    def _query(self, data=None):
+        # select data corresponding to query_filter
         fl = list(self._field_list) if self._field_list is not None else None
-        l_datas=self._ro_datasource.select(
-            target = self._target_class,
-            field_list = fl,
-            filters = self._query_filter[0],
-            relational_filters = self._query_filter[1],
-            order = self._order,
-            group = self._group,
-            limit = self._limit,
-            offset = self._offset)
-        return l_datas
-
-    ##@return a dict with query infos
+        l_data = self._ro_datasource.select(
+            target=self._target_class,
+            field_list=fl,
+            filters=self._query_filter[0],
+            relational_filters=self._query_filter[1],
+            order=self._order,
+            group=self._group,
+            limit=self._limit,
+            offset=self._offset)
+        return l_data
+
+    # @return a dict with query infos
     def dump_infos(self):
         ret = super().dump_infos()
-        ret.update({  'field_list' : self._field_list,
-                        'order' : self._order,
-                        'group' : self._group,
-                        'limit' : self._limit,
-                        'offset': self._offset,
-       })
+        ret.update({'field_list': self._field_list,
+                    'order': self._order,
+                    'group': self._group,
+                    'limit': self._limit,
+                    'offset': self._offset,
+                    })
         return ret
 
     def __repr__(self):
 offset={offset}"
         res = res.format(**self.dump_infos())
         if len(self.subqueries) > 0:
-            for n,subq in enumerate(self.subqueries):
+            for n, subq in enumerate(self.subqueries):
                 res += "\n\tSubquerie %d : %s"
                 res %= (n, subq)
         res += ">"

lodel/mlnamedobject/__init__.py

+## @package lodel.mlnamedobject A package dedicated to manage the objects' properties which can be 
+# translated in several languages.
+#
+# Each object in Lodel which can be translated will see his displayed name and help text being 
+# managed by a MlNamedObject instance, a class that is part of this package.

lodel/mlnamedobject/mlnamedobject.py

 LodelContext.expose_modules(globals(), {
     'lodel.utils.mlstring': ['MlString']})
 
-# @package lodel.mlnamedobject Lodel2 description of objects module
+## @package lodel.mlnamedobject.mlnamedobject Lodel2 description of objects module
 #
 # Display name and Description of a lodel2 object
 
-# @brief Class allows display name and help text for lodel2 objects and fields
-
-
+## @brief Represents a multi-language object (dealing with its translations) 
 class MlNamedObject(object):
-
+    
+    ##
+    # @param display_name str|dict : displayed string to name the object (either a string or a dictionnary of the translated strings can be passed)
+    # @param help_text str|dict : description text for this object (either a string or a dictionnary of the translated strings can be passed)
     def __init__(self, display_name=None, help_text=None):
+        ## @brief The object's name which will be used in all the user interfaces
         self.display_name = None if display_name is None else MlString(display_name)
+        ## @brief Description text for this object
         self.help_text = None if help_text is None else MlString(help_text)

lodel/plugin/core_hooks.py

     'lodel.settings': ['Settings'],
     'lodel.logger': 'logger'})
 
-##@package lodel.plugin.core_hooks
-#@brief Lodel2 internal hooks declaration
-#@ingroup lodel2_plugins
+## @package lodel.plugin.core_hooks
+# @brief Lodel2 internal hooks declaration
+# @ingroup lodel2_plugins
 
-##@brief Bootstrap hook to check datasources configuration
+## @brief Bootstrap hook that checks datasources configuration
+# @param hook_name str
+# @param caller * : the hook's caller
+# @param payload * : data to be given to the hook
+# @throw NameError when : a set datasource family name can not be found or a datasource identifier does not match with a configured datasource.
 @LodelHook('lodel2_bootstraped')
 def datasources_bootstrap_hook(hook_name, caller, payload):
     for ds_name in Settings.datasources._fields:
             msg %= identifier
             raise NameError(msg)
 
-
         log_msg = "Found a datasource named '%s' identified by '%s'"
         log_msg %= (ds_name, identifier)
         logger.debug(log_msg)
 
-##@brief Bootstrap hook that print debug infos about registered hooks
+## @brief Bootstrap hook that prints debug infos about registered hooks
+# @param name str
+# @param caller * : the hook's caller
+# @param payload * : data to be given to the hook
 @LodelHook('lodel2_bootstraped')
 def list_hook_debug_hook(name, caller, payload):
     LodelContext.expose_modules(globals(), {
         
 
 
-##@brief Hooks that trigger custom methods injection in dynmic classes
+## @brief Hook that triggers custom methods injection in dynamic classes
+# @param caller * : the hook's caller
+# @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/datasource_plugin.py

+## @package lodel.plugin.datasource_plugin Datasource plugins management module
+#
+# 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.exceptions': ['LodelException', 'LodelExceptions',
         'LodelFatalError', 'DataNoneValid', 'FieldValidationError']})
 
+## @brief The plugin type that is used in the global settings of Lodel
 _glob_typename = 'datasource'
 
 
-##@brief Datasource class in plugins HAVE TO inherit from this abstract class
+## @brief Main abstract class from which the plugins' datasource classes must inherit.
 class AbstractDatasource(object):
     
-    ##@brief Trigger LodelFatalError when abtract method called
+    ## @brief Trigger LodelFatalError when abtract method called
+    # @throw LodelFatalError if there is an attempt to instanciate an object from this class
     @staticmethod
     def _abs_err():
         raise LodelFatalError("This method is abstract and HAVE TO be \
 reimplemented by plugin datasource child class")
     
-    ##@brief The constructor
+    ##
+    # @param *conn_args
+    # @param **conn_kwargs
     def __init__(self, *conn_args, **conn_kwargs):
         self._abs_err()
 
-    ##@brief Provide a new uniq numeric ID
-    #@param emcomp LeObject subclass (not instance) : To know on wich things we
-    #have to be uniq
-    #@return an integer
+    ## @brief Provides a new uniq numeric ID
+    # @param emcomp LeObject subclass (not instance) : defines against which objects type the id should be unique
+    # @return int
     def new_numeric_id(self, emcomp):
         self._abs_err()
 
-    ##@brief returns a selection of documents from the datasource
-    #@param target Emclass
-    #@param field_list list
-    #@param filters list : List of filters
-    #@param rel_filters list : List of relational filters
-    #@param order list : List of column to order. ex: order = [('title', 'ASC'),]
-    #@param group list : List of tupple representing the column to group together. ex: group = [('title', 'ASC'),]
-    #@param limit int : Number of records to be returned
-    #@param offset int: used with limit to choose the start record
-    #@param instanciate bool : If true, the records are returned as instances, else they are returned as dict
-    #@return list
+    ## @brief Returns a selection of documents from the datasource
+    # @param target Emclass : class of the documents
+    # @param field_list list : fields to get from the datasource
+    # @param filters list : List of filters
+    # @param rel_filters list : List of relational filters (default value : None)
+    # @param order list : List of column to order. ex: order = [('title', 'ASC'),] (default value : None)
+    # @param group list : List of tupple representing the column to group together. ex: group = [('title', 'ASC'),] (default value : None)
+    # @param limit int : Number of records to be returned (default value None)
+    # @param offset int: used with limit to choose the start record (default value : 0)
+    # @param instanciate bool : If true, the records are returned as instances, else they are returned as dict (default value : True)
+    # @return list
     def select(self, target, field_list, filters, rel_filters=None, order=None, group=None, limit=None, offset=0,
                instanciate=True):
         self._abs_err()
 
-    ##@brief Deletes records according to given filters
-    #@param target Emclass : class of the record to delete
-    #@param filters list : List of filters
-    #@param relational_filters list : List of relational filters
-    #@return int : number of deleted records
+    ## @brief Deletes records according to given filters
+    # @param target Emclass : class of the record to delete
+    # @param filters list : List of filters
+    # @param relational_filters list : List of relational filters
+    # @return int : number of deleted records
     def delete(self, target, filters, relational_filters):
         self._abs_err()
 
     ## @brief updates records according to given filters
-    #@param target Emclass : class of the object to insert
-    #@param filters list : List of filters
-    #@param relational_filters list : List of relational filters
-    #@param upd_datas dict : datas to update (new values)
-    #@return int : Number of updated records
+    # @param target Emclass : class of the object to insert
+    # @param filters list : List of filters
+    # @param relational_filters list : List of relational filters
+    # @param upd_datas dict : datas to update (new values)
+    # @return int : Number of updated records
     def update(self, target, filters, relational_filters, upd_datas):
         self._abs_err()
 
         self._abs_err()
 
 
-##@brief Designed to handles datasources plugins
+## @brief Represents a Datasource plugin
 #
-#A datasource provide data access to LeAPI typically a connector on a DB
-#or an API
+# It will provide an access to a data collection to LeAPI (i.e. database connector, API ...).
 #
-#Provide methods to initialize datasource attribute in LeAPI LeObject child
-#classes (see @ref leapi.leobject.LeObject._init_datasources() )
+# It provides the methods needed to initialize the datasource attribute in LeAPI LeObject child
+# classes (see @ref leapi.leobject.LeObject._init_datasources() )
 #
-#@note For the moment implementation is done with a retro-compatibilities
-#priority and not with a convenience priority.
-#@todo Refactor and rewrite lodel2 datasource handling
-#@todo Write abstract classes for Datasource and MigrationHandler !!!
+# @note For the moment implementation is done with a retro-compatibilities priority and not with a convenience priority.
+# @todo Refactor and rewrite lodel2 datasource handling
+# @todo Write abstract classes for Datasource and MigrationHandler !!!
 class DatasourcePlugin(Plugin):
     
     _type_conf_name = _glob_typename
-    ##@brief Stores confspecs indicating where DatasourcePlugin list is stored
+  
+    ## @brief Stores confspecs indicating where DatasourcePlugin list is stored
     _plist_confspecs = {
         'section': 'lodel2',
         'key': 'datasource_connectors',
                 'none_is_valid': False})
         }
  
-    ##@brief Construct a DatasourcePlugin 
-    #@param name str : plugin name
-    #@see plugins.Plugin
+    ##
+    # @param name str : plugin's name
+    # @see plugins.Plugin
     def __init__(self, name):
         super().__init__(name)
         self.__datasource_cls = None
     
-    ##@brief Accessor to the datasource class
-    #@return A python datasource class
+    ## @brief Returns an accessor to the datasource class
+    # @return A python datasource class
+    # @throw DatasourcePluginError if the plugin's datasource class is not a child of 
+    # @ref lodel.plugin.datasource_plugin.AbstractDatasource
     def datasource_cls(self):
         if self.__datasource_cls is None:
             self.__datasource_cls = self.loader_module().Datasource
 lodel.plugin.datasource_plugin.AbstractDatasource" % (self.name))
         return self.__datasource_cls
     
-    ##@brief Accessor to migration handler class
-    #@return A python migration handler class
+    ## @brief Returns an accessor to migration handler class
+    # @return A python migration handler class
     def migration_handler_cls(self):
         return self.loader_module().migration_handler_class()
 
-    ##@brief Return an initialized Datasource instance
-    #@param ds_name str : The name of the datasource to instanciate
-    #@param ro bool
-    #@return A properly initialized Datasource instance
-    #@throw SettingsError if an error occurs in settings
-    #@throw DatasourcePluginError for various errors
+    ## @brief Returns an initialized Datasource instance
+    # @param ds_name str : The name of the datasource to instanciate
+    # @param ro bool : indicates if it will be in read only mode, else it will be in write only mode
+    # @return A properly initialized Datasource instance
     @classmethod
     def init_datasource(cls, ds_name, ro):
         plugin_name, ds_identifier = cls.plugin_name(ds_name, ro)
         ds_cls = cls.get_datasource(plugin_name)
         return ds_cls(**ds_conf)
     
-    ##@brief Return an initialized MigrationHandler instance
-    #@param ds_name str : The datasource name
-    #@return A properly initialized MigrationHandler instance
+    ## @brief Returns an initialized MigrationHandler instance
+    # @param ds_name str : The datasource name
+    # @return A properly initialized MigrationHandler instance
+    # @throw PluginError if a read only datasource instance was given to the migration handler. 
     @classmethod
     def init_migration_handler(cls, ds_name):
         plugin_name, ds_identifier = cls.plugin_name(ds_name, False)
         return mh_cls(**ds_conf)
 
 
-    ##@brief Given a datasource name returns a DatasourcePlugin name
-    #@param ds_name str : datasource name
-    #@param ro bool : if true consider the datasource as readonly
-    #@return a DatasourcePlugin name
-    #@throw PluginError if datasource name not found
-    #@throw DatasourcePermError if datasource is read_only but ro flag arg is
-    #false
+    ## @brief Given a datasource name returns a DatasourcePlugin name
+    # @param ds_name str : datasource name
+    # @param ro bool : if true consider the datasource as readonly
+    # @return a DatasourcePlugin name
+    # @throw DatasourcePluginError if the given datasource is unknown or not configured, or if there is a conflict in its "read-only" property (between the instance and the settings).
+    # @throw SettingsError if there are misconfigured datasource settings.
     @staticmethod
     def plugin_name(ds_name, ro):
         LodelContext.expose_modules(globals(), {
 DS_PLUGIN_NAME.DS_INSTANCE_NAME. But got %s" % ds_identifier)
         return res
 
-    ##@brief Try to fetch a datasource configuration
-    #@param ds_identifier str : datasource name
-    #@param ds_plugin_name : datasource plugin name
-    #@return a dict containing datasource initialisation options
-    #@throw NameError if a datasource plugin or instance cannot be found
+    ## @brief Returns a datasource's configuration
+    # @param ds_identifier str : datasource name
+    # @param ds_plugin_name : datasource plugin name
+    # @return a dict containing datasource initialisation options
+    # @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(), {
         ds_conf = getattr(ds_conf, ds_identifier)
         return {k: getattr(ds_conf,k) for k in ds_conf._fields }
 
-    ##@brief DatasourcePlugin instance accessor
-    #@param ds_name str : plugin name
-    #@return a DatasourcePlugin instance
-    #@throw PluginError if no plugin named ds_name found
-    #@throw PluginTypeError if ds_name ref to a plugin that is not a 
-    #DatasourcePlugin
+    ## @brief Returns a DatasourcePlugin instance from a plugin's name
+    # @param ds_name str : plugin name
+    # @return DatasourcePlugin
+    # @throw PluginError if no plugin named ds_name found (@see lodel.plugin.plugins.Plugin)
+    # @throw PluginTypeError if ds_name ref to a plugin that is not a DatasourcePlugin
     @classmethod
     def get(cls, ds_name):
-        pinstance = super().get(ds_name) #Will raise PluginError if bad name
+        pinstance = super().get(ds_name)  # Will raise PluginError if bad name
         if not isinstance(pinstance, DatasourcePlugin):
            raise PluginTypeErrror("A name of a DatasourcePlugin was excepted \
 but %s is a %s" % (ds_name, pinstance.__class__.__name__))
         return pinstance
 
-    ##@brief Return a datasource class given a datasource name
-    #@param ds_plugin_name str : datasource plugin name
-    #@throw PluginError if ds_name is not an existing plugin name
-    #@throw PluginTypeError if ds_name is not the name of a DatasourcePlugin
+    ## @brief Returns a datasource class given a datasource name
+    # @param ds_plugin_name str : datasource plugin name
+    # @return Datasource class
     @classmethod
     def get_datasource(cls, ds_plugin_name):
         return cls.get(ds_plugin_name).datasource_cls()
     
-    ##@brief Given a plugin name returns a migration handler class
-    #@param ds_plugin_name str : a datasource plugin name
+    ## @brief Returns a migration handler class, given a plugin name
+    # @param ds_plugin_name str : a datasource plugin name
+    # @return MigrationHandler class
     @classmethod
     def get_migration_handler(cls, ds_plugin_name):
         return cls.get(ds_plugin_name).migration_handler_cls()
 
 
-##@page lodel2_datasources Lodel2 datasources
+## @page lodel2_datasources Lodel2 datasources
 #
-#@par lodel2_datasources_intro Intro
+# @par lodel2_datasources_intro Introduction
 # A single lodel2 website can interact with multiple datasources. This page
-# aims to describe configuration & organisation of datasources in lodel2.
+# aims to describe configuration and organisation of datasources in lodel2.
 # Each object is attached to a datasource. This association is done in the
-# editorial model, the datasource is identified by a name.
+# editorial model, in which the datasource is identified by its name.
 #
-#@par Datasources declaration
-# To define a datasource you have to write something like this in confs file :
-#<pre>
-#[lodel2.datasources.DATASOURCE_NAME]
-#identifier = DATASOURCE_FAMILY.SOURCE_NAME
-#</pre>
-# See below for DATASOURCE_FAMILY & SOURCE_NAME
+# @par Datasources declaration
+# To define a datasource you have to write something like this in configuration file :
+# <pre>
+# [lodel2.datasources.DATASOURCE_NAME]
+# identifier = DATASOURCE_FAMILY.SOURCE_NAME
+# </pre>
+#  See below for DATASOURCE_FAMILY & SOURCE_NAME
 #
-#@par Datasources plugins
-# Each datasource family is a plugin ( 
-#@ref plugin_doc "More informations on plugins" ). For example mysql or a 
-#mongodb plugins. Here is the CONFSPEC variable templates for datasources 
-#plugin
+# @par Datasources plugins
+# Each datasource family is a plugin ( @ref plugin_doc "More informations on plugins" ). 
+# For example mysql or a mongodb plugins. \n
+#
+# Here is the CONFSPEC variable templates for datasources plugin
 #<pre>
 #CONFSPEC = {
 #                'lodel2.datasource.example.*' : {
 #                }
 #}
 #</pre>
-#MySQL example
+# 
+#MySQL example \n
 #<pre>
 #CONFSPEC = {
 #                'lodel2.datasource.mysql.*' : {
 #}
 #</pre>
 #
-#@par Configuration example
-#<pre>
+# @par Configuration example
+# <pre>
 # [lodel2.datasources.main]
 # identifier = mysql.Core
 # [lodel2.datasources.revues_write]

lodel/plugin/exceptions.py

+## @package lodel.plugin.exceptions Plugin management specific exceptions
+
+
 class PluginError(Exception):
     pass
 

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'],
 
 _glob_typename = 'extension'
 
-
+## @brief A class representing a basic Extension plugin
+# 
+# This class will be extended for each plugin of this type.
 class Extension(Plugin):
     
+    ## @brief Specifies the settings linked to this plugin
     _plist_confspecs = {
         'section': 'lodel2',
         'key': 'extensions',
                 'ptype': _glob_typename,
                 'none_is_valid': False})
         }
-
+    
+    ## @brief A property defining the type's name of this plugin.
+    # By default, it's the global type name ("extension" here).
     _type_conf_name = _glob_typename
 

lodel/plugin/hooks.py

 #-*- coding: utf-8 -*-
 
+## @package lodel.plugin.hooks This module deals with the Hook management in Lodel
+
 import os
 import copy
 from lodel.context import LodelContext
 
 
-##@brief Class designed to handle a hook's callback with a priority
+## @brief Class designed to handle a hook's callback with a priority
 class DecoratedWrapper(object):
-    ##@brief Constructor
+    ##
     # @param hook function : the function to wrap
     # @param priority int : the callbacl priority
     def __init__(self, hook, priority):
         self._priority = priority
         self._hook = hook
     
-    ##@brief Call the callback
+    ## @brief Calls the callback
     # @param hook_name str : The name of the called hook
     # @param caller * : The caller (depends on the hook)
     # @param payload * : Datas that depends on the hook
     def __call__(self, hook_name, caller, payload):
         return self._hook(hook_name, caller, payload)
 
+    ## @brief Returns the string representation of the class
+    # It shows the name and the priority of the hook
     def __str__(self):
         return "<LodelHook '%s' priority = %s>" % (
             self._hook.__name__, self._priority)
 
-##@brief Decorator designed to register hook's callbacks
-#@ingroup lodel2_plugins
+## @brief Decorator designed to register hook's callbacks
+# @ingroup lodel2_plugins
 #
 # @note Decorated functions are expected to take 3 arguments :
 #  - hook_name : the called hook name
 #  - payload : datas depending on the hook
 class LodelHook(object):
     
-    ##@brief Stores all hooks (DecoratedWrapper instances)
+    ## @brief Stores all hooks (DecoratedWrapper instances)
     _hooks = dict()
     
-    ##@brief Decorator constructor
+    ##
     # @param hook_name str : the name of the hook to register to
-    # @param priority int : the hook priority
+    # @param priority int : the hook priority (default value : None)
     def __init__(self, hook_name, priority = None):
         self._hook_name = hook_name
         self._priority = 0xFFFF if priority is None else priority
     
-    ##@brief called just after __init__
+    ## @brief called just after __init__
     # @param hook function : the decorated function
     # @return the hook argument
     def __call__(self, hook):
         self._hooks[self._hook_name] = sorted(self._hooks[self._hook_name], key = lambda h: h._priority)
         return hook
 
-    ##@brief Call hooks
+    ## @brief Calls a hook
     # @param hook_name str : the hook's name
     # @param caller * : the hook caller (depends on the hook)
     # @param payload * : datas for the hook
-    # @param cls
     # @return modified payload
     @classmethod
     def call_hook(cls, hook_name, caller, payload):
                 payload = hook(hook_name, caller, payload)
         return payload
     
-    ##@brief Fetch registered hooks
-    # @param names list | None : optionnal filter on name
-    # @param cls
-    # @return a list of functions
+    ## @brief Fetches registered hooks
+    # @param names list | None : optionnal filter on name (default value : None)
+    # @return dict containing for each name a list of the hooks and their priorities
     @classmethod
     def hook_list(cls, names = None):
         res = None
             res = copy.copy(cls._hooks)
         return { name: [(hook._hook, hook._priority) for hook in hooks] for name, hooks in res.items() }
     
-    ##@brief Unregister all hooks
-    # @param cls
+    ## @brief Unregister all hooks
     # @warning REALLY NOT a good idea !
     # @note implemented for testing purpose
     @classmethod

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'],
         'LodelScriptError', 'DatasourcePluginError'],
     'lodel.validator.validator': ['Validator']})
 
+## @brief Global type name used in the settings of Lodel for this type of plugins
 _glob_typename = 'ui'
 
 
-##@brief Handles interfaces plugin
+##@brief A plugin Interface
 #@note It's a singleton class. Only 1 interface allowed by instance.
 class InterfacePlugin(Plugin):
     
-    ##@brief Singleton instance storage
+    ## @brief Singleton instance storage
     _instance = None
 
+    ## @brief Settings description
     _plist_confspecs = {
         'section': 'lodel2',
         'key': 'interface',
         'validator': Validator(
             'plugin', none_is_valid = True, ptype = _glob_typename)}
 
+    ## @brief plugin type name
     _type_conf_name = _glob_typename
     
+    ##
+    # @param name str : Name of the interface plugin
+    # @throw PluginError if there is already an interface plugin instanciated
     def __init__(self, name):
         if InterfacePlugin._instance is not None:
             raise PluginError("Maximum one interface allowed")
         super().__init__(name)
         self._instance = self
 
-    ##@brief Clear class
-    #@see plugins.Plugin::clear()
+    ## @brief Clears the singleton from its active instance
+    # @see plugins.Plugin::clear()
     @classmethod
     def clear_cls(cls):
         if cls._instance is not None:

lodel/plugins/mongodb_datasource/datasource.py

         target = emcomp.uid_source()
         tuid = target._uid[0] # Multiple UID broken here
         results = self.select(
-            target, field_list = [tuid], filters = [], 
+            target, field_list = [tuid], filters = [],
             order=[(tuid, 'DESC')], limit = 1)
-        if len(results) == 0: 
+        if len(results) == 0:
             return 1
         return results[0][tuid]+1
 
     #@param field_list list
     #@param filters list : List of filters
     #@param relational_filters list : List of relational filters
-    #@param order list : List of column to order. ex: order = 
+    #@param order list : List of column to order. ex: order =
     #[('title', 'ASC'),]
-    #@param group list : List of tupple representing the column used as 
+    #@param group list : List of tupple representing the column used as
     #"group by" fields. ex: group = [('title', 'ASC'),]
     #@param limit int : Number of records to be returned
     #@param offset int: used with limit to choose the start record
     #@return list
     #@todo Implement group for abstract LeObject childs
-    def select(self, target, field_list, filters = None, 
-            relational_filters=None, order=None, group=None, limit=None, 
+    def select(self, target, field_list, filters = None,
+            relational_filters=None, order=None, group=None, limit=None,
             offset=0):
         if target.is_abstract():
             #Reccursiv calls for abstract LeObject child
             results =  self.__act_on_abstract(target, filters,
                 relational_filters, self.select, field_list = field_list,
                 order = order, group = group, limit = limit)
-            
+
             #Here we may implement the group
             #If sorted query we have to sort again
             if order is not None:
 
         query_filters = self.__process_filters(
             target, filters, relational_filters)
-        
+
         query_result_ordering = None
         if order is not None:
             query_result_ordering = utils.parse_query_order(order)
-        
+
         if group is None:
             if field_list is None:
                 field_list = dict()
         results = list()
         for document in cursor:
             results.append(document)
-        
+
         return results
 
     ##@brief Deletes records according to given filters
         self.__update_backref_filtered(target, filters, relational_filters,
             upd_datas, old_datas_l)
         return res
-    
+
     ##@brief Designed to be called by backref update in order to avoid
     #infinite updates between back references
     #@see update()
             raise MongoDataSourceError("Missing UID data will inserting a new \
 %s" % target.__class__)
         res = self.__collection(target).insert(new_datas)
-        self.__update_backref(target, new_datas[uidname], None, new_datas) 
+        self.__update_backref(target, new_datas[uidname], None, new_datas)
         return str(res)
 
     ## @brief Inserts a list of records in a given collection
             self._data_cast(datas)
         res = self.__collection(target).insert_many(datas_list)
         for new_datas in datas_list:
-            self.__update_backref(target, None, new_datas) 
+            self.__update_backref(target, None, new_datas)
             target.make_consistency(datas=new_datas)
         return list(res.inserted_ids)
-    
+
     ##@brief Update backref giving an action
     #@param target leObject child class
     #@param filters
             old_datas_l = self.__collection(target).find(
                 mongo_filters)
             old_datas_l = list(old_datas_l)
-        
+
         uidname = target.uid_fieldname()[0] #MULTIPLE UID BROKEN HERE
         for old_datas in old_datas_l:
             self.__update_backref(
     ##@brief Update back references of an object
     #@ingroup plugin_mongodb_bref_op
     #
-    #old_datas and new_datas arguments are set to None to indicate 
+    #old_datas and new_datas arguments are set to None to indicate
     #insertion or deletion. Calls examples :
     #@par LeObject insert __update backref call
     #<pre>
                 self.__update_no_backref(
                     leo.__class__, [(leo.uid_fieldname()[0], '=', uidval)],
                     [], datas)
-    
-    ##@brief Utility function designed to handle the upd_dict of 
+
+    ##@brief Utility function designed to handle the upd_dict of
     #__update_backref()
     #
     #Basically checks if a key exists at some level, if not create it with
     #@param uid_val mixed : the UID of the referenced object
     #@return the updated version of upd_dict
     @staticmethod
-    def __update_backref_upd_dict_prepare(upd_dict,bref_infos, bref_fname, 
+    def __update_backref_upd_dict_prepare(upd_dict,bref_infos, bref_fname,
             uid_val):
         bref_cls, bref_leo, bref_dh, bref_value = bref_infos
         if bref_cls not in upd_dict:
         if bref_fname not in upd_dict[bref_cls][uid_val]:
             upd_dict[bref_cls][uid_val][1][bref_fname] = bref_value
         return upd_dict
-        
-        
+
+
     ##@brief Prepare a one value back reference update
     #@param fname str : the source Reference field name
     #@param fdh DataHandler : the source Reference DataHandler
                 return bref_val
             elif oldd and not newdd:
                 #deletion
-                if not hasattr(bref_dh, "default"): 
+                if not hasattr(bref_dh, "default"):
                     raise MongoDbConsistencyError("Unable to delete a \
 value for a back reference update. The concerned field don't have a default \
 value : in %s field %s" % (bref_leo,fname))
             elif not oldd and newdd:
                 bref_val = tuid
         return bref_val
-    
+
     ##@brief Fetch back reference informations
     #@warning thank's to __update_backref_act() this method is useless
     #@param bref_cls LeObject child class : __back_reference[0]
             port = self.__db_infos['port'],
             db_name = db_name,
             ro = ro)
-        
+
         self.__conn_hash = conn_h = hash(conn_string)
         if conn_h in self._connections:
             self._connections[conn_h]['conn_count'] += 1
                 'conn_count': 1,
                 'db': utils.connect(conn_string)}
             return self._connections[conn_h]['db'][self.__db_infos['db_name']]
-                    
+
 
     ##@brief Return a pymongo collection given a LeObject child class
     #@param leobject LeObject child class (no instance)
                     rfilters[fname][repr_leo][rfield] = list()
                 rfilters[fname][repr_leo][rfield].append((op, value))
         return rfilters
-    
+
     ##@brief Convert lodel2 filters to pymongo conditions
     #@param filters list : list of lodel filters
     #@return dict representing pymongo conditions
             1 if (a[fname]>b[fname] if cmpdir == 'ASC' else a[fname]<b[fname])\
             else -1)
 
-    
+
     ##@brief Correct some datas before giving them to pymongo
     #
     #For example sets has to be casted to lise
                 #with sets
                 datas[dname] = list(datas[dname])
         return datas
-
-    ##@brief Tool to check if a record with unique id uid is set in the target_class representation
-    #@param target_class : class to check in 
-    #@param uid : a unique id in target_class
-    #@returns true if a record with unique id uid exists in the target_class representation, false if not
-    def is_exist(self, target_class, uid):
-    # retrouver la table qui correspond à target_class
-    # vérifier qu'il existe, ou pas, un enregistrement contenant uid
-        result = self.select(self, target_class, [target_class.uid_fieldname], filters = [(target_class.uid_fieldname, '=', uid)])
-        return len(result) == 1

tests/editorial_model/test_model.py

         grp1.add_components((cls1, c1f1))
         grp2 = model.new_group('testgroup2')
         grp2.add_components((cls2, c1f2, c2f1, c2f2))
-        grp2.add_dependencie(grp1)
+        grp2.add_dependency(grp1)
         e_hash = 0x250eab75e782e51bbf212f47c6159571
         self.assertEqual(model.d_hash(), e_hash)
 
         grp3 = EmGroup('grp3')
         grp4 = EmGroup('grp4')
 
-        grp2.add_dependencie(grp1)
-        grp3.add_dependencie(grp2)
-        grp4.add_dependencie(grp2)
-        grp4.add_dependencie(grp1)
+        grp2.add_dependency(grp1)
+        grp3.add_dependency(grp2)
+        grp4.add_dependency(grp2)
+        grp4.add_dependency(grp1)
 
         self.assertEqual(set(grp1.dependencies().values()), set())
         self.assertEqual(set(grp2.dependencies().values()), set([grp1]))
     def test_deps_complex(self):
         """ More complex dependencies handling test """
         grps = [ EmGroup('group%d' % i) for i in range(6) ]
-        grps[5].add_dependencie( (grps[1], grps[2], grps[4]) )
-        grps[4].add_dependencie( (grps[1], grps[3]) )
-        grps[3].add_dependencie( (grps[0],) )
-        grps[1].add_dependencie( (grps[2], grps[0]) )
+        grps[5].add_dependency( (grps[1], grps[2], grps[4]) )
+        grps[4].add_dependency( (grps[1], grps[3]) )
+        grps[3].add_dependency( (grps[0],) )
+        grps[1].add_dependency( (grps[2], grps[0]) )
         self.assertEqual(
                             set(grps[5].dependencies(True).values()),
                             set( grps[i] for i in range(5))
                             set(grps[4].dependencies(True).values()),
                             set( grps[i] for i in range(4))
         )
-        grps[2].add_dependencie(grps[0])
+        grps[2].add_dependency(grps[0])
         self.assertEqual(
                             set(grps[5].dependencies(True).values()),
                             set( grps[i] for i in range(5))
         )
         # Inserting circular deps
         with self.assertRaises(EditorialModelError):
-            grps[0].add_dependencie(grps[5])
+            grps[0].add_dependency(grps[5])
 
     def test_circular_dep(self):
         """ Test circular dependencies detection """
         grps = [ EmGroup('group%d' % i) for i in range(10) ]
         for i in range(1,10):
-            grps[i].add_dependencie(grps[i-1])
+            grps[i].add_dependency(grps[i-1])
 
         for i in range(1,10):
             for j in range(i+1,10):
                 with self.assertRaises(EditorialModelError):
-                    grps[i].add_dependencie(grps[j])
+                    grps[i].add_dependency(grps[j])
 
     def test_d_hash(self):
         """ Test the deterministic hash method """

tests/editorial_model/test_translator_picklefile.py

         grp2 = model.new_group('testgroup2')
         grp2.add_components((cls2, c1f2, c2f1, c2f2))
 
-        grp2.add_dependencie(grp1)
+        grp2.add_dependency(grp1)
         
         tmpfd, temp_file = tempfile.mkstemp()
         os.close(tmpfd)

tests/editorial_model/test_translator_xmlfile.py

         grp2 = emmodel.new_group('testgroup2')
         grp2.add_components((cls2, c1f2, c2f1, c2f2))
 
-        grp2.add_dependencie(grp1)
+        grp2.add_dependency(grp1)
         
         f_tmp, file_name = tempfile.mkstemp()
         os.close(f_tmp)

tests/leapi/query/test_datasource.py

             [(('alias', {cls: 'firstname'}), '=', 'foo')])
         self.check_nocall(read = False, exclude = ['delete'])
         self.check_nocall(read = True)
-    
+
     @unittest.skip("Waiting references checks stack implementation")
     def test_insert(self):
         """ Testing LeInsertQuery mocking datasource """
         query = LeUpdateQuery(inst)
 
         with self.assertRaises(LeApiQueryError):
-            # Bad call, giving datas while an instance was given to __init__
-            query.execute(datas = {'firstname': 'ooba'})
+            # Bad call, giving data while an instance was given to __init__
+            query.execute(data = {'firstname': 'ooba'})
 
         query.execute()
         self.mockwrite.update.assert_called_once_with(