Beginin leapi implementation

lodel/leapi/datahandlers/field_data_handler.py

@@ -57,6 +57,8 @@ class FieldDataHandler(object):
     # @param fname str : The field name
     # @param datas dict : dict storing fields values (from the component)
     # @param cur_value : the value from the current field (identified by fieldname)
+    # @return the value
+    # @throw RunTimeError if data construction fails
     def construct_data(self, emcomponent, fname, datas, cur_value):
         emcomponent_fields = emcomponent.fields()
         fname_data_handler = None
@@ -70,7 +72,7 @@ class FieldDataHandler(object):
         elif fname_data_handler is not None and fname_data_handler.nullable:
                 return None
 
-        raise RuntimeError("Unable to construct data for field %s", fname)
+        return RuntimeError("Unable to construct data for field %s", fname)
 
     ## @brief Check datas consistency
     # @param emcomponent EmComponent : An EmComponent child class instance

lodel/leapi/leobject.py

@@ -0,0 +1,227 @@
+#-*- coding: utf-8 -*-
+
+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 
+# without name collision problems
+# @note Wrapped methods are : LeObject.data() & LeObject.set_data()
+class LeObjectValues(object):
+    
+    ## @brief Construct a new LeObjectValues
+    # @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
+    def __init__(self, fieldnames_callback, set_callback, get_callback):
+        self.__setter = set_callback
+        self.__getter = get_callback
+    
+    ## @brief Provide read access to datas values
+    # @note Read access should be provided for all fields
+    # @param fname str : Field name
+    def __getattribute__(self, fname):
+        return self.__getter(fname)
+    
+    ## @brief Provide 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
+    def __setattribute__(self, fname, fval):
+        return self.__setter(fname, fval)
+        
+
+class LeObject(object):
+    
+    ## @brief A dict that stores DataHandler instances indexed by field name
+    __fields = None
+    ## @brief A tuple of fieldname (or a uniq fieldname) representing uid
+    __uid = None 
+
+    def __init__(self, **kwargs):
+        ## @brief A dict that stores fieldvalues indexed by fieldname
+        self.__datas = dict(fname:None for fname in self.__fields)
+        ## @brief Store a list of initianilized fields when instanciation not complete else store True
+        self.__initialized = list()
+        ## @brief Datas accessor. Instance of @ref LeObjectValues
+        self.d = LeObjectValues(self.fieldnames, self.set_data, self.data)
+
+        # Checks that uid is given
+        for uid_name in self.__uid:
+            if uid_name not in kwargs:
+                raise AttributeError("Cannot instanciate a LeObject without it's identifier")
+            self.__datas[uid_name] = kwargs[uid_name]
+            del(kwargs[uid_name])
+            self.__initialized.append(uid_name)
+
+        allowed_fieldnames = self.fieldnames(include_ro = False)
+        err_list = list()
+        for fieldname, fieldval in kwargs.items():
+            if fieldname not in allowed_fieldnames:
+                if fieldname in self.__fields:
+                    err_list.append(
+                        AttributeError("Value given for internal field : '%s'" % fieldname)
+                    )
+                else:
+                    err_list.append(
+                        AttributeError("Unknown fieldname : '%s'" % fieldname)
+                    )
+            else:
+                self.__datas[fieldame] = fieldval
+                self.__initialized = list()
+        self.set_initialized()
+    
+    #-----------------------------------#
+    #   Fields datas handling methods   #
+    #-----------------------------------#
+
+    ## @brief @property True if LeObject is initialized else False
+    @property
+    def initialized(self):
+        return not isinstance(self.__initialized, list)
+
+    ## @brief Return a list of fieldnames
+    # @param include_ro bool : if True include read only field names
+    # @return a list of str
+    @classmethod
+    def fieldnames(cls, include_ro = False):
+        if not include_ro:
+            return [ fname for fname in self.__fields if not self.__fields[fname].is_internal() ]
+        else:
+            return list(self.__fields.keys())
+ 
+    ## @brief Read only access to all datas
+    # @note for fancy data accessor use @ref LeObject.g attribute @ref LeObjectValues instance
+    # @param name str : field 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):
+        if field_name not in self.__fields.keys():
+            raise NameError("No such field in %s : %s" % (self.__class__.__name__, name)
+        if not self.initialized and name not in self.__initialized:
+            raise RuntimeError("The field %s is not initialized yet (and have no value)" % name)
+        return self.__datas[name]
+    
+    ## @brief Datas setter
+    # @note for fancy data accessor use @ref LeObject.g attribute @ref LeObjectValues instance
+    # @param fname str : field 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
+    def set_data(self, fname, fval):
+        if field_name not in self.fieldnames(include_ro = False):
+            if field_name not in self.__fields.keys():
+                raise NameError("No such field in %s : %s" % (self.__class__.__name__, name))
+            else:
+                raise AttributeError("The field %s is read only" % fname)
+        self.__datas[fname] = fval
+        if not self.initialized and fname not in self.__initialized:
+            # Add field to initialized fields list
+            self.__initialized.append(fname)
+            self.__set_initialized()
+        if self.initialized:
+            # Running full value check
+            ret = self.__check_modified_values()
+            if ret is None:
+                return self.__datas[fname]
+            else:
+                raise LeApiErrors("Data check error", ret)
+        else:
+            # Doing value check on modified field
+            # We skip full validation here because the LeObject is not fully initialized yet
+            val, err = self.__fields[fname].check_data_value(fval)
+            if isinstance(err, Exception):
+                #Revert change to be in valid state
+                del(self.__datas[fname])
+                del(self.__initialized[-1])
+                raise LeApiErrors("Data check error", {fname:err})
+            else:
+                self.__datas[fname] = val
+    
+    ## @brief Update the __initialized attribute according to LeObject internal state
+    #
+    # Check the list of initialized fields and set __initialized to 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.__initialized = True
+
+    ## @brief Designed to be called when datas are modified
+    #
+    # Make 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()
+        if self.__initialized is True:
+            # Data value check
+            for fname in self.fieldnames(include_ro = False):
+                val, err = self.__fields[fname].check_data_value(self.__datas[fname])
+                if err is not None:
+                    err_list[fname] = err
+                else:
+                    self.__datas[fname] = val
+            # Data construction
+            if len(err_list) == 0:
+                for fname in self.fieldnames(include_ro = True):
+                    try:
+                        field = self.__fields[fname]
+                        self.__datas[fname] = fields.construct_data(    self,
+                                                                        fname,
+                                                                        self.__datas,
+                                                                        self.__datas[fname]
+                        )
+                    except Exception as e:
+                        err_list[fname] = e
+            # Datas consistency check
+            if len(err_list) == 0:
+                for fname in self.fieldnames(include_ro = True):
+                    field = self.__fields[fname]
+                    ret = field.check_data_consistency(self, fname, self.__datas)
+                    if isinstance(ret, Exception):
+                        err_list[fname] = ret
+        else:
+            # Data value check for initialized datas
+            for fname in self.__initialized:
+                val, err = self.__fields[fname].check_data_value(self.__datas[fname])
+                if err is not None:
+                    err_list[fname] = err
+                else:
+                    self.__datas[fname] = val
+        return err_list if len(err_list) > 0 else None
+
+    #-------------------#
+    #   Crud methods    #
+    #-------------------#
+
+    

lodel/leapi/query.py

@@ -0,0 +1,41 @@
+#-*- coding: utf-8 -*-
+
+from leobject import LeObject
+
+class LeQueryError(Exception):
+    pass
+
+## @brief Handle CRUD operations on datasource
+class LeQuery(object):
+    
+    ## @brief Constructor
+    # @param target_class LeObject class or childs : The LeObject child class concerned by this query
+    def __init__(self, target_class):
+        if not issubclass(target_class, LeObject):
+            raise TypeError("target_class have to be a child class of LeObject")
+        self._target_class = target_class
+
+## @brief Handles insert queries
+class LeInsertQuery(LeQuery):
+
+    def __init__(self, target_class):
+        super().__init__(target_class)
+        if target_class.is_abstract():
+            raise LeQueryError("Target EmClass cannot be abstract for an InsertQuery")
+
+## @brief Handles Le*Query with a query_filter argument
+# @see LeGetQuery, LeUpdateQuery, LeDeleteQuery
+class LeFilteredQuery(LeQuery):
+    pass
+
+## @brief Handles Get queries
+class LeGetQuery(LeFilteredQuery):
+    pass   
+
+## @brief Handles Update queries
+class LeUpdateQuery(LeFilteredQuery):
+    pass
+
+## @biref Handles Delete queries
+class LeInsertQuery(LeFilteredQuery):
+    pass