Refactoring of datahandlers to simplify from_name() method

Warning, this commit is in a broken state. The em_test.py doesn't works yet
because it uses old relation handler (that doesn't exists anymore). The pickle file in
example is broken too

lodel/editorial_model/components.py

@@ -6,7 +6,6 @@ import copy
 import hashlib
 
 from lodel.utils.mlstring import MlString
-from lodel.leapi.datahandlers.field_data_handler import FieldDataHandler
 
 from lodel.editorial_model.exceptions import *
 
@@ -156,7 +155,7 @@ class EmClass(EmComponent):
 
 ## @brief Handles editorial model classes fields
 class EmField(EmComponent):
-    
+
     ## @brief Instanciate a new EmField
     # @param uid str : uniq identifier
     # @param display_name MlString|str|dict : field display_name
@@ -165,9 +164,10 @@ class EmField(EmComponent):
     # @param group EmGroup :
     # @param **handler_kwargs : data handler arguments
     def __init__(self, uid, data_handler, display_name = None, help_text = None, group = None, **handler_kwargs):
+        from lodel.leapi.datahandlers.base_classes import DataHandler
         super().__init__(uid, display_name, help_text, group)
         self.data_handler_name = data_handler
-        self.data_handler_cls = FieldDataHandler.from_name(data_handler)
+        self.data_handler_cls = DataHandler.from_name(data_handler)
         #if 'data_handler_kwargs' in handler_kwargs:
         #    handler_kwargs = handler_kwargs['data_handler_kwargs']
         self.data_handler_options = handler_kwargs

lodel/leapi/datahandlers/__init__.py

@@ -1 +1,2 @@
-__author__ = 'roland'
+from lodel.leapi.datahandlers.base_classes import DataHandler
+DataHandler.load_base_handlers()

lodel/leapi/datahandlers/base_classes.py

@@ -0,0 +1,249 @@
+# -*- coding: utf-8 -*-
+
+## @package lodel.leapi.datahandlers.base_classes Define all base/abstract class for data handlers
+#
+# Contains custom exceptions too
+
+import copy
+import importlib
+import inspect
+
+
+class FieldValidationError(Exception):
+    pass
+
+## @brief Base class for all data handlers
+class DataHandler(object):
+    
+    __HANDLERS_MODULES = ('datas_base', 'datas', 'references')
+    ## @brief Stores the DataHandler childs classes indexed by name
+    __base_handlers = None
+    ## @brief Stores custom datahandlers classes indexed by name
+    # @todo do it ! (like plugins, register handlers... blablabla)
+    __custom_handlers = dict()
+
+    help_text = 'Generic Field Data Handler'
+
+    ## @brief List fields that will be exposed to the construct_data_method
+    _construct_datas_deps = []
+
+    ## @brief constructor
+    # @param internal False | str : define whether or not a field is internal
+    # @param immutable bool : indicates if the fieldtype has to be defined in child classes of LeObject or if it is
+    #                         designed globally and immutable
+    # @param **args
+    # @throw NotImplementedError if it is instanciated directly
+    def __init__(self, internal=False, immutable=False, primary_key = False, **args):
+        if self.__class__ == DataHandler:
+            raise NotImplementedError("Abstract class")
+        
+        self.primary_key = primary_key
+        self.internal = internal  # Check this value ?
+        self.immutable = bool(immutable)
+
+        for argname, argval in args.items():
+            setattr(self, argname, argval)
+
+    ## Fieldtype name
+    @staticmethod
+    def name(cls):
+        return cls.__module__.split('.')[-1]
+
+    def is_primary_key(self):
+        return self.primary_key
+
+    ## @brief checks if a fieldtype is internal
+    # @return bool
+    def is_internal(self):
+        return self.internal is not False
+
+    ## @brief calls the data_field defined _check_data_value() method
+    # @return tuple (value, error|None)
+    def check_data_value(self, value):
+        return self._check_data_value(value)
+
+    def _check_data_value(self, value):
+        return value, None
+
+    ## @brief checks if this class can override the given data handler
+    # @param data_handler DataHandler
+    # @return bool
+    def can_override(self, data_handler):
+        if data_handler.__class__.base_type != self.__class__.base_type:
+            return False
+        return True
+
+    ## @brief Build field value
+    # @param emcomponent EmComponent : An EmComponent child class instance
+    # @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
+        if fname in emcomponent_fields:
+            fname_data_handler = DataHandler.from_name(emcomponent_fields[fname])
+
+        if fname in datas.keys():
+            return cur_value
+        elif fname_data_handler is not None and hasattr(fname_data_handler, 'default'):
+                return fname_data_handler.default
+        elif fname_data_handler is not None and fname_data_handler.nullable:
+                return None
+
+        return RuntimeError("Unable to construct data for field %s", fname)
+
+    ## @brief Check datas consistency
+    # @param emcomponent EmComponent : An EmComponent child class instance
+    # @param fname : the field name
+    # @param datas dict : dict storing fields values
+    # @return an Exception instance if fails else True
+    # @todo A implémenter
+    def check_data_consistency(self, emcomponent, fname, datas):
+        return True
+
+    ## @brief This method is use by plugins to register new data handlers
+    @classmethod
+    def register_new_handler(cls, name, data_handler):
+        if not inspect.isclass(data_handler):
+            raise ValueError("A class was expected but %s given" % type(data_handler))
+        if not issubclass(data_handler, DataHandler):
+            raise ValueError("A data handler HAS TO be a child class of DataHandler")
+        cls.__custom_handlers[name] = data_handler
+
+    @classmethod
+    def load_base_handlers(cls):
+        if cls.__base_handlers is None:
+            cls.__base_handlers = dict()
+            for module_name in cls.__HANDLERS_MODULES:
+                module = importlib.import_module('lodel.leapi.datahandlers.%s' % module_name)
+                for name, obj in inspect.getmembers(module):
+                    if inspect.isclass(obj):
+                        print("Data handler found : %s in %s" % (name, module_name))
+                        cls.__base_handlers[name.lower()] = obj
+        return copy.copy(cls.__base_handlers)
+
+    ## @brief given a field type name, returns the associated python class
+    # @param fieldtype_name str : A field type name (not case sensitive)
+    # @return DataField child class
+    # @todo implements custom handlers fetch
+    # @note To access custom data handlers it can be cool to preffix the handler name by plugin name for example ? (to ensure name unicity)
+    @classmethod
+    def from_name(cls, name):
+        name = name.lower()
+        if name not in cls.__base_handlers:
+            raise NameError("No data handlers named '%s'" % (name,))
+        return cls.__base_handlers[name]
+ 
+    ## @brief Return the module name to import in order to use the datahandler
+    # @param data_handler_name str : Data handler name
+    # @return a str
+    @classmethod
+    def module_name(cls, name):
+        name = name.lower()
+        handler_class = cls.from_name(name)
+        return '{module_name}.{class_name}'.format(
+                                                    module_name = handler_class.__module__,
+                                                    class_name = handler_class.__name__
+        )
+            
+    ## @brief __hash__ implementation for fieldtypes
+    def __hash__(self):
+        hash_dats = [self.__class__.__module__]
+        for kdic in sorted([k for k in self.__dict__.keys() if not k.startswith('_')]):
+            hash_dats.append((kdic, getattr(self, kdic)))
+        return hash(tuple(hash_dats))
+
+## @brief Base class for datas data handler (by opposition with references)
+class DataField(DataHandler):
+
+    ## @brief Instanciates a new fieldtype
+    # @param nullable bool : is None allowed as value ?
+    # @param uniq bool : Indicates if a field should handle a uniq value
+    # @param primary bool : If true the field is a primary key
+    # @param internal str|False: if False, that field is not internal. Other values cans be "autosql" or "internal"
+    # @param **kwargs : Other arguments
+    # @throw NotImplementedError if called from bad class
+    def __init__(self, internal=False, nullable=True, uniq=False, primary=False, **kwargs):
+        if self.__class__ == DataField:
+            raise NotImplementedError("Abstract class")
+
+        super().__init__(internal, **kwargs)
+
+        self.nullable = nullable
+        self.uniq = uniq
+        self.primary = primary
+        if 'defaults' in kwargs:
+            self.default, error = self.check_data_value(kwargs['default'])
+            if error:
+                raise error
+            del(args['default'])
+
+    def check_data_value(self, value):
+        if value is None:
+            if not self.nullable:
+                return None, TypeError("'None' value but field is not nullable")
+
+            return None, None
+        return super().check_data_value(value)
+
+
+## @brief Abstract class for all references
+#
+# References are fields that stores a reference to another
+# editorial object
+class Reference(DataHandler):
+
+    ## @brief Instanciation
+    # @param allowed_classes list | None : list of allowed em classes if None no restriction
+    # @param internal bool : if False, the field is not internal
+    # @param **kwargs : other arguments
+    def __init__(self, allowed_classes = None, internal=False, **kwargs):
+        self.__allowed_classes = None if allowed_classes is None else set(allowed_classes)
+        super().__init__(internal=internal, **kwargs)
+
+    ## @brief Check value
+    # @param value *
+    # @return tuple(value, exception)
+    # @todo implement the check when we have LeObject to check value
+    def _check_data_value(self, value):
+        return value, None
+        if isinstance(value, lodel.editorial_model.components.EmClass):
+            value = [value]
+        for elt in value:
+            if not issubclass(elt.__class__, EmClass):
+                return None, FieldValidationError("Some elements of this references are not EmClass instances")
+            if self.__allowed_classes is not None:
+                if not isinstance(elt, self.__allowed_classes):
+                    return None, FieldValidationError("Some element of this references are not valids (don't fit with allowed_classes")
+        return value
+
+
+## @brief This class represent a data_handler for single reference to another object
+#
+# The fields using this data handlers are like "foreign key" on another object
+class SingleRef(Reference):
+    
+    def __init__(self, allowed_classes = None, **kwargs):
+        super().__init__(allowed_classes = allowed_classes)
+ 
+    def _check_data_value(self, value):
+        val, expt = super()._check_data_value(value)
+        if not isinstance(expt, Exception):
+            if len(val) > 1:
+               return None, FieldValidationError("Only single values are allowed for SingleRef fields")
+        return val, expt
+
+
+## @brief This class represent a data_handler for multiple references to another object
+#
+# The fields using this data handlers are like SingleRef but can store multiple references in one field
+# @note SQL implementation could be tricky
+class MultipleRef(Reference):
+    
+    def __init__(self, allowed_classes = None, **kwargs):
+        super().__init__(allowed_classes = allowed_classes)
+ 
+

lodel/leapi/datahandlers/data_field.py

@@ -1,36 +0,0 @@
-# -*- coding: utf-8 -*-
-from .field_data_handler import FieldDataHandler
-
-
-class DataField(FieldDataHandler):
-
-    ## @brief Instanciates a new fieldtype
-    # @param nullable bool : is None allowed as value ?
-    # @param uniq bool : Indicates if a field should handle a uniq value
-    # @param primary bool : If true the field is a primary key
-    # @param internal str|False: if False, that field is not internal. Other values cans be "autosql" or "internal"
-    # @param **kwargs : Other arguments
-    # @throw NotImplementedError if called from bad class
-    def __init__(self, internal=False, nullable=True, uniq=False, primary=False, **kwargs):
-        if self.__class__ == DataField:
-            raise NotImplementedError("Abstract class")
-
-        super().__init__(internal, **kwargs)
-
-        self.nullable = nullable
-        self.uniq = uniq
-        self.primary = primary
-        if 'defaults' in kwargs:
-            self.default, error = self.check_data_value(kwargs['default'])
-            if error:
-                raise error
-            del(args['default'])
-
-    def check_data_value(self, value):
-        if value is None:
-            if not self.nullable:
-                return None, TypeError("'None' value but field is not nullable")
-
-            return None, None
-        return super().check_data_value(value)
-

lodel/leapi/datahandlers/data_fields/__init__.py

@@ -1 +0,0 @@
-

lodel/leapi/datahandlers/data_fields/bool.py

@@ -1,22 +0,0 @@
-# -*- coding: utf-8 -*-
-from ..data_field import DataField
-
-
-class DataHandler(DataField):
-
-    help = 'A basic boolean field'
-    base_type = 'bool'
-
-    ## @brief A boolean field
-    def __init__(self, **kwargs):
-        if 'check_data_value' not in kwargs:
-            kwargs['check_data_value'] = self.check_value
-        super().__init__(ftype='bool', **kwargs)
-
-    def _check_data_value(self, value):
-        error = None
-        try:
-            value = bool(value)
-        except(ValueError, TypeError):
-            error = TypeError("The value '%s' is not, and will never, be a boolean" % value)
-        return value, error

lodel/leapi/datahandlers/data_fields/datetime.py

@@ -1,17 +0,0 @@
-# -*- coding: utf-8 -*-
-from ..data_field import DataField
-
-
-class DataHandler(DataField):
-
-    help = 'A datetime field. Take two boolean options now_on_update and now_on_create'
-    base_type = 'datetime'
-
-    ## @brief A datetime field
-    # @param now_on_update bool : If true, the date is set to NOW on update
-    # @param now_on_create bool : If true, the date is set to NEW on creation
-    # @param **kwargs
-    def __init__(self, now_on_update=False, now_on_create=False, **kwargs):
-        self.now_on_update = now_on_update
-        self.now_on_create = now_on_create
-        super().__init__(**kwargs)

lodel/leapi/datahandlers/data_fields/file.py

@@ -1,14 +0,0 @@
-# -*- coding: utf-8 -*-
-from ..data_field import DataField
-
-
-class DataHandler(DataField):
-
-    base_type = 'file'
-
-    ## @brief a file field
-    # @param upload_path str : None by default
-    # @param **kwargs
-    def __init__(self, upload_path=None, **kwargs):
-        self.upload_path = upload_path
-        super().__init__(**kwargs)

lodel/leapi/datahandlers/data_fields/format.py

@@ -1,27 +0,0 @@
-# -*- coding: utf-8 -*-
-import warnings
-from .varchar import DataHandler as VarcharDataHandler
-
-
-class DataHandler(VarcharDataHandler):
-
-    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 max_length int : the maximum length of the handled value
-    # @param field_list list : List of field to use
-    # @param **kwargs
-    def __init__(self, format_string, field_list, max_length, **kwargs):
-        self._field_list = field_list
-        self._format_string = format_string
-        super().__init__(internal='automatic', max_length=max_length)
-
-
-    def can_override(self, data_handler):
-        if not super().can_override(data_handler):
-            return False
-        if data_handler.max_length != self.max_length:
-            return False
-        return True

lodel/leapi/datahandlers/data_fields/integer.py

@@ -1,20 +0,0 @@
-# -*- coding: utf-8 -*-
-from ..data_field import FieldDataHandler
-
-
-class DataHandler(FieldDataHandler):
-
-    help = 'Basic integer field'
-    base_type = 'int'
-
-    def __init__(self, **kwargs):
-        super().__init__(base_type='int', **kwargs)
-
-    def _check_data_value(self, value):
-        error = None
-        try:
-            value = int(value)
-        except(ValueError, TypeError):
-            error = TypeError("The value '%s' is not, and will never, be an integer" % value)
-        return value, error
-

lodel/leapi/datahandlers/data_fields/regexvarchar.py

@@ -1,34 +0,0 @@
-# -*- coding: utf-8 -*-
-import re
-from .varchar import DataHandler as VarcharDataHandler
-
-
-class DataHandler(VarcharDataHandler):
-
-    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())
-    # @param max_length int : the max length for this field (default : 10)
-    # @param **kwargs
-    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)
-
-    def _check_data_value(self, value):
-        error = None
-        if not self.compiled_re.match(value):
-            value = ''
-            error = TypeError('"%s" doesn\'t match the regex "%s"' % (value, self.regex))
-        return value, error
-
-    def can_override(self, data_handler):
-        if not super().can_override(data_handler):
-            return False
-
-        if data_handler.max_length != self.max_length:
-            return False
-        return True

lodel/leapi/datahandlers/data_fields/text.py

@@ -1,10 +0,0 @@
-# -*- coding: utf-8 -*-
-from ..data_field import DataField
-
-
-class DataHandler(DataField):
-    help = 'A text field (big string)'
-    base_type = 'text'
-
-    def __init__(self, **kwargs):
-        super(self.__class__, self).__init__(ftype='text', **kwargs)

lodel/leapi/datahandlers/data_fields/uid.py

@@ -1,18 +0,0 @@
-# -*- coding: utf-8 -*-
-from .integer import DataHandler as IntegerDataHandler
-
-
-class DataHandler(IntegerDataHandler):
-
-    help = 'Fieldtype designed to handle editorial model UID'
-    base_type = 'int'
-
-    ## @brief A uid field
-    # @param **kwargs
-    def __init__(self, is_id_class, **kwargs):
-        self._is_id_class = is_id_class
-        kwargs['internal'] = 'automatic'
-        super(self.__class__, self).__init__(is_id_class=is_id_class, **kwargs)
-
-    def _check_data_value(self, value):
-        return value, None

lodel/leapi/datahandlers/data_fields/varchar.py

@@ -1,24 +0,0 @@
-# -*- coding: utf-8 -*-
-from ..data_field import DataField
-
-
-class DataHandler(DataField):
-
-    help = 'Basic string (varchar) field. Default size is 64 characters'
-    base_type = 'char'
-
-    ## @brief A string field
-    # @brief max_length int: The maximum length of this field
-    def __init__(self, max_length=64, **kwargs):
-        self.max_length = int(max_length)
-        super().__init__(**kwargs)
-
-    ## @brief checks if this class can override the given data handler
-    # @param data_handler DataHandler
-    # @return bool
-    def can_override(self, data_handler):
-        if not super().can_override(data_handler):
-            return False
-        if data_handler.max_length != self.max_length:
-            return False
-        return True

lodel/leapi/datahandlers/datas.py

@@ -0,0 +1,74 @@
+#-*- coding: utf-8 -*-
+
+from lodel.leapi.datahandlers.datas_base import *
+
+## @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'
+    base_type = 'char'
+
+    ## @brief Build its content with a field list and a format string
+    # @param format_string str
+    # @param max_length int : the maximum length of the handled value
+    # @param field_list list : List of field to use
+    # @param **kwargs
+    def __init__(self, format_string, field_list, max_length, **kwargs):
+        self._field_list = field_list
+        self._format_string = format_string
+        super().__init__(internal='automatic', max_length=max_length)
+
+
+    def can_override(self, data_handler):
+        if not super().can_override(data_handler):
+            return False
+        if data_handler.max_length != self.max_length:
+            return False
+        return True
+
+## @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())
+    # @param max_length int : the max length for this field (default : 10)
+    # @param **kwargs
+    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)
+
+    def _check_data_value(self, value):
+        error = None
+        if not self.compiled_re.match(value):
+            value = ''
+            error = TypeError('"%s" doesn\'t match the regex "%s"' % (value, self.regex))
+        return value, error
+
+    def can_override(self, data_handler):
+        if not super().can_override(data_handler):
+            return False
+
+        if data_handler.max_length != self.max_length:
+            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
+    def __init__(self, is_id_class, **kwargs):
+        self._is_id_class = is_id_class
+        kwargs['internal'] = 'automatic'
+        super(self.__class__, self).__init__(is_id_class=is_id_class, **kwargs)
+
+    def _check_data_value(self, value):
+        return value, None

lodel/leapi/datahandlers/datas_base.py

@@ -0,0 +1,98 @@
+#-*- coding: utf-8 -*-
+import warnings
+
+from lodel.leapi.datahandlers.base_classes import DataField
+
+## @brief Data field designed to handle boolean values
+class Boolean(DataField):
+
+    help = 'A basic boolean field'
+    base_type = 'bool'
+
+    ## @brief A boolean field
+    def __init__(self, **kwargs):
+        if 'check_data_value' not in kwargs:
+            kwargs['check_data_value'] = self.check_value
+        super().__init__(ftype='bool', **kwargs)
+
+    def _check_data_value(self, value):
+        error = None
+        try:
+            value = bool(value)
+        except(ValueError, TypeError):
+            error = TypeError("The value '%s' is not, and will never, be a boolean" % value)
+        return value, error
+
+## @brief Data field designed to handle integer values
+class Integer(DataField):
+
+    help = 'Basic integer field'
+    base_type = 'int'
+
+    def __init__(self, **kwargs):
+        super().__init__(base_type='int', **kwargs)
+
+    def _check_data_value(self, value):
+        error = None
+        try:
+            value = int(value)
+        except(ValueError, TypeError):
+            error = TypeError("The value '%s' is not, and will never, be an integer" % value)
+        return value, error
+
+## @brief Data field designed to handle string
+class Varchar(DataField):
+
+    help = 'Basic string (varchar) field. Default size is 64 characters'
+    base_type = 'char'
+
+    ## @brief A string field
+    # @brief max_length int: The maximum length of this field
+    def __init__(self, max_length=64, **kwargs):
+        self.max_length = int(max_length)
+        super().__init__(**kwargs)
+
+    ## @brief checks if this class can override the given data handler
+    # @param data_handler DataHandler
+    # @return bool
+    def can_override(self, data_handler):
+        if not super().can_override(data_handler):
+            return False
+        if data_handler.max_length != self.max_length:
+            return False
+        return True
+
+## @brief Data field designed to handle date & time 
+class DateTime(DataField):
+
+    help = 'A datetime field. Take two boolean options now_on_update and now_on_create'
+    base_type = 'datetime'
+
+    ## @brief A datetime field
+    # @param now_on_update bool : If true, the date is set to NOW on update
+    # @param now_on_create bool : If true, the date is set to NEW on creation
+    # @param **kwargs
+    def __init__(self, now_on_update=False, now_on_create=False, **kwargs):
+        self.now_on_update = now_on_update
+        self.now_on_create = now_on_create
+        super().__init__(**kwargs)
+
+## @brief Data field designed to handle long string
+class Text(DataField):
+    help = 'A text field (big string)'
+    base_type = 'text'
+
+    def __init__(self, **kwargs):
+        super(self.__class__, self).__init__(ftype='text', **kwargs)
+
+## @brief Data field designed to handle Files
+class File(DataField):
+
+    base_type = 'file'
+
+    ## @brief a file field
+    # @param upload_path str : None by default
+    # @param **kwargs
+    def __init__(self, upload_path=None, **kwargs):
+        self.upload_path = upload_path
+        super().__init__(**kwargs)

lodel/leapi/datahandlers/field_data_handler.py

@@ -1,139 +0,0 @@
-# -*- coding: utf-8 -*-
-import importlib
-
-class FieldValidationError(Exception):
-    pass
-
-class FieldDataHandler(object):
-
-    help_text = 'Generic Field Data Handler'
-
-    ## @brief List fields that will be exposed to the construct_data_method
-    _construct_datas_deps = []
-
-    ## @brief constructor
-    # @param internal False | str : define whether or not a field is internal
-    # @param immutable bool : indicates if the fieldtype has to be defined in child classes of LeObject or if it is
-    #                         designed globally and immutable
-    # @param **args
-    # @throw NotImplementedError if it is instanciated directly
-    def __init__(self, internal=False, immutable=False, primary_key = False, **args):
-        if self.__class__ == FieldDataHandler:
-            raise NotImplementedError("Abstract class")
-        
-        self.primary_key = primary_key
-        self.internal = internal  # Check this value ?
-        self.immutable = bool(immutable)
-
-        for argname, argval in args.items():
-            setattr(self, argname, argval)
-
-
-    ## Fieldtype name
-    @staticmethod
-    def name(cls):
-        return cls.__module__.split('.')[-1]
-
-    def is_primary_key(self):
-        return self.primary_key
-
-    ## @brief checks if a fieldtype is internal
-    # @return bool
-    def is_internal(self):
-        return self.internal is not False
-
-    ## @brief calls the data_field defined _check_data_value() method
-    # @return tuple (value, error|None)
-    def check_data_value(self, value):
-        return self._check_data_value(value)
-
-    def _check_data_value(self, value):
-        return value, None
-
-    ## @brief checks if this class can override the given data handler
-    # @param data_handler DataHandler
-    # @return bool
-    def can_override(self, data_handler):
-        if data_handler.__class__.base_type != self.__class__.base_type:
-            return False
-        return True
-
-    ## @brief Build field value
-    # @param emcomponent EmComponent : An EmComponent child class instance
-    # @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
-        if fname in emcomponent_fields:
-            fname_data_handler = FieldDataHandler.from_name(emcomponent_fields[fname])
-
-        if fname in datas.keys():
-            return cur_value
-        elif fname_data_handler is not None and hasattr(fname_data_handler, 'default'):
-                return fname_data_handler.default
-        elif fname_data_handler is not None and fname_data_handler.nullable:
-                return None
-
-        return RuntimeError("Unable to construct data for field %s", fname)
-
-    ## @brief Check datas consistency
-    # @param emcomponent EmComponent : An EmComponent child class instance
-    # @param fname : the field name
-    # @param datas dict : dict storing fields values
-    # @return an Exception instance if fails else True
-    # @todo A implémenter
-    def check_data_consistency(self, emcomponent, fname, datas):
-        return True
-
-    ## @brief given a field type name, returns the associated python class
-    # @param fieldtype_name str : A field type name
-    # @return DataField child class
-    @staticmethod
-    def from_name(data_handler_name):
-        data_handler_name = data_handler_name.lower()
-        mod = None
-        for mname in FieldDataHandler.modules_name(data_handler_name):
-            try:
-                mod = importlib.import_module(mname)
-            except ImportError:
-                pass
-        if mod is None:
-            raise NameError("Unknown data_handler name : '%s'" % data_handler_name)
-        return mod.DataHandler
-    
-    ## @brief Return the module name to import in order to use the datahandler
-    # @param data_handler_name str : Data handler name
-    # @return a str
-    @staticmethod
-    def module_name(data_handler_name):
-        data_handler_name = data_handler_name.lower()
-        for mname in FieldDataHandler.modules_name(data_handler_name):
-            try:
-                mod = importlib.import_module(mname)
-                module_name = mname
-            except ImportError:
-                pass
-        if mod is None:
-            raise NameError("Unknown data_handler name : '%s'" % data_handler_name)
-        return module_name
-
-    ## @brief get a module name given a fieldtype name
-    # @param fieldtype_name str : a field type name
-    # @return a string representing a python module name
-    @staticmethod
-    def modules_name(fieldtype_name):
-        return (
-                'lodel.leapi.datahandlers.data_fields.%s' % fieldtype_name,
-                'lodel.leapi.datahandlers.references.%s' % fieldtype_name
-        )
-
-    ## @brief __hash__ implementation for fieldtypes
-    def __hash__(self):
-        hash_dats = [self.__class__.__module__]
-        for kdic in sorted([k for k in self.__dict__.keys() if not k.startswith('_')]):
-            hash_dats.append((kdic, getattr(self, kdic)))
-        return hash(tuple(hash_dats))

lodel/leapi/datahandlers/reference.py

@@ -1,29 +0,0 @@
-# -*- coding: utf-8 -*-
-from lodel.leapi.datahandlers.field_data_handler import FieldDataHandler, FieldValidationError
-from lodel.editorial_model.components import EmClass
-
-
-class Reference(FieldDataHandler):
-
-    ## @brief Instanciation
-    # @param allowed_classes list | None : list of allowed em classes if None no restriction
-    # @param internal bool : if False, the field is not internal
-    # @param **kwargs : other arguments
-    def __init__(self, allowed_classes = None, internal=False, **kwargs):
-        self.__allowed_classes = None if allowed_classes is None else set(allowed_classes)
-        super().__init__(internal=internal, **kwargs)
-
-    ## @brief Check value
-    # @param value *
-    # @return tuple(value, exception)
-    def _check_data_value(self, value):
-        if isinstance(value, EmClass):
-            value = [value]
-        for elt in value:
-            if not issubclass(elt.__class__, EmClass):
-                return None, FieldValidationError("Some elements of this references are not EmClass instances")
-            if self.__allowed_classes is not None:
-                if not isinstance(elt, self.__allowed_classes):
-                    return None, FieldValidationError("Some element of this references are not valids (don't fit with allowed_classes")
-        return value
-

lodel/leapi/datahandlers/references.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+from lodel.leapi.datahandlers.base_classes import Reference, MultipleRef, SingleRef
+
+class Link(SingleRef): pass
+
+## @brief Child class of MultipleRef where references are represented in the form of a python list
+class List(MultipleRef):
+
+    ## @brief instanciates a list reference
+    # @param allowed_classes list | None : list of allowed em classes if None no restriction
+    # @param internal bool
+    # @param kwargs
+    def __init__(self, allowed_classes=None, internal=False, **kwargs):
+        super().__init__(allowed_classes=allowed_classes, internal=internal, **kwargs)
+
+    ## @brief Check value
+    # @param value *
+    # @return tuple(value, exception)
+    def _check_data_value(self, value):
+        val, expt = super()._check_data_value()
+        if not isinstance(expt, Exception):
+            val = list(val)
+        return val, expt
+
+
+## @brief Child class of MultipleRef where references are represented in the form of a python set
+class Set(MultipleRef):
+
+    ## @brief instanciates a set reference
+    # @param allowed_classes list | None : list of allowed em classes if None no restriction
+    # @param internal bool : if False, the field is not internal
+    # @param kwargs : Other named arguments
+    def __init__(self, allowed_classes=None, internal=False, **kwargs):
+        super().__init__(allowed_classes=allowed_classes, internal=internal, **kwargs)
+
+    ## @brief Check value
+    # @param value *
+    # @return tuple(value, exception)
+    def _check_data_value(self, value):
+        val, expt = super()._check_data_value()
+        if not isinstance(expt, Exception):
+            val = set(val)
+        return val, expt
+
+
+## @brief Child class of MultipleRef where references are represented in the form of a python dict
+class Map(MultipleRef):
+
+    ## @brief instanciates a dict reference
+    # @param allowed_classes list | None : list of allowed em classes if None no restriction
+    # @param internal bool : if False, the field is not internal
+    # @param kwargs : Other named arguments
+    def __init__(self, allowed_classes=None, internal=False, **kwargs):
+        super().__init__(allowed_classes=allowed_classes, internal=internal, **kwargs)
+
+    ## @brief Check value
+    # @param value *
+    # @return tuple(value, exception)
+    def _check_data_value(self, value):
+        if not isinstance(value, dict):
+            return None, FieldValidationError("Values for dict fields should be dict")
+        val, expt = super()._check_data_value(value.values())
+        return (
+                None if isinstance(expt, Exception) else value,
+                expt)

lodel/leapi/datahandlers/references/__init__.py

@@ -1 +0,0 @@
-__author__ = 'roland'

lodel/leapi/datahandlers/references/dict.py

@@ -1,25 +0,0 @@
-# -*- coding: utf-8 -*-
-from lodel.leapi.datahandlers.field_data_handler import FieldValidationError
-from lodel.leapi.datahandlers.reference import Reference
-from lodel.editorial_model.components import EmClass
-
-
-class DataHandler(Reference):
-
-    ## @brief instanciates a dict reference
-    # @param allowed_classes list | None : list of allowed em classes if None no restriction
-    # @param internal bool : if False, the field is not internal
-    # @param kwargs : Other named arguments
-    def __init__(self, allowed_classes=None, internal=False, **kwargs):
-        super().__init__(allowed_classes=allowed_classes, internal=internal, **kwargs)
-
-    ## @brief Check value
-    # @param value *
-    # @return tuple(value, exception)
-    def _check_data_value(self, value):
-        if not isinstance(value, dict):
-            return None, FieldValidationError("Values for dict fields should be dict")
-        val, expt = super()._check_data_value(value.values())
-        return (
-                None if isinstance(expt, Exception) else value,
-                expt)

lodel/leapi/datahandlers/references/link.py

@@ -1,13 +0,0 @@
-# -*- coding: utf-8 -*-
-from lodel.leapi.datahandlers.reference import Reference
-from lodel.editorial_model.components import EmClass
-
-
-class DataHandler(Reference):
-
-    ## @brief instanciates a link reference
-    # @param allowed_classes list | None : list of allowed em classes if None no restriction
-    # @param internal bool : if False, the field is not internal
-    # @param kwargs : Other named arguments
-    def __init__(self, allowed_classes=None, internal=False, **kwargs):
-        super().__init__(allowed_classes=allowed_classes, internal=internal, **kwargs)

lodel/leapi/datahandlers/references/list.py

@@ -1,23 +0,0 @@
-# -*- coding: utf-8 -*-
-from lodel.leapi.datahandlers.field_data_handler import FieldValidationError
-from lodel.editorial_model.components import EmClass
-from lodel.leapi.datahandlers.reference import Reference
-
-
-class DataHandler(Reference):
-
-    ## @brief instanciates a list reference
-    # @param allowed_classes list | None : list of allowed em classes if None no restriction
-    # @param internal bool
-    # @param kwargs
-    def __init__(self, allowed_classes=None, internal=False, **kwargs):
-        super().__init__(allowed_classes=allowed_classes, internal=internal, **kwargs)
-
-    ## @brief Check value
-    # @param value *
-    # @return tuple(value, exception)
-    def _check_data_value(self, value):
-        val, expt = super()._check_data_value()
-        if not isinstance(expt, Exception):
-            val = list(val)
-        return val, expt

lodel/leapi/datahandlers/references/multiple.py

@@ -1,10 +0,0 @@
-#-*- coding: utf-8 -*-
-from lodel.leapi.datahandlers.reference import Reference
-from lodel.editorial_model.components import EmClass
-
-## @brief This class represent a data_handler for multiple references to another object
-class MultipleRef(Reference):
-    
-    def __init__(self, allowed_classes = None, **kwargs):
-        super().__init__(allowed_classes = allowed_classes
-    

lodel/leapi/datahandlers/references/relation.py

@@ -1,22 +0,0 @@
-# -*- coding: utf-8 -*-
-from lodel.leapi.datahandlers.field_data_handler import FieldDataHandler
-
-
-class DataHandler(FieldDataHandler):
-
-    ## @brief Instanciates a Relation object
-    # @param datahandler FieldDataHandler
-    # @param datahandler_args dict
-    # @param reference EmField
-    # @param kwargs
-    def __init__(self, **kwargs):
-        # Data Handler
-        data_handler = kwargs['data_handler_kwargs']['data_handler']
-        data_handler_args = kwargs['data_handler_kwargs']
-        data_handler_class = FieldDataHandler.from_name(data_handler)
-        self.data_handler = data_handler_class(**data_handler_args)
-
-        # Reference
-        self.backref_ref = kwargs['data_handler_kwargs']['backreference']
-
-        super().__init__(**kwargs)

lodel/leapi/datahandlers/references/set.py

@@ -1,22 +0,0 @@
-# -*- coding: utf-8 -*-
-from lodel.editorial_model.components import EmClass
-from lodel.leapi.datahandlers.reference import Reference
-
-
-class DataHandler(Reference):
-
-    ## @brief instanciates a set reference
-    # @param allowed_classes list | None : list of allowed em classes if None no restriction
-    # @param internal bool : if False, the field is not internal
-    # @param kwargs : Other named arguments
-    def __init__(self, allowed_classes=None, internal=False, **kwargs):
-        super().__init__(allowed_classes=allowed_classes, internal=internal, **kwargs)
-
-    ## @brief adds a referenced element
-    # @param emclass EmClass
-    # @return bool
-    def add_ref(self, emclass):
-        if isinstance(emclass, EmClass):
-            self._refs.add(emclass)
-            return True
-        return False

lodel/leapi/datahandlers/references/single.py

@@ -1,17 +0,0 @@
-#-*- coding: utf-8 -*-
-from lodel.leapi.datahandlers.reference import Reference
-from lodel.editorial_model.components import EmClass
-
-## @brief This class represent a data_handler for single reference to another object
-class SingleRef(Reference):
-    
-    def __init__(self, allowed_classes = None, **kwargs):
-        super().__init__(allowed_classes = allowed_classes
- 
-    def _check_data_value(self, value):
-        val, expt = super()._check_data_value(value)
-        if not isinstance(expt, Exception):
-            if len(val) > 1:
-               return None, FieldValidationError("Only single values are allowed for SingleRef fields")
-        return val, expt
-    

lodel/leapi/lefactory.py

@@ -3,14 +3,16 @@
 import functools
 from lodel.editorial_model.components import *
 from lodel.leapi.leobject import LeObject
-from lodel.leapi.datahandlers.field_data_handler import FieldDataHandler
+from lodel.leapi.datahandlers.base_classes import DataHandler
 
 ## @brief Generate python module code from a given model
 # @param model lodel.editorial_model.model.EditorialModel
 def dyncode_from_em(model):
     
     cls_code, modules, bootstrap_instr = generate_classes(model)
-    imports = "from lodel.leapi.leobject import LeObject\n"
+    imports = """from lodel.leapi.leobject import LeObject
+from lodel.leapi.datahandlers.base_classes import DataField
+"""
     for module in modules:
         imports += "import %s\n" % module
 
@@ -49,11 +51,11 @@ def emclass_sorted_by_deps(emclass_list):
 
 ## @brief Given an EmField returns the data_handler constructor suitable for dynamic code
 def data_handler_constructor(emfield):
-    dh_module_name = FieldDataHandler.module_name(emfield.data_handler_name)+'.DataHandler'
+    #dh_module_name = DataHandler.module_name(emfield.data_handler_name)+'.DataHandler'
+    get_handler_class_instr = 'DataField.from_name(%s)' % repr(emfield.data_handler_name)
     options = []
 
-    #dh_kwargs =  '{' + (', '.join(['%s: %s' % (repr(name), forge_optval(val)) for name, val in emfield.data_handler_options.items()])) + '}'
-    return ('%s(**{' % dh_module_name)+(', '.join([repr(name)+': '+forge_optval(val) for name, val in emfield.data_handler_options.items()])) + '})'
+    return ('%s(**{' % get_handler_class_instr)+(', '.join([repr(name)+': '+forge_optval(val) for name, val in emfield.data_handler_options.items()])) + '})'
             
 
 def forge_optval(optval):
@@ -87,7 +89,6 @@ def generate_classes(model):
         parents = list()    # List of parents EmClass
         # Determine pk
         for field in em_class.fields():
-            imports.append(FieldDataHandler.module_name(field.data_handler_name))
             if field.data_handler_instance.is_primary_key():
                 uid.append(field.uid)
         # Determine parent for inheritance