LeFactory first implementation

This implementation is broken because of relation data_handler. Backreference is a broken concept and relation data_handler too.

lodel/editorial_model/components.py

@@ -52,11 +52,15 @@ class EmClass(EmComponent):
     # @param uid str : uniq identifier
     # @param display_name MlString|str|dict : component display_name
     # @param abstract bool : set the class as asbtract if True
+    # @param pure_abstract bool : if True the EmClass will not be represented in leapi dyncode
     # @param parents list: parent EmClass list or uid list
     # @param help_text MlString|str|dict : help_text
-    def __init__(self, uid, display_name = None, help_text = None, abstract = False, parents = None, group = None):
+    def __init__(self, uid, display_name = None, help_text = None, abstract = False, parents = None, group = None, pure_abstract = False):
         super().__init__(uid, display_name, help_text, group)
         self.abstract = bool(abstract)
+        self.pure_abstract = bool(pure_abstract)
+        if self.pure_abstract:
+            self.abtract = True
         if parents is not None:
             if not isinstance(parents, list):
                 parents = [parents]
@@ -78,6 +82,19 @@ class EmClass(EmComponent):
         res.update(self.__fields)
         return res
 
+    ## @brief Return the list of all dependencies
+    #
+    # Reccursive parents listing
+    @property
+    def parents_recc(self):
+        if len(self.parents) == 0:
+            return set()
+
+        res = set(self.parents)
+        for parent in self.parents:
+            res |= parent.parents_recc
+        return res
+
     ## @brief EmField getter
     # @param uid None | str : If None returns an iterator on EmField instances else return an EmField instance
     # @param no_parents bool : If True returns only fields defined is this class and not the one defined in parents classes
@@ -96,7 +113,7 @@ class EmClass(EmComponent):
     # @todo End the override checks (needs methods in data_handlers)
     def add_field(self, emfield):
         if emfield.uid in self.__fields:
-            raise EditorialModelException("Duplicated uid '%s' for EmField in this class ( %s )" % (emfield.uid, self))
+            raise EditorialModelError("Duplicated uid '%s' for EmField in this class ( %s )" % (emfield.uid, self))
         # Incomplete field override check
         if emfield.uid in self.__all_fields:
             parent_field = self.__all_fields[emfield.uid]
@@ -124,6 +141,18 @@ class EmClass(EmComponent):
         m.update(bytes(payload, 'utf-8'))
         return int.from_bytes(m.digest(), byteorder='big')
 
+    def __str__(self):
+        return "<class EmClass %s>" % self.uid
+    
+    def __repr__(self):
+        if not self.abstract:
+            abstract = ''
+        elif self.pure_abstract:
+            abstract = 'PureAbstract'
+        else:
+            abstract = 'Abstract'
+        return "<class %s EmClass uid=%s>" % (abstract, repr(self.uid) )
+
 
 ## @brief Handles editorial model classes fields
 class EmField(EmComponent):
@@ -139,6 +168,8 @@ class EmField(EmComponent):
         super().__init__(uid, display_name, help_text, group)
         self.data_handler_name = data_handler
         self.data_handler_cls = FieldDataHandler.from_name(data_handler)
+        #if 'data_handler_kwargs' in handler_kwargs:
+        #    handler_kwargs = handler_kwargs['data_handler_kwargs']
         self.data_handler_options = handler_kwargs
         self.data_handler_instance = self.data_handler_cls(**handler_kwargs)
         ## @brief Stores the emclass that contains this field (set by EmClass.add_field() method)

lodel/editorial_model/model.py

@@ -1,6 +1,7 @@
 #-*- coding:utf-8 -*-
 
 import hashlib
+import importlib
 
 from lodel.utils.mlstring import MlString
 
@@ -77,6 +78,8 @@ class EditorialModel(object):
     # @param translator module : The translator module to use
     # @param **translator_args
     def save(self, translator, **translator_kwargs):
+        if isinstance(translator, str):
+            translator = self.translator_from_name(translator)
         return translator.save(self, **translator_kwargs)
     
     ## @brief Load a model
@@ -84,7 +87,23 @@ class EditorialModel(object):
     # @param **translator_args
     @classmethod
     def load(cls, translator, **translator_kwargs):
+        if isinstance(translator, str):
+            translator = cls.translator_from_name(translator)
         return translator.load(**translator_kwargs)
+
+    ## @brief Return a translator module given a translator name
+    # @param translator_name str : The translator name
+    # @return the translator python module
+    # @throw NameError if the translator does not exists
+    @staticmethod
+    def translator_from_name(translator_name):
+        pkg_name = 'lodel.editorial_model.translator.%s' % translator_name
+        try:
+            mod = importlib.import_module(pkg_name)
+        except ImportError:
+            raise NameError("No translator named %s")
+        return mod
+        
     
     ## @brief Private getter for __groups or __classes
     # @see classes() groups()

lodel/editorial_model/translator/pickle.py

@@ -1 +0,0 @@
-#-*- coding: utf-8 -*-

lodel/leapi/datahandlers/field_data_handler.py

@@ -15,10 +15,11 @@ class FieldDataHandler(object):
     #                         designed globally and immutable
     # @param **args
     # @throw NotImplementedError if it is instanciated directly
-    def __init__(self, internal=False, immutable=False, **args):
+    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)
 
@@ -31,6 +32,9 @@ class FieldDataHandler(object):
     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):
@@ -98,6 +102,22 @@ class FieldDataHandler(object):
         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

lodel/leapi/lefactory.py

@@ -0,0 +1,122 @@
+#-*- coding: utf-8 -*-
+
+import functools
+from lodel.editorial_model.components import *
+from lodel.leapi.leobject import LeObject
+from lodel.leapi.datahandlers.field_data_handler import FieldDataHandler
+
+## @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"
+    for module in modules:
+        imports += "import %s\n" % module
+
+    res_code = """#-*- coding: utf-8 -*-
+{imports}
+{classes}
+{bootstrap_instr}
+del(LeObject._set__fields)
+""".format(
+            imports = imports,
+            classes = cls_code,
+            bootstrap_instr = bootstrap_instr,
+    )
+    return res_code
+
+## @brief return A list of EmClass sorted by dependencies
+#
+# The first elts in the list depends on nothing, etc.
+# @return a list of EmClass instances
+def emclass_sorted_by_deps(emclass_list):
+    def emclass_deps_cmp(cls_a, cls_b):
+        if len(cls_a.parents) + len(cls_b.parents) == 0:
+            return 0
+        elif len(cls_a.parents) == 0:
+            return -1
+        elif len(cls_b.parents) == 0:
+            return 1
+
+        if cls_a in cls_b.parents_recc:
+            return -1
+        elif cls_b in cls_a.parents_recc:
+            return 1
+        else:
+            return 0
+    return sorted(emclass_list, key = functools.cmp_to_key(emclass_deps_cmp))
+
+## @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'
+    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()])) + '})'
+            
+
+def forge_optval(optval):
+    if isinstance(optval, dict):
+        return '{' + (', '.join( [ '%s: %s' % (repr(name), forge_optval(val)) for name, val in optval.items()])) + '}'
+
+    if isinstance(optval, (set, list, tuple)):
+        return '[' + (', '.join([forge_optval(val) for val in optval])) + ']'
+        
+    if isinstance(optval, EmField):
+        return "{leobject}.data_handler({fieldname})".format(
+                leobject = LeObject.name2objname(optval._emclass.uid),
+                fieldname = repr(optval.uid)
+            )
+    elif isinstance(optval, EmClass):
+        return LeObject.name2objname(optval.uid)
+    else:
+        return repr(optval)
+
+## @brief Generate dyncode from an EmClass
+# @param model EditorialModel : 
+# @param emclass EmClass : EmClass instance
+# @return a tuple with emclass python code, a set containing modules name to import, and a list of python instruction to bootstrap dynamic code, in this order
+def generate_classes(model):
+    res = ""
+    imports = list()
+    bootstrap = ""
+    # Generating field list for LeObjects generated from EmClass
+    for em_class in [ cls for cls in emclass_sorted_by_deps(model.classes()) if not cls.pure_abstract ]:
+        uid = list()        # List of fieldnames that are part of the EmClass primary key
+        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
+        if len(em_class.parents) > 0:
+            for parent in em_class.parents:
+               parents.append(LeObject.name2objname(parent.uid))
+        else:
+            parents.append('LeObject')
+        
+        # Dynamic code generation for LeObject childs classes
+        em_cls_code = """
+class {clsname}({parents}):
+    __abstract = {abstract}
+    __fields = None
+    __uid = {uid_list}
+
+""".format(
+    clsname = LeObject.name2objname(em_class.uid),
+    parents = ', '.join(parents),
+    abstract = 'True' if em_class.abstract else 'False',
+    uid_list = repr(uid),
+)
+        res += em_cls_code
+        # Dyncode bootstrap instructions
+        bootstrap += """{classname}._set__fields({fields})
+#del({classname}._set__fields)
+""".format(
+    classname = LeObject.name2objname(em_class.uid),
+    fields = '{' + (', '.join(['\n\t%s: %s' % (repr(emfield.uid),data_handler_constructor(emfield)) for emfield in em_class.fields()])) + '}',
+)
+    return res, set(imports), bootstrap
+    

lodel/leapi/leobject.py

@@ -24,11 +24,13 @@ class LeApiErrors(Exception):
 
 
 ## @brief When an error concern a query
-class LeApiQueryError(LeApiErrors): pass
+class LeApiQueryError(LeApiErrors):
+    pass
 
 
 ## @brief When an error concerns a datas
-class LeApiDataCheckError(LeApiErrors): pass
+class LeApiDataCheckError(LeApiErrors):
+    pass
 
 
 ## @brief Wrapper class for LeObject getter & setter
@@ -60,15 +62,21 @@ class LeObjectValues(object):
         
 
 class LeObject(object):
-    
+ 
+    ## @brief boolean that tells if an object is abtract or not
+    __abtract = None
     ## @brief A dict that stores DataHandler instances indexed by field name
     __fields = None
     ## @brief A tuple of fieldname (or a uniq fieldname) representing uid
     __uid = None 
 
+    ## @brief Construct an object representing an Editorial component
+    # @note Can be considered as EmClass instance
     def __init__(self, **kwargs):
+        if self.__abstract:
+            raise NotImplementedError("%s is abstract, you cannot instanciate it." % self.__class__.__name__ )
         ## @brief A dict that stores fieldvalues indexed by fieldname
-        self.__datas = dict(fname:None for fname in self.__fields)
+        self.__datas = { fname:None for fname in self.__fields }
         ## @brief Store a list of initianilized fields when instanciation not complete else store True
         self.__initialized = list()
         ## @brief Datas accessor. Instance of @ref LeObjectValues
@@ -81,7 +89,8 @@ class LeObject(object):
             self.__datas[uid_name] = kwargs[uid_name]
             del(kwargs[uid_name])
             self.__initialized.append(uid_name)
-
+        
+        # Processing given fields
         allowed_fieldnames = self.fieldnames(include_ro = False)
         err_list = list()
         for fieldname, fieldval in kwargs.items():
@@ -118,6 +127,20 @@ class LeObject(object):
         else:
             return list(self.__fields.keys())
  
+    @classmethod
+    def name2objname(cls, name):
+        return name.title()
+    
+    ## @brief Return the datahandler asssociated with a LeObject field
+    # @param fieldname str : The fieldname
+    # @return A data handler instance
+    @classmethod
+    def data_handler(cls, fieldname):
+        if not fieldname in cls.__fields:
+            raise NameError("No field named '%s' in %s" % (fieldname, cls.__name__))
+        return cls.__fields[fieldname]
+        
+
     ## @brief Read only access to all datas
     # @note for fancy data accessor use @ref LeObject.g attribute @ref LeObjectValues instance
     # @param name str : field name
@@ -126,7 +149,7 @@ class LeObject(object):
     # @throw NameError if name is not an existing field name
     def data(self, field_name):
         if field_name not in self.__fields.keys():
-            raise NameError("No such field in %s : %s" % (self.__class__.__name__, name)
+            raise NameError("No such field in %s : %s" % (self.__class__.__name__, name))
         if not self.initialized and name not in self.__initialized:
             raise RuntimeError("The field %s is not initialized yet (and have no value)" % name)
         return self.__datas[name]
@@ -220,8 +243,20 @@ class LeObject(object):
                     self.__datas[fname] = val
         return err_list if len(err_list) > 0 else None
 
-    #-------------------#
-    #   Crud methods    #
-    #-------------------#
+    #--------------------#
+    #   Other methods    #
+    #--------------------#
+    
+    ## @brief Temporary method to set private fields attribute at dynamic code generation
+    #
+    # This method is used in the generated dynamic code to set the __fields attribute
+    # at the end of the dyncode parse
+    # @warning This method is deleted once the dynamic code is parsed
+    # @param field_list list : list of EmField instance
+    @classmethod
+    def _set__fields(cls, field_list):
+        cls.__fields = field_list
+        
+
 
     

test_em.py

@@ -244,3 +244,4 @@ text.new_field( 'linked_persons',
                 group = editorial_person_group,
 )
 
+em.save('picklefile', filename = '/tmp/em_test.pickle')

tests/editorial_model/test_model.py

@@ -32,6 +32,25 @@ class EditorialModelTestCase(unittest.TestCase):
         c2f1.uid = 'c2testfield1'
         self.assertEqual(model.d_hash(), e_hash)
 
+    def test_translator_from_name(self):
+        """ Test the translator_from_name method """
+        import lodel.editorial_model.translator.picklefile as expected
+        translator = EditorialModel.translator_from_name('picklefile')
+        self.assertEqual(translator, expected)
+
+    def test_invalid_translator_from_name(self):
+        """ Test the translator_from_name method when invalid names given as argument """
+        import lodel.editorial_model.translator.picklefile
+        invalid_names = [
+            lodel.editorial_model.translator.picklefile,
+            'foobar',
+            42,
+        ]
+
+        for name in invalid_names:
+            with self.assertRaises(NameError):
+                EditorialModel.translator_from_name(name)
+
 
 class EmComponentTestCase(unittest.TestCase):
     
@@ -105,6 +124,24 @@ class EmClassTestCase(unittest.TestCase):
         with self.assertRaises(AttributeError):
             cls2.new_field('test', data_handler = 'varchar', max_length = 2)
 
+    def test_parents_recc(self):
+        """ Test the reccursive parents property """
+        model = EditorialModel(
+                                    "test_model",
+                                    description = "Model for LeFactoryTestCase"
+        )
+        cls1 = model.new_class('testclass1')
+        cls2 = model.new_class('testclass2')
+        cls3 = model.new_class('testclass3', parents = [cls2])
+        cls4 = model.new_class('testclass4', parents = [cls1, cls3])
+        cls5 = model.new_class('testclass5', parents = [cls4])
+        cls6 = model.new_class('testclass6')
+
+        self.assertEqual(cls5.parents_recc, set((cls4, cls1, cls2, cls3)))
+        self.assertEqual(cls1.parents_recc, set())
+        self.assertEqual(cls4.parents_recc, set((cls1, cls2, cls3)))
+        self.assertEqual(cls3.parents_recc, set((cls2,)))
+
 class EmGroupTestCase(unittest.TestCase):
     
     def test_init(self):

tests/leapi/test_lefactory.py

@@ -0,0 +1,52 @@
+#-*- coding: utf-8 -*-
+
+import unittest
+from lodel.editorial_model.model import EditorialModel
+from lodel.leapi import lefactory
+
+class LeFactoryTestCase(unittest.TestCase):
+    
+    model = None
+
+    @classmethod
+    def setUpClass(cls):
+        """ Generate an example model for this TestCase """
+        model = EditorialModel(
+                                    "test_model",
+                                    description = "Model for LeFactoryTestCase"
+        )
+        cls1 = model.new_class('testclass1')
+        cls2 = model.new_class('testclass2')
+        cls3 = model.new_class('testclass3', parents = [cls2])
+        cls4 = model.new_class('testclass4', parents = [cls1, cls3])
+        cls5 = model.new_class('testclass5', parents = [cls4])
+        cls6 = model.new_class('testclass6')
+
+        cls1.new_field('testfield1', data_handler='varchar')
+        cls1.new_field('testfield2', data_handler='varchar', nullable = True)
+        cls1.new_field('testfield3', data_handler='varchar', max_length=64)
+        cls1.new_field('testfield4', data_handler='varchar', max_length=64, nullable=False, uniq=True)
+        cls1.new_field('id', data_handler='integer', primary_key = True)
+
+        cls5.new_field('id2', data_handler='varchar', primary_key = True)
+
+        cls.model = model
+    
+    def test_emclass_sorted_by_deps(self):
+        """ Test the function that sort EmClass by dependencies """
+        cls_list = self.model.classes()
+        sorted_cls = lefactory.emclass_sorted_by_deps(cls_list)
+        seen = set() # Stores the EmClass allready seen will walking through array
+        
+        for _ in range(10): #Bad sorts algorithm can have random behavior
+            for emclass in sorted_cls:
+                for parent in emclass.parents:
+                    self.assertIn(parent, seen)
+                seen |= set((emclass,))
+
+    def test_generated_code_syntax(self):
+        """ Test the function that generate LeObject childs classes code"""
+        pycode = lefactory.dyncode_from_em(self.model)
+        pycomp_code = compile(pycode, "dyn.py", 'exec')
+        exec(pycomp_code, globals())
+