Merge branch 'fieldtypes' with the new EmField processing

Conflicts:
	EditorialModel/model.py
	EditorialModel/test/me.json

.gitignore

 .idea
 Lodel/settings/locale.py
 Lodel/settings/local.py
-doc
+doc
+.*.swp

EditorialModel/backend/graphviz.py

 # -*- coding: utf-8 -*-
 
 import datetime
+import EditorialModel
 from EditorialModel.classtypes import EmClassType
 from EditorialModel.fieldgroups import EmFieldGroup
 from EditorialModel.types import EmType
             for f in c.fields():
                 if ((cn == 'EmType' and f.optional) or (cn == 'EmFieldGroup' and not f.optional)) and f.rel_field_id is None:
                     
-                    if not (f.rel_to_type_id is None):
+                    #if not (f.rel_to_type_id is None):
+                    if isinstance(f, EditorialModel.fieldtypes.rel2type.EmFieldRel2Type):
                         rel_node_id = '%s%s'%(EmBackendGraphviz._component_id(c), EmBackendGraphviz._component_id(em.component(f.rel_to_type_id)))
 
                         rel_node = '\t%s [ label="rel_to_type'%rel_node_id
                     if first:
                         ret += ' { '
                         first = False
-                    if not (f.rel_to_type_id is None):
+                    #if not (f.rel_to_type_id is None):
+                    if isinstance(f, EditorialModel.fieldtypes.rel2type.EmFieldRel2Type):
                         ret += '<f%d> '%cntref
                         cntref += 1
                     ret += f.name

EditorialModel/backend/json_backend.py

 import json
 import datetime
 from Lodel.utils.mlstring import MlString
+import EditorialModel
 
 
 def date_cast(date):
     if len(date):
-        return datetime.datetime(date)
+        return datetime.datetime.strptime(date, '%c')
     else:
         return None
 
 
+## @brief dirty obsolote cast function
 def int_or_none(i):
-    if len(i):
+    if isinstance(i, int):
+        return i
+    elif i is None:
+        return None
+    elif len(i):
         return int(i)
     else:
         return None
     #
     # @param json_file str: path to the json_file used as data source
     def __init__(self, json_file):
-        with open(json_file) as json_data:
-            self.data = json.loads(json_data.read())
+        self.json_file = json_file
+        pass
+
+    @staticmethod
+    ## @brief Used by json.dumps to serialize date and datetime
+    def date_handler(obj):
+        return obj.strftime('%c') if isinstance(obj, datetime.datetime) or isinstance(obj, datetime.date) else None
+
 
     ## Loads the data in the data source json file
     #
     # @return list
     def load(self):
         data = {}
-        for index, component in self.data.items():
-            attributes = {}
-            for attr_name, attr_value in component.items():
-                if attr_name in EmBackendJson.cast_methods:
-                    attributes[attr_name] = EmBackendJson.cast_methods[attr_name](attr_value)
-                else:
-                    attributes[attr_name] = attr_value
-            data[int(index)] = attributes
+        with open(self.json_file) as json_data:
+            rdata = json.loads(json_data.read())
+            for index, component in rdata.items():
+                attributes = {}
+                for attr_name, attr_value in component.items():
+                    if attr_name in EmBackendJson.cast_methods:
+                        attributes[attr_name] = EmBackendJson.cast_methods[attr_name](attr_value)
+                    else:
+                        attributes[attr_name] = attr_value
+                data[int(index)] = attributes
         return data
 
     ## Saves the data in the data source json file
-    #
-    # @return bool
-    # @todo à implémenter
-    def save(self, em):
-        return True
+    # @param filename str : The filename to save the EM in (if None use self.json_file provided at init )
+    def save(self, em, filename = None):
+        with open(self.json_file if filename is None else filename, 'w') as fp:
+            fp.write(json.dumps({ component.uid : component.dumps() for component in em.components() }, default=self.date_handler))
+

EditorialModel/components.py

 from collections import OrderedDict
 import hashlib
 
-import EditorialModel.fieldtypes as ftypes
+import EditorialModel
 from EditorialModel.exceptions import *
 from Lodel.utils.mlstring import MlString
 
     ## @brief Return a dict with attributes name as key and attributes value as value
     # @note Used at creation and deletion to call the migration handler
     def attr_dump(self):
-        return {fname: fval for fname, fval in self.__dict__.items() if not (fname.startswith('__') or (fname == 'uid'))}
+        return {fname: fval for fname, fval in self.__dict__.items() if not (fname.startswith('_') or (fname == 'uid'))}
 
     @property
     ## @brief Provide a uniq name
     # Identify a component with his type and name
     def uniq_name(self):
         uname = self.__class__.__name__
-        try:
-            uname += '_'+self.em_class.name
-        except AttributeError: pass
+        if not isinstance(self, EditorialModel.fields.EmField):
+            try:
+                uname += '_'+self.em_class.name
+            except AttributeError: pass
         uname += '_'+self.name
         return uname
         
+    ## @brief dumps attr for serialization
+    def dumps(self):
+        #attr =  {fname: fval for fname, fval in self.__dict__.items() if not (fname.startswith('_'))}
+        attr = self.attr_dump
+        del(attr['model'])
+        for attr_f in attr:
+            if isinstance(attr[attr_f], EmComponent):
+                attr[attr_f] = attr[attr_f].uid
+            elif isinstance(attr[attr_f], MlString):
+                attr[attr_f] = attr[attr_f].__str__()
+        if isinstance(self, EditorialModel.fields.EmField):
+            attr['component'] = 'EmField'
+            attr['type'] = self.fieldtype
+        else:
+            attr['component'] = self.__class__.__name__
+        return attr
+
     ## @brief This function has to be called after the instanciation, checks, and init manipulations are done
     # @note Create a new attribute _inited that allow __setattr__ to know if it has or not to call the migration handler
     def init_ended(self):

EditorialModel/fields.py

 #-*- coding: utf-8 -*-
 
+import importlib
+import warnings
+
 from EditorialModel.components import EmComponent
 from EditorialModel.exceptions import EmComponentCheckError
 import EditorialModel
+import EditorialModel.fieldtypes
 from django.db import models
 
 ## EmField (Class)
 
     ranked_in = 'fieldgroup_id'
 
-    fieldtypes = {
-        'int': models.IntegerField,
-        'integer': models.IntegerField,
-        'bigint': models.BigIntegerField,
-        'smallint': models.SmallIntegerField,
-        'boolean': models.BooleanField,
-        'bool': models.BooleanField,
-        'float': models.FloatField,
-        'char': models.CharField,
-        'varchar': models.CharField,
-        'text': models.TextField,
-        'time': models.TimeField,
-        'date': models.DateField,
-        'datetime': models.DateTimeField,
-    }
+    ftype = None
+    help = 'Default help text'
 
     ## Instanciate a new EmField
     # @todo define and test type for icon and fieldtype
-    def __init__(self, model, uid, name, fieldgroup_id, fieldtype, optional=False, internal=False, rel_to_type_id=None, rel_field_id=None, icon='0', string=None, help_text=None, date_update=None, date_create=None, rank=None, **kwargs):
+    # @warning nullable == True by default
+    def __init__(self, model, uid, name, fieldgroup_id, fieldtype, optional=False, internal=False, rel_field_id=None, icon='0', string=None, help_text=None, date_update=None, date_create=None, rank=None, nullable = True, default = None, uniq = False, **kwargs):
+
+        if self.ftype == None:
+            raise NotImplementedError("Trying to instanciate an EmField and not one of the fieldtypes child classes")
 
         self.fieldgroup_id = fieldgroup_id
         self.check_type('fieldgroup_id', int)
-        self.fieldtype = fieldtype
         self.optional = optional
         self.check_type('optional', bool)
         self.internal = internal
         self.check_type('internal', bool)
-        self.rel_to_type_id = rel_to_type_id
-        self.check_type('rel_to_type_id', (int, type(None)))
         self.rel_field_id = rel_field_id
         self.check_type('rel_field_id', (int, type(None)))
         self.icon = icon
-        self.options = kwargs
+
+
+        #Field type elements
+        self.fieldtype = fieldtype
+        self.nullable = nullable
+        self.default = default
+        self.uniq = uniq
+
+        if len(kwargs) > 0:
+            for kwargs_f in kwargs:
+                warnings.warn("Argument '%s' not used and will be invalid for EmField __init__"%kwargs_f,SyntaxWarning)
+            
 
         super(EmField, self).__init__(model=model, uid=uid, name=name, string=string, help_text=help_text, date_update=date_update, date_create=date_create, rank=rank)
 
+    @staticmethod
+    ## @brief Return an EmField subclass given a wanted field type
+    # @return An EmField subclass
+    # @throw When not found
+    # @see EmField::fieldtypes()
+    def get_field_class(ftype, **kwargs):
+        ftype_module = importlib.import_module('EditorialModel.fieldtypes.%s'%ftype)
+        return ftype_module.fclass
+
+    @staticmethod
+    ## @brief Return the list of allowed field type
+    def fieldtypes_list():
+        return [ f for f in EditorialModel.fieldtypes.__all__ if f != '__init__' ]
+
+    ## @brief Abstract method that should return a validation function
+    # @param raise_e Exception : if not valid raise this exception
+    # @param ret_valid : if valid return this value
+    # @param ret_invalid : if not valid return this value
+    def validation_function(self, raise_e = None, ret_valid = None, ret_invalid = None):
+        if self.__class__ == EmField:
+            raise NotImplementedError("Abstract method")
+        if raise_e is None and ret_valid is None:
+            raise AttributeError("Behavior doesn't allows to return a valid validation function")
+
+        return False
+            
+
     ## @brief Return the list of relation fields for a rel_to_type
     # @return None if the field is not a rel_to_type else return a list of EmField
     def rel_to_type_fields(self):
     def delete_check(self):
         return True
 
-    def to_django(self):
-        if self.fieldtype in ('varchar', 'char'):
-            max_length = None if 'max_length' not in self.options else self.options['max_length']
-            return self.fieldtypes[self.fieldtype](max_length=max_length, **self.options)
-
-        if self.fieldtype in ('time', 'datetime', 'date'):
-            auto_now = False if 'auto_now' not in self.options else self.options['auto_now']
-            auto_now_add = False if 'auto_now_add' not in self.options else self.options['auto_now_add']
-            return self.fieldtypes[self.fieldtype](auto_now=auto_now, auto_now_add=auto_now_add, **self.options)
-
-        if self.fieldtype == 'boolean' and ('nullable' in self.options and self.options['nullable'] == 1):
-            return models.NullBooleanField(**self.options)
-
-        return self.fieldtypes[self.fieldtype](**self.options)

EditorialModel/fieldtypes.py

-#-*- coding: utf-8 -*-
-
-from django.db import models
-import re
-import datetime
-import json
-import importlib
-import copy
-import EditorialModel
-from Lodel.utils.mlstring import MlString
-
-
-## @brief Characterise fields for LeObject and EmComponent
-# This class handles values rules for LeObject and EmComponents.
-#
-# It allows to EmFieldValue classes family to have rules to cast, validate and save values.
-#
-# There is exposed methods that allows LeObject and EmType to run a save sequence. This methods are :
-# - EmFieldType.to_value() That cast a value to an EmFieldType internal storage
-# - EmFieldType.is_valid() That indicates wether or not a value is valid
-# - EmFieldType.pre_save() That returns weighted SQL request that must be run before any value save @ref EditorialModel::types::EmType.save_values()
-# - EmFieldType.to_sql() That returns a value that can be inserted in database.
-# - EmFieldType.post_save() That returns weighted SQL request that must be run after any value save @ref EditorialModel::types::EmType.save_values()
-#
-class EmFieldType(object):
-
-    ## Stores options and default value for EmFieldType
-    # options list :
-    # - type (str|None) : if None will make an 'abstract' fieldtype (with no value assignement possible)
-    # - nullable (bool) : tell whether or not a fieldType accept NULL value
-    # - default (mixed) : The default value for a FieldType
-    # - primarykey (bool) : If true the fieldType represent a PK
-    # - autoincrement (bool) : If true the fieldType will be autoincremented
-    # - index (bool) : If true the columns will be indexed in Db
-    # - name (str) : FieldType name
-    # - doc (str) : FieldType documentation
-    # - onupdate (callable) : A callback to call on_update
-    # - valueobject (EmFieldValue or childs) : An object that represent values for this fieldType
-    # - type_* (mixed) : Use to construct an options dictinnary for a type (exemple : type_length => nnewColumn(lenght= [type_lenght VALUE] )) @ref EmFieldSQLType
-    # - validators (list) : List of validator functions to use
-    _opt = {
-        'name': None,
-        'type': None,
-        'nullable': True,
-        'default': None,
-        'primarykey': False,
-        'autoincrement': False,
-        'uniq': False,
-        'index': False,
-        'doc': None,
-        'onupdate': None,
-        'valueobject': None,
-        'validators': None
-    }
-
-    ## Instanciate an EmFieldType
-    # For arguments see @ref EmFieldType::_opt
-    # @see EmFieldType::_opt
-    def __init__(self, **kwargs):
-        self.__init(kwargs)
-        self.type_options = dict()
-
-        # stores all col_* arguments into the self.type_options dictionary
-        args = kwargs.copy()
-        for optname in args:
-            type_opt = re.sub(r'^type_', '', optname)
-            if type_opt != optname:
-                self.type_options[type_opt] = args[optname]
-                del kwargs[optname]
-
-        # checks if the other arguments are valid
-        if len(set(kwargs.keys()) - set(self.__class__._opt.keys())) > 0:
-            badargs = ""
-            for bad in set(kwargs.keys()) - set(self.__class__._opt.keys()):
-                badargs += " " + bad
-            raise TypeError("Unexpected arguments : %s" % badargs)
-
-        # stores other arguments as instance attribute
-        for opt_name in self.__class__._opt:
-            setattr(self, opt_name, (kwargs[opt_name] if opt_name in kwargs else self.__class__._opt[opt_name]))
-
-        # checks type's options valididty
-        if self.type != None:
-            try:
-                EmFieldSQLType.sqlType(self.type, **self.type_options)
-            except TypeError as e:
-                raise e
-
-        # Default value for name
-        if self.name == None:
-            if  self.__class__ == EmFieldType:
-                self.name = 'generic'
-            else:
-                self.name = self.__class__.__name__
-
-        # Default value for doc
-        if self.doc == None:
-            if self.__class__ == EmFieldType:
-                self.doc = 'Abstract generic EmFieldType'
-            else:
-                self.doc = self.__class__.__name__
-
-    ## MUST be called first in each constructor
-    # @todo this solution is not good (look at the __init__ for EmFieldType childs)
-    def __init(self, kwargs):
-        try:
-            self.args_copy
-        except AttributeError:
-            self.args_copy = kwargs.copy()
-
-    @property
-    ## A predicate that indicates whether or not an EmFieldType is "abstract"
-    def is_abstract(self):
-        return (self.type == None)
-
-    ## Returns a copy of the current EmFieldType
-    def copy(self):
-        args = self.args_copy.copy()
-        return self.__class__(**args)
-
-    def dump_opt(self):
-        return json.dumps(self.args_copy)
-
-    @staticmethod
-    ## Return an instance from a classname and options from dump_opt
-    # @param classname str: The EmFieldType class name
-    # @param json_opt str: getted from dump_opt
-    def restore(colname, classname, json_opt):
-        field_type_class = getattr(EditorialModel.fieldtypes, classname)
-        init_opt = json.loads(json_opt)
-        init_opt['name'] = colname
-        return field_type_class(**init_opt)
-
-    ## Return a value object 'driven' by this EmFieldType
-    # @param name str: The column name associated with the value
-    # @param *init_val mixed: If given this will be the initialisation value
-    # @return a EmFieldValue instance
-    # @todo better default value (and bad values) handling
-    def valueObject(self, name, *init_val):
-        if self.valueObject == None:
-            return EmFieldValue(name, self, *init_val)
-        return self.valueObject(name, self, *init_val)
-
-    ## Cast to the correct value
-    # @param v mixed : the value to cast
-    # @return A gently casted value
-    # @throw ValueError if v is innapropriate
-    # @throw NotImplementedError if self is an abstract EmFieldType
-    def to_value(self, v):
-        if self.type == None:
-            raise NotImplemented("This EmFieldType is abstract")
-        if v == None and not self.nullable:
-            raise TypeError("Field not nullable")
-        return v
-
-    ## to_value alias
-    # @param value mixed : the value to cast
-    # @return A casted value
-    def from_string(self, value):
-        return self.to_value(value)
-
-    ## Returns a gently sql forged value
-    # @return A sql forged value
-    # @warning It assumes that the value is correct and comes from an EmFieldValue object
-    def to_sql(self, value):
-        if self.is_abstract:
-            raise NotImplementedError("This EmFieldType is abstract")
-        return True
-
-    ## Returns whether or not a value is valid for this EmFieldType
-    # @note This function always returns True and is here for being overloaded  by child objects
-    # @return A boolean, True if valid else False
-    def is_valid(self, value):
-        if self.is_abstract:
-            raise NotImplementedError("This EmFieldType is abstract")
-        return True
-
-    ## Pre-save actions
-    def pre_save(self):
-        if self.is_abstract:
-            raise NotImplementedError("This EmFieldType is abstract")
-        return []
-
-    ## Post-save actions
-    def post_save(self):
-        if self.is_abstract:
-            raise NotImplementedError("This EmFieldType is abstract")
-        return []
-
-    @classmethod
-    ## Function designed to be called by child class to enforce a type
-    # @param args dict: The kwargs argument of __init__
-    # @param typename str: The typename to enforce
-    # @return The new kwargs to be used
-    # @throw TypeError if type is present is args
-    def _setType(cl, args, typename):
-        return cl._argEnforce(args, 'type', typename, True)
-
-    @classmethod
-    ## Function designed to be called by child's constructo to enforce an argument
-    # @param args dict: The constructor's kwargs
-    # @param argname str: The name of the argument to enforce
-    # @param argval mixed: The value we want to enforce
-    # @param Return a new kwargs
-    # @throw TypeError if type is present is args and exception argument is True
-    def _argEnforce(cl, args, argname, argval, exception=True):
-        if exception and argname in args:
-            raise TypeError("Invalid argument '"+argname+"' for "+cl.__class__.__name__+" __init__")
-        args[argname] = argval
-        return args
-
-    @classmethod
-    ## Function designed to be called by child's constructor to set a default value
-    # @param args dict: The constructor's kwargs
-    # @param argname str: The name of the argument with default value
-    # @param argval mixed : The default value
-    # @return a new kwargs dict
-    def _argDefault(cl, args, argname, argval):
-        if argname not in args:
-            args[argname] = argval
-        return args
-
-class EmFieldValue(object):
-
-    ## Instanciates a EmFieldValue
-    # @param name str : The column name associated with this value
-    # @param fieldtype EmFieldType: The EmFieldType defining the value
-    # @param *value *list: This argument allow to pass a value to set (even None) and to detect if no value given to set to EmFieldType's default value
-    # @throw TypeError if more than 2 arguments given
-    # @throw TypeError if fieldtype is not an EmFieldType
-    # @throw TypeError if fieldtype is an abstract EmFieldType
-    def __init__(self, name, fieldtype, *value):
-        if not isinstance(fieldtype, EmFieldType):
-            raise TypeError("Expected <class EmFieldType> for 'fieldtype' argument, but got : %s instead" % str(type(fieldtype)))
-        if fieldtype.is_abstract:
-            raise TypeError("The given fieldtype in argument is abstract.")
-
-        # This copy ensures that the fieldtype will not change during the value lifecycle
-        super(EmFieldValue, self).__setattr__('fieldtype', fieldtype.copy())
-
-        if len(value) > 1:
-            raise TypeError("Accept only 2 positionnal parameters. %s given." % str(len(value)+1))
-        elif len(value) == 1:
-            self.value = value[0]
-        else:
-            self.value = fieldtype.default
-
-        # Use this to set value in the constructor
-        setv = super(EmFieldValue, self).__setattr__
-        # This copy makes column attributes accessible easily
-        for attrname in self.fieldtype.__dict__:
-            setv(attrname, getattr(self.fieldtype, attrname))
-
-        # Assign some EmFieldType methods to the value
-        setv('from_python', self.fieldtype.to_value)
-        setv('from_string', self.fieldtype.to_value)
-        #setv('sqlCol', self.fieldtype.sqlCol)
-
-    ## The only writable attribute of EmFieldValue is the value
-    # @param name str: Have to be value
-    # @param value mixed: The value to set
-    # @throw AtrributeError if another attribute than value is to be set
-    # @throw ValueError if self.to_value raises it
-    # @see EmFieldType::to_value()
-    def __setattr__(self, name, value):
-        if name != "value":
-            raise AttributeError("EmFieldValue has only the value property settable")
-        super(EmFieldValue,self).__setattr__('value', self.fieldtype.to_value(value))
-
-        ##
-    # @warning When getting the fieldtype you actually get a copy of it to prevent any modifications !
-    def __getattr__(self, name):
-        if name == 'fieldtype':
-            return self.fieldtype.copy()
-        return super(EmFieldValue, self).__getattribute__(name)
-
-    ## @brief Return a valid SQL value
-    #
-    # Can be used to convert any value (giving one positionnal argument) or to return the current value
-    # @param *value list: If a positionnal argument is given return it and not the instance value
-    # @return A value suitable for sql
-    def to_sql(self, *value):
-        if len(value) > 1:
-            raise TypeError("Excepted 0 or 1 positional argument but got "+str(len(value)))
-        elif len(value) == 1:
-            return self.fieldtype.to_sql(value[0])
-        return self.fieldtype.to_sql(self.value)
-
-class EmFieldSQLType(object):
-    _integer = {'sql': models.IntegerField}
-    _bigint = {'sql': models.BigIntegerField}
-    _smallint = {'sql': models.SmallIntegerField}
-    _boolean = {'sql': models.BooleanField}
-    _nullableboolean = {'sql': models.NullBooleanField}
-    _float = {'sql': models.FloatField}
-    _varchar = {'sql': models.CharField}
-    _text = {'sql': models.TextField}
-    _time = {'sql': models.TimeField}
-    _date = {'sql': models.DateField}
-    _datetime = {'sql': models.DateTimeField}
-
-    _names = {
-        'int': _integer,
-        'integer': _integer,
-        'bigint': _bigint,
-        'smallint': _smallint,
-        'boolean': _boolean,
-        'bool': _boolean,
-        'float': _float,
-        'char': _varchar,
-        'varchar': _varchar,
-        'text': _text,
-        'time': _time,
-        'date': _date,
-        'datetime': _datetime,
-    }
-
-    @classmethod
-    def sqlType(cls, name, **kwargs):
-        if not isinstance(name, str):
-            raise TypeError("Expect <class str>, <class int>|None but got : %s %s" % (str(type(name)), str(type(size))))
-        name = name.lower()
-        if name not in cls._names:
-            raise ValueError("Unknown type '%s'" % name)
-
-        if name in ['boolean','bool'] and kwargs['nullable'] in [1,'true']:
-            sqlclass = _nullableboolean
-        else:
-            sqlclass = cls._names[name]
-
-        if len(kwargs) == 0:
-            return sqlclass['sql']
-
-        return sqlclass['sql'](**kwargs)
-
-
-## @brief Represents values with common arithmetic operations
-class EmFieldValue_int(EmFieldValue):
-    def __int__(self):
-        return self.value
-
-    def __add__(self, other):
-        return self.value + other
-
-    def __sub__(self, other):
-        return self.value - other
-
-    def __mul__(self, other):
-        return self.value * other
-
-    def __div__(self, other):
-        return self.value / other
-
-    def __mod__(self, other):
-        return self.value % other
-
-    def __iadd__(self, other):
-        self.value = int(self.value + other)
-        return self
-
-    def __isub__(self, other):
-        self.value = int(self.value - other)
-        return self
-
-    def __imul__(self, other):
-        self.value = int(self.value * other)
-        return self
-
-    def __idiv__(self, other):
-        self.value = int(self.value / other)
-        return self
-
-
-## @brief Handles integer fields
-# @note Enforcing type to be int
-# @note Default name is 'integer' and default 'valueobject' is EmFieldValue_int
-class EmField_integer(EmFieldType):
-
-    def __init__(self, **kwargs):
-        self._init(kwargs)
-        # Default name
-        kwargs = self.__class__._argDefault(kwargs, 'name', 'integer')
-        # Default value object
-        kwargs = self.__class__._argDefault(kwargs, 'valueobject', EmFieldValue_int)
-        # Type enforcing
-        kwargs = self.__class__._setType(kwargs, 'int')
-        super(EmField_integer, self).__init__(**kwargs)
-
-    ##
-    # @todo catch cast error ?
-    #def to_sql(self, value):
-    #    return value
-
-    def to_value(self, value):
-        if value == None:
-            return super(EmField_integer, self).to_value(value)
-        return int(value)
-
-
-## @brief Handles boolean fields
-# @note Enforce type to be 'boolean'
-# @note Default name is 'boolean'
-class EmField_boolean(EmFieldType):
-    def __init__(self, **kwargs):
-        self._init(kwargs)
-        #Default name
-        kwargs = self.__class__._argDefault(kwargs, 'name', 'boolean')
-        #Type enforcing
-        kwargs = self.__class__._setType(kwargs, 'boolean')
-        super(EmField_boolean, self).__init__(**kwargs)
-
-    #def to_sql(self, value):
-    #    return 1 if super(EmField_boolean, self).to_sql(value) else 0
-
-    def to_value(self, value):
-        if value == None:
-            return super(EmField_boolean, self).to_value(value)
-        self.value = bool(value)
-        return self.value
-
-
-## @brief Handles string fields
-# @note Enforce type to be (varchar)
-# @note Default 'name' is 'char'
-# @note Default 'type_length' is 76
-class EmField_char(EmFieldType):
-
-    default_length = 76
-
-    def __init__(self, **kwargs):
-        self._init(kwargs)
-        kwargs = self.__class__._argDefault(kwargs, 'type_length', self.__class__.default_length)
-        kwargs = self.__class__._argDefault(kwargs, 'name', 'char')
-        #Type enforcing
-        kwargs = self.__class__._setType(kwargs, 'varchar')
-        super(EmField_char, self).__init__(**kwargs)
-
-    #def to_sql(self, value):
-    #    return str(value)
-
-
-## @brief Handles date fields
-# @note Enforce type to be 'datetime'
-# @todo rename to EmField_datetime
-# @todo timezones support
-class EmField_date(EmFieldType):
-    def __init__(self, **kwargs):
-        self._init(kwargs)
-        kwargs = self.__class__._argDefault(kwargs, 'name', 'date')
-        #Type enforcing
-        kwargs = self.__class__._setType(kwargs, 'datetime')
-        super(EmField_date, self).__init__(**kwargs)
-
-    #def to_sql(self, value):
-    #    return value #thanks to sqlalchemy
-
-    def to_value(self, value):
-        if value == None:
-            return super(EmField_date, self).to_value(value)
-        if isinstance(value, int):
-            #assume its a timestamp
-            return datetime.fromtimestamp(value)
-        if isinstance(value, datetime.datetime):
-            return value
-
-
-## @brief Handles strings with translations
-class EmField_mlstring(EmField_char):
-
-    def __init__(self, **kwargs):
-        self._init(kwargs)
-        kwargs = self.__class__._argDefault(kwargs, 'name', 'mlstr')
-        super(EmField_mlstring, self).__init__(**kwargs)
-
-    #def to_sql(self, value):
-    #    return value.__str__()
-
-    def to_value(self, value):
-        if value == None:
-            return super(EmField_mlstring, self).to_value(value)
-        if isinstance(value, str):
-            return MlString.load(value)
-        elif isinstance(value, MlString):
-            return value
-        raise TypeError("<class str> or <class MlString> excepted. But got "+str(type(value)))
-
-
-## @brief Handles lodel uid fields
-class EmField_uid(EmField_integer):
-
-    def __init__(self, **kwargs):
-        self._init(kwargs)
-        kwargs = self.__class__._argEnforce(kwargs, 'primarykey', True)
-        super(EmField_uid, self).__init__(**kwargs)

EditorialModel/fieldtypes/__init__.py

+from os.path import dirname, basename, isfile
+import glob
+modules = glob.glob(dirname(__file__)+"/*.py")
+__all__ = [ basename(f)[:-3] for f in modules if isfile(f) and basename(f) != '__init__.py']
+

EditorialModel/fieldtypes/bool.py

+#-*- coding: utf-8 -*-
+
+from EditorialModel.fields import EmField
+
+class EmFieldBool(EmField):
+    
+    ftype = 'bool'
+    help = 'A basic boolean field'
+    
+    ## @brief A char field
+    # @brief max_length int : The maximum length of this field
+    def __init__(self, **kwargs):
+        super(EmFieldChar, self).__init__(**kwargs)
+
+fclass=EmFieldBool

EditorialModel/fieldtypes/char.py

+#-*- coding: utf-8 -*-
+
+from EditorialModel.fields import EmField
+
+class EmFieldChar(EmField):
+    
+    ftype = 'char'
+    help = 'Basic string (varchar) field. Take max_length=64 as option'
+    
+    ## @brief A char field
+    # @brief max_length int : The maximum length of this field
+    def __init__(self, max_length=64, **kwargs):
+        self.max_length = max_length
+        super(EmFieldChar, self).__init__(**kwargs)
+
+fclass = EmFieldChar

EditorialModel/fieldtypes/datetime.py

+#-*- coding: utf-8 -*-
+
+from EditorialModel.fields import EmField
+
+class EmFieldDatetime(EmField):
+    
+    ftype = 'datetime'
+
+    help = 'A datetime field. Take two boolean options now_on_update and now_on_create'
+
+    ## @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
+    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(EmFieldDatetime, self).__init__(**kwargs)
+
+fclass = EmFieldDatetime

EditorialModel/fieldtypes/file.py

+#-*- coding: utf-8 -*-
+
+from EditorialModel.fields import EmField
+
+class EmFieldFile(EmField):
+    
+    ftype = 'file'
+    help = 'A file field. With one options upload_path'
+    
+    ## @brief A char field
+    # @brief max_length int : The maximum length of this field
+    def __init__(self, upload_path = None,**kwargs):
+        self.upload_path = upload_path
+        super(EmFieldChar, self).__init__(**kwargs)
+
+fclass=EmFieldFile

EditorialModel/fieldtypes/int.py

+#-*- coding: utf-8 -*-
+
+from EditorialModel.fields import EmField
+
+
+class EmFieldInt(EmField):
+    
+    ftype = 'int'
+
+    help = 'Basic integer field'
+
+    def __init__(self, **kwargs):
+        super(EmFieldChar, self).__init__(**kwargs)
+
+fclass=EmFieldInt

EditorialModel/fieldtypes/regexchar.py

+#-*- coding: utf-8 -*-
+
+import re
+from EditorialModel.fieldtypes.char import EmFieldChar
+
+class EmFieldCharRegex(EmFieldChar):
+
+    help = 'String field validated with a regex. Take two optionss : max_length and regex'
+    
+    ## @brief A char field validated with a regex
+    # @param regex str : a regex string (passed as argument to re.compile() )
+    # @param max_length int : the maximum length for this field
+    def __init__(self, regex = '', **kwargs):
+        self.regex = regex
+        v_re = re.compile(regex) #trigger an error if invalid regex
+
+        super(EmFieldCharRegex, self).__init__(**kwargs)
+
+    def validation_function(self, raise_e = None, ret_valid = None, ret_invalid = None):
+        super(EmFieldChar, self).validation_function(raise_e, ret_valid, ret_invalid)
+
+        if not raise_e is None:
+            def v_fun(value):
+                if not re.match(self.regex):
+                    raise raise_e
+        else:
+            def v_fun(value):
+                if not re.match(self.regex):
+                    return ret_invalid
+                else:
+                    return ret_valid
+        return v_fun
+ 
+fclass = EmFieldCharRegex

EditorialModel/fieldtypes/rel2type.py

+#-*- coding: utf-8 -*-
+
+from EditorialModel.fields import EmField
+
+class EmFieldRel2Type(EmField):
+
+    ftype= 'rel2type'
+
+    help = 'Relationnal field (relation2type). Take rel_to_type_id as option (an EmType uid)'
+
+    def __init__(self, rel_to_type_id, **kwargs):
+        self.rel_to_type_id = rel_to_type_id
+        super(EmFieldRel2Type, self).__init__(**kwargs)
+
+    def get_related_type(self):
+        return self.model.component(self.rel_to_type_id)
+
+    def get_related_fields(self):
+        return [ f for f in self.model.components(EmField) if f.rel_field_id == self.uid ]
+        
+
+fclass = EmFieldRel2Type

EditorialModel/fieldtypes/text.py

+#-*- coding: utf-8 -*-
+
+from EditorialModel.fields import EmField
+
+class EmFieldText(EmField):
+    
+    ftype = 'text'
+    help = 'A text field (big string)'
+
+    def __init__(self, **kwargs):
+        super(EmFieldText, self).__init__(**kwargs)
+
+fclass = EmFieldText

EditorialModel/migrationhandler/django.py

 # -*- coding: utf-8 -*-
 
-#from django.conf import settings
-#settings.configure(DEBUG=True)
 import os
 import sys
-from django.db import models
-import django
 
+import django
+from django.db import models
 from django.db.models.loading import cache as django_cache
+from django.core.exceptions import ValidationError
+
 from EditorialModel.exceptions import *
 
-#django.conf.settings.configure(DEBUG=True)
 
 
 ## @brief Create a django model
 # @param admin_opts dict : Dict of options for admin part of this model
 # @param parent_class str : Parent class name
 # @return A dynamically created django model
-# @source https://code.djangoproject.com/wiki/DynamicModels
+# @note Source : https://code.djangoproject.com/wiki/DynamicModels
 #
 def create_model(name, fields=None, app_label='', module='', options=None, admin_opts=None, parent_class=None):
     class Meta:
 
 class DjangoMigrationHandler(object):
 
-    ##
+    ## @brief Instanciate a new DjangoMigrationHandler
     # @param app_name str : The django application name for models generation
     # @param debug bool : Set to True to be in debug mode
+    # @param dryrun bool : If true don't do any migration, only simulate them
     def __init__(self, app_name, debug=False, dryrun=False):
-        self.models = {}
         self.debug = debug
         self.app_name = app_name
         self.dryrun = dryrun
         return True
 
     ## @brief Print a debug message representing a migration
+    # @param uid int : The EmComponent uid
+    # @param initial_state dict | None : dict representing the fields that are changing
+    # @param new_state dict | None : dict represnting the new fields states
     def dump_migration(self, uid, initial_state, new_state):
         if self.debug:
             print("\n##############")
     # @note There is a problem with the related_name for superiors fk : The related name cannot be subordinates, it has to be the subordinates em_type name
     def em_to_models(self, edMod):
         
-        module_name = self.app_name+'models'
+        module_name = self.app_name+'.models'
 
         #Purging django models cache
         if self.app_name in django_cache.all_models:
                 del(django_cache.all_models[self.app_name][modname])
             #del(django_cache.all_models[self.app_name])
 
-        #This cache at instance level seems to be useless...
-        del(self.models)
-        self.models = {}
 
         app_name = self.app_name
         #Creating the document model
                 if not emfield.optional:
                     # !!! Replace with fieldtype 2 django converter
                     #emclass_fields[emfield.uniq_name] = models.CharField(max_length=56, default=emfield.uniq_name)
-                    emclass_fields[emfield.uniq_name] = emfield.to_django()
+                    emclass_fields[emfield.uniq_name] = self.field_to_django(emfield, emclass)
             #print("Model for class %s created with fields : "%emclass.uniq_name, emclass_fields)
-            print("Model for class %s created"%emclass.uniq_name)
+            if self.debug:
+                print("Model for class %s created"%emclass.uniq_name)
             django_models['classes'][emclass.uniq_name] = create_model(emclass.uniq_name, emclass_fields, self.app_name, module_name, parent_class=django_models['doc'])
             
             #Creating the EmTypes models with EmClass inherithance
                 #Adding selected optionnal fields
                 for emfield in emtype.selected_fields():
                     #emtype_fields[emfield.uniq_name] = models.CharField(max_length=56, default=emfield.uniq_name)
-                    emtype_fields[emfield.uniq_name] = emfield.to_django()
+                    emtype_fields[emfield.uniq_name] = self.field_to_django(emfield, emtype)
                 #Adding superiors foreign key
                 for nature, superior in emtype.superiors().items():
                     emtype_fields[nature] = models.ForeignKey(superior.uniq_name, related_name=emtype.uniq_name, null=True)
                     print("Model for type %s created"%emtype.uniq_name)
                 django_models['types'][emtype.uniq_name] = create_model(emtype.uniq_name, emtype_fields, self.app_name, module_name, parent_class=django_models['classes'][emclass.uniq_name])
 
-        self.models=django_models
         pass
 
+    ## @brief Return a good django field type given a field
+    # @param f EmField : an EmField object
+    # @param assoc_comp EmComponent : The associated component (type or class)
+    # @return A django field instance
+    # @note The manytomany fields created with the rel2type field has no related_name associated to it
+    def field_to_django(self, f, assoc_comp):
+
+        #Building the args dictionnary for django field instanciation
+        args = dict()
+        args['null'] = f.nullable
+        if not (f.default is None):
+            args['default'] = f.default
+        v_fun = f.validation_function(raise_e = ValidationError)
+        if v_fun:
+            args['validators'] = [v_fun]
+        if f.uniq:
+            args['unique'] = True
+        
+        # Field instanciation
+        if f.ftype == 'char': #varchar field
+            args['max_length'] = f.max_length
+            return models.CharField(**args)
+        elif f.ftype == 'int': #integer field
+            return models.IntegerField(**args)
+        elif f.ftype == 'text': #text field
+            return models.TextField(**args)
+        elif f.ftype == 'datetime': #Datetime field
+            args['auto_now'] = f.now_on_update
+            args['auto_now_add'] = f.now_on_create
+            return models.DateTimeField(**args)
+        elif f.ftype == 'bool': #Boolean field
+            if args['null']:
+                return models.NullBooleanField(**args)
+            del(args['null'])
+            return models.BooleanField(**args)
+        elif f.ftype == 'rel2type': #Relation to type
+
+            if assoc_comp == None:
+                raise RuntimeError("Rel2type field in a rel2type table is not allowed")
+            #create first a throught model if there is data field associated with the relation
+            kwargs = dict()
+
+            relf_l = f.get_related_fields()
+            if len(relf_l) > 0:
+                through_fields = {}
+                
+                #The two FK of the through model
+                through_fields[assoc_comp.name] = models.ForeignKey(assoc_comp.uniq_name)
+                rtype = f.get_related_type()
+                through_fields[rtype.name] = models.ForeignKey(rtype.uniq_name)
+
+                for relf in relf_l:
+                    through_fields[relf.name] = self.field_to_django(relf, None)
+
+                #through_model_name = f.uniq_name+assoc_comp.uniq_name+'to'+rtype.uniq_name
+                through_model_name = f.name+assoc_comp.name+'to'+rtype.name
+                module_name = self.app_name+'.models'
+                #model created
+                through_model = create_model(through_model_name, through_fields, self.app_name, module_name)
+                kwargs['through'] = through_model_name
+            
+            return models.ManyToManyField(f.get_related_type().uniq_name, **kwargs)
+        else: #Unknow data type
+            raise NotImplemented("The conversion to django fields is not yet implemented for %s field type"%f.ftype)
+
+
+        
 

EditorialModel/model.py

 ## @file editorialmodel.py
 # Manage instance of an editorial model
 
+import EditorialModel
 from EditorialModel.migrationhandler.dummy import DummyMigrationHandler
 from EditorialModel.backend.dummy_backend import EmBackendDummy
 from EditorialModel.classes import EmClass
     # @return A class name as string or False if cls is not an EmComponent child class
     def name_from_emclass(em_class):
         if em_class not in Model.components_class:
+            spl = em_class.__module__.split('.')
+            if spl[1] == 'fieldtypes':
+                return 'EmField'
             return False
         return em_class.__name__
 
             #Store and delete the EmComponent class name from datas
             cls_name = kwargs['component']
             del kwargs['component']
-            cls = self.emclass_from_name(cls_name)
+            
+            if cls_name == 'EmField':
+                #Special EmField process because of fieldtypes
+                if not 'type' in kwargs:
+                    raise AttributeError("Missing 'type' from EmField instanciation")
+                cls = EditorialModel.fields.EmField.get_field_class(kwargs['type'])
+                kwargs['fieldtype'] = kwargs['type']
+                del(kwargs['type'])
+            else:
+                cls = self.emclass_from_name(cls_name)
+
             if cls:
                 kwargs['uid'] = uid
                 # create a dict for the component and one indexed by uids, store instanciated component in it
-                self._components['uids'][uid] = cls(self, **kwargs)
+                self._components['uids'][uid] = cls(model=self, **kwargs)
                 self._components[cls_name].append(self._components['uids'][uid])
             else:
                 raise ValueError("Unknow EmComponent class : '" + cls_name + "'")
             component.init_ended()
 
     ## Saves data using the current backend
-    def save(self):
-        return self.backend.save(self)
+    # @param filename str | None : if None use the current backend file (provided at backend instanciation)
+    def save(self, filename = None):
+        return self.backend.save(self, filename)
 
     ## Given a EmComponent child class return a list of instances
     # @param cls EmComponent : A python class
     # @return a list of instances or False if the class is not an EmComponent child
-    def components(self, cls):
+    def components(self, cls=None):
+        if cls is None:
+            return [ self.component(uid) for uid in self._components['uids'] ]
         key_name = self.name_from_emclass(cls)
         return False if key_name is False else self._components[key_name]
 
     ## Sort components by rank in Model::_components
     # @param emclass pythonClass : The type of components to sort
     # @throw AttributeError if emclass is not valid
+    # @warning disabled the test on component_class because of EmField new way of working
     def sort_components(self, component_class):
-        if component_class not in self.components_class:
-            raise AttributeError("Bad argument emclass : '" + component_class + "', excpeting one of " + str(self.components_class))
+        #if component_class not in self.components_class:
+        #    raise AttributeError("Bad argument emclass : '" + str(component_class) + "', excpeting one of " + str(self.components_class))
 
         self._components[self.name_from_emclass(component_class)] = sorted(self.components(component_class), key=lambda comp: comp.rank)
 
     # @param datas dict : the options needed by the component creation
     # @throw ValueError if datas['rank'] is not valid (too big or too small, not an integer nor 'last' or 'first' )
     # @todo Handle a raise from the migration handler
+    # @todo Transform the datas arg in **datas ?
     def create_component(self, component_type, datas, uid=None):
-
-        em_obj = self.emclass_from_name(component_type)
+        
+        if component_type == 'EmField':
+            #special process for EmField
+            if not 'type' in datas:
+                raise AttributeError("Missing 'type' from EmField instanciation")
+            em_obj = EditorialModel.fields.EmField.get_field_class(datas['type'])
+            del(datas['type'])
+        else:
+            em_obj = self.emclass_from_name(component_type)
 
         rank = 'last'
         if 'rank' in datas:

EditorialModel/test/me.json

     "component":"EmFieldGroup", "name":"info", "string":"{\"fre\":\"Info\"}", "help_text":"{}", "rank":"1", "date_update":"", "date_create":"", "class_id":"1"
   },
   "4" : {
-    "component":"EmField", "name":"titre", "string":"{\"fre\":\"Titre\"}", "help_text":"{}", "rank":"1", "date_update":"", "date_create":"", "fieldtype":"varchar", "fieldgroup_id":"3", "rel_to_type_id":"", "rel_field_id":"", "optional":0, "internal":"", "icon":"0"
+    "component":"EmField", "name":"titre", "string":"{\"fre\":\"Titre\"}", "help_text":"{}", "rank":"1", "date_update":"", "date_create":"", "type":"char", "fieldgroup_id":"3", "rel_field_id":"", "optional":0, "internal":"", "icon":"0"
   },
   "5" : {
     "component":"EmType", "name":"article", "string":"{\"fre\":\"Article\"}", "help_text":"{}", "rank":"1", "date_update":"", "date_create":"", "class_id":"1", "icon":"0", "sortcolumn":"rank", "fields_list":[7], "superiors_list":{"parent":14}
     "component":"EmType", "name":"personne", "string":"{\"fre\":\"Personne\"}", "help_text":"{}", "rank":"1", "date_update":"", "date_create":"", "class_id":"2", "icon":"0", "sortcolumn":"rank", "fields_list":[10]
   },
   "7" : {
-    "component":"EmField", "name":"soustitre", "string":"{\"fre\":\"Sous-titre\"}", "help_text":"{}", "rank":"2", "date_update":"", "date_create":"", "fieldtype":"varchar", "fieldgroup_id":"3", "rel_to_type_id":"", "rel_field_id":"", "optional":1, "internal":"", "icon":"0"
+    "component":"EmField", "name":"soustitre", "string":"{\"fre\":\"Sous-titre\"}", "help_text":"{}", "rank":"2", "date_update":"", "date_create":"", "type":"char", "fieldgroup_id":"3", "rel_field_id":"", "optional":1, "internal":"", "icon":"0"
   },
   "8" : {
     "component":"EmFieldGroup", "name":"civilité", "string":"{\"fre\":\"Civilité\"}", "help_text":"{}", "rank":"1", "date_update":"", "date_create":"", "class_id":"2"
   },
   "9" : {
-    "component":"EmField", "name":"nom", "string":"{\"fre\":\"Nom\"}", "help_text":"{}", "rank":"1", "date_update":"", "date_create":"", "fieldtype":"varchar", "fieldgroup_id":"8", "rel_to_type_id":"", "rel_field_id":"", "optional":0, "internal":"", "icon":"0"
+    "component":"EmField", "name":"nom", "string":"{\"fre\":\"Nom\"}", "help_text":"{}", "rank":"1", "date_update":"", "date_create":"", "type":"char", "fieldgroup_id":"8", "rel_field_id":"", "optional":0, "internal":"", "icon":"0"
   },
   "10" : {
-    "component":"EmField", "name":"prenom", "string":"{\"fre\":\"Preom\"}", "help_text":"{}", "rank":"2", "date_update":"", "date_create":"", "fieldtype":"varchar", "fieldgroup_id":"8", "rel_to_type_id":"", "rel_field_id":"", "optional":1, "internal":"", "icon":"0"
+    "component":"EmField", "name":"prenom", "string":"{\"fre\":\"Preom\"}", "help_text":"{}", "rank":"2", "date_update":"", "date_create":"", "type":"char", "fieldgroup_id":"8", "rel_field_id":"", "optional":1, "internal":"", "icon":"0"
   },
   "11" : {
-    "component":"EmField", "name":"auteur", "string":"{\"fre\":\"Auteur\"}", "help_text":"{}", "rank":"1", "date_update":"", "date_create":"", "fieldtype":"varchar", "fieldgroup_id":"17", "rel_to_type_id":"6", "rel_field_id":"", "optional":1, "internal":"", "icon":"0"
+    "component":"EmField", "name":"auteur", "string":"{\"fre\":\"Auteur\"}", "help_text":"{}", "rank":"1", "date_update":"", "date_create":"", "type":"rel2type", "fieldgroup_id":"17", "rel_to_type_id":"6", "rel_field_id":"", "optional":0, "internal":"", "icon":"0"
   },
   "12" : {
-    "component":"EmField", "name":"adresse", "string":"{\"fre\":\"Adresse\"}", "help_text":"{}", "rank":"2", "date_update":"", "date_create":"", "fieldtype":"varchar", "fieldgroup_id":"17", "rel_to_type_id":"", "rel_field_id":"11", "optional":0, "internal":"", "icon":"0"
+    "component":"EmField", "name":"adresse", "string":"{\"fre\":\"Adresse\"}", "help_text":"{}", "rank":"2", "date_update":"", "date_create":"", "type":"char", "fieldgroup_id":"17", "rel_field_id":"11", "optional":0, "internal":"", "icon":"0"
   },
   "13" : {
     "component":"EmClass", "name":"publication", "string":"{\"fre\":\"Publication\"}", "help_text":"{}", "rank":"2", "date_update":"", "date_create":"", "classtype":"entity", "icon":"0", "sortcolumn":"rank"
     "component":"EmFieldGroup", "name":"info", "string":"{\"fre\":\"Info\"}", "help_text":"{}", "rank":"1", "date_update":"", "date_create":"", "class_id":"13"
   },
   "16" : {
-    "component":"EmField", "name":"titre", "string":"{\"fre\":\"Titre\"}", "help_text":"{}", "rank":"1", "date_update":"", "date_create":"", "fieldtype":"varchar", "fieldgroup_id":"15", "rel_to_type_id":"", "rel_field_id":"", "optional":0, "internal":"", "icon":"0"
+    "component":"EmField", "name":"titre", "string":"{\"fre\":\"Titre\"}", "help_text":"{}", "rank":"1", "date_update":"", "date_create":"", "type":"char", "fieldgroup_id":"15", "rel_field_id":"", "optional":0, "internal":"", "icon":"0"
   },
   "17" : {
     "component":"EmFieldGroup", "name":"gens", "string":"{\"fre\":\"Gens\"}", "help_text":"{}", "rank":"2", "date_update":"", "date_create":"", "class_id":"1"

Lodel/management/commands/listfieldtypes.py

+from django.core.management.base import BaseCommand, CommandError
+from optparse import make_option
+from EditorialModel.fields import EmField
+
+class Command(BaseCommand):
+    option_list = BaseCommand.option_list + (
+        make_option('--silent',
+            action='store_true',
+            dest='silent',
+            default=False,
+            help='Only display field types name and hide the help text'),
+    )
+    help = 'List all the possible field types'
+
+    def handle(self, *args, **options):
+        ftl = EmField.fieldtypes_list()
+        ftl.sort()
+        if options['silent']:
+            for ftype in ftl:
+                self.stdout.write("%s\n"%ftype)
+        else:
+            self.stdout.write("Field types list : ")
+            for ftype in ftl:
+                self.stdout.write("\t{0:15} {1}".format(ftype, EmField.get_field_class(ftype).help))

Lodel/settings/defaults.py

     'django.contrib.messages',
     'django.contrib.staticfiles',
     'LodelTestInstance',
+    'Lodel',
 )
 
 MIDDLEWARE_CLASSES = (