Moved exceptions + LeUpdateQuery.__query implementation

- The LeUpdateQuery implementation is broken or at least have huge performance issue
- Moved LeObject exceptions and LeQuery exceptions in lodel.leapi.exceptions

Doxyfile

@@ -763,7 +763,7 @@ WARN_LOGFILE           =
 # spaces.
 # Note: If this tag is empty the current directory is searched.
 
-INPUT                  = .
+INPUT                  =
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses

lodel/leapi/leobject.py

@@ -7,45 +7,13 @@ from lodel import logger
 from lodel.settings import Settings
 from lodel.settings.utils import SettingsError
 from .query import LeInsertQuery, LeUpdateQuery, LeDeleteQuery, LeGetQuery
+from .exceptions import *
 from lodel.plugin.hooks import LodelHook
 
 ##@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"
 
-class LeApiErrors(Exception):
-    ##@brief Instanciate a new exceptions handling multiple exceptions
-    # @param msg str : Exception message
-    # @param exceptions dict : A list of data check Exception with concerned field (or stuff) as key
-    def __init__(self, msg = "Unknow error", exceptions = None):
-        self._msg = msg
-        self._exceptions = dict() if exceptions is None else exceptions
-
-    def __repr__(self):
-        return self.__str__()
-
-    def __str__(self):
-        msg = self._msg
-        for_iter = self._exceptions.items() if isinstance(self._exceptions, dict) else enumerate(self.__exceptions)
-        for obj, expt in for_iter:
-            msg += "\n\t{expt_obj} : ({expt_name}) {expt_msg}; ".format(
-                    expt_obj = obj,
-                    expt_name=expt.__class__.__name__,
-                    expt_msg=str(expt)
-            )
-        return msg
-
-
-##@brief When an error concern a query
-class LeApiQueryError(LeApiErrors):
-    pass
-
-
-##@brief When an error concerns a datas
-class LeApiDataCheckError(LeApiErrors):
-    pass
-
-
 ##@brief Wrapper class for LeObject getter & setter
 #
 # This class intend to provide easy & friendly access to LeObject fields values 
@@ -276,6 +244,12 @@ raised when trying to import Datasource"
             ds_conf[k] = getattr(ds_conf_old, k)
 
         return datasource_class(**ds_conf)
+    
+    ##@brief Return the uid of the current LeObject instance
+    #@return the uid value
+    #@warning Broke multiple uid capabilities
+    def uid(self):
+        return self.data(self._uid[0])
 
     ##@brief Read only access to all datas
     # @note for fancy data accessor use @ref LeObject.g attribute @ref LeObjectValues instance
@@ -290,6 +264,12 @@ raised when trying to import Datasource"
             raise RuntimeError("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
+    def datas(self):
+        return [self.data(fname) for fname in self.fieldnames(True)]
+        
+    
     ##@brief Datas setter
     # @note for fancy data accessor use @ref LeObject.g attribute @ref LeObjectValues instance
     # @param fname str : field name
@@ -527,7 +507,7 @@ raised when trying to import Datasource"
             
         try:
             result = query.execute(datas)
-        except Exception as err;
+        except Exception as err:
             raise err
 
         return result

lodel/leapi/query.py

@@ -2,36 +2,12 @@
 
 import re
 import copy
+import inspect
 
-from .leobject import LeObject, LeApiErrors, LeApiDataCheckError
+from .exceptions import *
 from lodel.plugin.hooks import LodelHook
 from lodel import logger
 
-class LeQueryError(Exception):
-    ##@brief Instanciate a new exceptions handling multiple exceptions
-    #@param msg str : Exception message
-    #@param exceptions dict : A list of data check Exception with concerned
-    # field (or stuff) as key
-    def __init__(self, msg = "Unknow error", exceptions = None):
-        self._msg = msg
-        self._exceptions = dict() if exceptions is None else exceptions
-
-    def __repr__(self):
-        return self.__str__()
-
-    def __str__(self):
-        msg = self._msg
-        if isinstance(self._exceptions, dict):
-            for_iter = self._exceptions.items()
-        else:
-            for_iter = enumerate(self.__exceptions)
-        for obj, expt in for_iter:
-            msg += "\n\t{expt_obj} : ({expt_name}) {expt_msg}; ".format(
-                    expt_obj = obj,
-                    expt_name=expt.__class__.__name__,
-                    expt_msg=str(expt)
-            )
-        return msg
 
 ##@todo check datas when running query
 class LeQuery(object):
@@ -44,6 +20,7 @@ class LeQuery(object):
     ##@brief Abstract constructor
     # @param target_class LeObject : class of object the query is about
     def __init__(self, target_class):
+        from .leobject import LeObject
         if self._hook_prefix is None:
             raise NotImplementedError("Abstract class")
         if not issubclass(target_class, LeObject):
@@ -504,41 +481,81 @@ class LeInsertQuery(LeQuery):
 
 
 ##@brief A query to update datas 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...
 class LeUpdateQuery(LeFilteredQuery):
     
     _hook_prefix = 'leapi_update_'
     _data_check_args = { 'complete': True, 'allow_internal': False }
-
-    def __init__(self, target_class, query_filter):
-        super().__init__(target_class, query_filter)
     
-    ##@brief Called by __query to do severals checks before running the update
-    #@warning Optimization issue : each time this method is called we do 
-    #a LeGetQuery to fetch ALL datas and construct instances for being able to
-    #construct datas and check consistency
-    #@todo implementation (waiting for LeApi to be plugged to LeQuery)
-    def __fetch_construct_check_update(self, filters, rel_filters, datas):
-        """
-        instances = self._target_class.get(filters, rel_filters)
-        for instance in instances:
-            instance.check_datas_value(instance.
-        """
-        pass
-        
+    ##@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)
+    #@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
+    def __init__(self, target, query_filters = None):
+        ##@brief This attr is set only if the target argument is an 
+        #instance of a LeObject subclass
+        self.__leobject_datas = None
+        target_class = target
+        if not inspect.isclass(target):
+            if query_filters is not None:
+                msg = "No query_filters accepted when an instance is given as \
+target to LeUpdateQuery constructor"
+                raise AttributeError(msg)
+            target_class = target.__class__
+            if self.initialized():
+                self.__leobject_instance_datas = target.datas()
+            else:
+                filters = [(target._uid[0], '=', target.uid())]
+    
+        super().__init__(target_class, query_filters)
 
     ##@brief Implements an update query
     #@param filters list : see @ref LeFilteredQuery
     #@param rel_filters list : see @ref LeFilteredQuery
     #@param datas dict : datas to update
     #@returns the number of updated items
+    #@todo change stategy for instance update. Datas should be allowed 
+    #for execute method (and query)
     def __query(self, filters, rel_filters, datas):
-        self.__fetch_construct_check_update(filters, rel_filters, datas)
-        nb_updated = self._rw_datasource.update(
-            self._target_class, filters, rel_filters, datas)
+        uid_name = self._target_class._uid[0]
+        if self.__leobject_instance is not None:
+            #Instance update
+            #Building query_filter
+            filters = [(
+                uid_name, '=', self.__leobject_instance_datas[uid_name])]
+            self._rw_datasource.update(
+                self._target_class, filters, [],
+                self.__leobject_instance_datas)
+        else:
+            #Update by filters, we have to fetch datas before updating
+            res = self._ro_datasource.select(
+                self._target_class, self._target_class.fieldnames(True),
+                filters, rel_filters)
+            #Checking and constructing datas
+            upd_datas = dict()
+            for res_data in res:
+                res_data.update(datas)
+                res_datas = self._target_class.check_datas_value(
+                    res_data, True, True)
+                filters = [(uid_name, '=', res_data[uid_name])]
+                self._rw_datasource.update(
+                    self._target_class, filters, [],
+                    res_datas)
         return nb_updated
     
     ## @brief Execute the update query
-    def execute(self, datas):
+    def execute(self, datas = None):
+        if self.__leobject_instance is not None and datas is not None:
+            raise AttributeError("No datas expected when running an update \
+query on an instance")
         return super().execute(datas = datas)
 
 ##@brief A query to delete an object
@@ -639,7 +656,7 @@ class LeGetQuery(LeFilteredQuery):
                 err_l[fieldname] =  expt
         if len(err_l) > 0:
             msg = "Error while setting field_list in a get query"
-            raise LeQueryError(msg = msg, exceptions = err_l)
+            raise LeApiQueryErrors(msg = msg, exceptions = err_l)
         self.__field_list = list(set(field_list))
     
     ##@brief Execute the get query

plugins/mongodb_datasource/datasource.py

@@ -77,7 +77,7 @@ class MongoDbDatasource(object):
     #@param instanciate bool : If true, the records are returned as instances, else they are returned as dict
     #@return list
     #@todo Implement the relations
-    def select(self, target, field_list, filters, rel_filters=None, order=None, group=None, limit=None, offset=0, instanciate=True):
+    def select(self, target, field_list, filters, rel_filters=None, order=None, group=None, limit=None, offset=0):
         collection_name = object_collection_name(target)
         collection = self.database[collection_name]
         query_filters = self.__process_filters(

tests/leapi/query/test_get.py

@@ -5,8 +5,8 @@ import itertools
 import tests.loader_utils
 from tests.leapi.query.utils import dyncode_module as dyncode
 
-from lodel.leapi.leobject import LeApiDataCheckError
-from lodel.leapi.query import LeDeleteQuery, LeUpdateQuery, LeGetQuery, LeQueryError
+from lodel.leapi.query import LeDeleteQuery, LeUpdateQuery, LeGetQuery
+from lodel.leapi.exceptions import LeApiQueryError
 
 class LeGetQueryTestCase(unittest.TestCase):
     
@@ -89,6 +89,6 @@ class LeGetQueryTestCase(unittest.TestCase):
                             ('lodel_id', None,) )
 
         for bad_field_list in bad_field_lists:
-            with self.assertRaises(LeQueryError):
+            with self.assertRaises(LeApiQueryError):
                 LeGetQuery(dyncode.Object, [], field_list = bad_field_list)