Updated LeFactory generated code and LeFactory class itself

Bugfixes in generated code imports
Enhancement on generated classes retrieval

leapi/lecrud.py

 # @brief This package contains the abstract class representing Lodel Editorial components
 #
 
-import EditorialModel
+import EditorialModel.fieldtypes.generic
+import importlib
 
 ## @brief Main class to handler lodel editorial components (relations and objects)
 class _LeCrud(object):
     def __init__(self):
         raise NotImplementedError("Abstract class")
  
+    ## @brief Given a dynamically generated class name return the corresponding python Class
+    # @param name str : a concrete class name
+    # @return False if no such component
+    @classmethod
+    def name2class(cls, name):
+        #print(dir(cls.__module__))
+        mod = importlib.import_module(cls.__module__)
+        try:
+            return getattr(mod, name)
+        except AttributeError:
+            return False
+
+    @classmethod
+    def leobject(cls):
+        return cls.name2class('LeObject')
+
     ## @return A dict with key field name and value a fieldtype instance
     @classmethod
     def fieldtypes(cls):

leapi/lefactory.py

 
 import importlib
 import copy
+import os.path
 
 import EditorialModel
 from EditorialModel.model import Model
     output_file = 'dyn.py'
     modname = None
 
-    def __init__(self):
-        raise NotImplementedError("Not designed (yet?) to be implemented")
 
-    ## @brief Return a LeObject child class given its name
-    # @return a python class or False
-    @staticmethod
-    def leobj_from_name(name):
-        if LeFactory.modname is None:
-            modname = 'leapi.' + LeFactory.output_file.split('.')[0]
-        else:
-            modname = LeFactory.modname
-        mod = importlib.import_module(modname)
-        try:
-            res = getattr(mod, name)
-        except AttributeError:
-            return False
-        return res
-
-    @classmethod
-    def leobject(cls):
-        return cls.leobj_from_name('LeObject')
+    def __init__(self, code_filename = 'leapi/dyn.py'):
+        self._code_filename = code_filename
+        self._dyn_file = os.path.basename(code_filename)
+        self._modname = os.path.dirname(code_filename).strip('/').replace('/', '.') #Warning Windaube compatibility
 
     ## @brief Convert an EmType or EmClass name in a python class name
     # @param name str : The name
             GenericFieldType.module_name(emfield.fieldtype),
             repr(emfield._fieldtype_args),
         )
+    
+    ## @brief Write generated code to a file
+    # @todo better options/params for file creation
+    def create_pyfile(self, model, datasource_cls, datasource_args):
+        with open(self._code_filename, "w+") as dynfp:
+            dynfp.write(self.generate_python(model, datasource_cls, datasource_args))
 
     ## @brief Given a Model and an EmClass instances generate python code for corresponding LeClass
     # @param model Model : A Model instance
     # @param emclass EmClass : An EmClass instance from model
     # @return A string representing the python code for the corresponding LeClass child class
-    @staticmethod
-    def emclass_pycode(model, emclass):
+    def emclass_pycode(self, model, emclass):
+
         cls_fields = dict()
         cls_linked_types = dict() #keys are LeType classnames and values are tuples (attr_fieldname, attr_fieldtype)
         #Populating linked_type attr
             ]
         # Populating fieldtype attr
         for field in emclass.fields(relational = False):
+            self.needed_fieldtypes |= set([field.fieldtype])
             cls_fields[field.name] = LeFactory.fieldtype_construct_from_field(field)
             fti = field.fieldtype_instance()
 
     # @param model Model : A Model instance
     # @param emtype EmType : An EmType instance from model
     # @return A string representing the python code for the corresponding LeType child class
-    @staticmethod
-    def emtype_pycode(model, emtype):
+    def emtype_pycode(self, model, emtype):
         type_fields = list()
         type_superiors = list()
         for field in emtype.fields(relational=False):
         )
 
     ## @brief Generate python code containing the LeObject API
-    # @param backend_cls Backend : A model backend class
-    # @param backend_args dict : A dict representing arguments for backend_cls instanciation
+    # @param model EditorialModel.model.Model : An editorial model instance
     # @param datasource_cls Datasource : A datasource class
     # @param datasource_args dict : A dict representing arguments for datasource_cls instanciation
     # @return A string representing python code
-    @staticmethod
-    def generate_python(backend_cls, backend_args, datasource_cls, datasource_args):
-        model = Model(backend=backend_cls(**backend_args))
+    def generate_python(self, model, datasource_cls, datasource_args):
+        self.needed_fieldtypes = set() #Stores the list of fieldtypes that will be used by generated code
+
+        model = model
 
         result = ""
         #result += "#-*- coding: utf-8 -*-\n"
         #Putting import directives in result
-        result += """## @author LeFactory
+        heading = """## @author LeFactory
+
+import EditorialModel
+from EditorialModel import fieldtypes
+from EditorialModel.fieldtypes import {needed_fieldtypes_list}
 
 import leapi
 import leapi.lecrud
 import leapi.leobject
 from leapi.leclass import LeClass
 from leapi.letype import LeType
-import EditorialModel.fieldtypes
-from EditorialModel.fieldtypes import *
 """
 
         result += """
 import %s
-import %s
 
-""" % (backend_cls.__module__, datasource_cls.__module__)
+""" % (datasource_cls.__module__)
 
         #Generating the code for LeObject class
-        backend_constructor = '%s.%s(**%s)' % (backend_cls.__module__, backend_cls.__name__, repr(backend_args))
         leobj_me_uid = dict()
         for comp in model.components('EmType') + model.components('EmClass'):
             leobj_me_uid[comp.uid] = LeFactory.name2classname(comp.name)
         for fname, ftargs in EditorialModel.classtypes.common_fields.items():
             ftargs = copy.copy(ftargs)
             fieldtype = ftargs['fieldtype']
+            self.needed_fieldtypes |= set([fieldtype])
             del(ftargs['fieldtype'])
 
             constructor = '{ftname}.EmFieldType(**{ftargs})'.format(
 
         #Set attributes of created LeClass and LeType child classes
         for emclass in emclass_l:
-            result += LeFactory.emclass_pycode(model, emclass)
+            result += self.emclass_pycode(model, emclass)
         for emtype in emtype_l:
-            result += LeFactory.emtype_pycode(model, emtype)
+            result += self.emtype_pycode(model, emtype)
 
         #Populating LeObject._me_uid dict for a rapid fetch of LeType and LeClass given an EM uid
         me_uid = {comp.uid: LeFactory.name2classname(comp.name) for comp in emclass_l + emtype_l}
 ## @brief Dict for getting LeClass and LeType child classes given an EM uid
 LeObject._me_uid = %s""" % "{" + (', '.join(['%s: %s' % (k, v) for k, v in me_uid.items()])) + "}"
         result += "\n"
+        
+        heading = heading.format(needed_fieldtypes_list = ', '.join(self.needed_fieldtypes))
+        result = heading + result
+
+        del(self.needed_fieldtypes)
         return result

leapi/leobject.py

     # @param letype LeType|str|None : LeType child instant or its name
     # @param leclass LeClass|str|None : LeClass child instant or its name
     # @return a tuple with 2 python classes (LeTypeChild, LeClassChild)
-    @staticmethod
-    def _prepare_targets(letype = None , leclass = None):
+    @classmethod
+    def _prepare_targets(cls, letype = None , leclass = None):
 
         if not(leclass is None):
             if isinstance(leclass, str):
-                leclass = LeFactory.leobj_from_name(leclass)
+                leclass = cls.name2class(leclass)
+                #leclass = LeFactory.leobj_from_name(leclass)
             
             if not isinstance(leclass, type) or not (leapi.leclass.LeClass in leclass.__bases__) or leclass.__class__ == leapi.leclass.LeClass:
                 raise ValueError("None | str | LeType child class excpected, but got : '%s' %s"%(leclass,type(leclass)))
 
         if not(letype is None):
             if isinstance(letype, str):
-                letype = LeFactory.leobj_from_name(letype)
+                letype = cls.name2class(letype)
+                #letype = LeFactory.leobj_from_name(letype)
 
             if not isinstance(letype, type) or not leapi.letype.LeType in letype.__bases__ or letype.__class__ == leapi.letype.LeType:
                 raise ValueError("None | str | LeType child class excpected, but got : %s"%type(letype))

leapi/letype.py

     # @throw Leo exception if the lodel_id identify an object from another type
     @classmethod
     def delete(cls, filters):
-        return leapi.lefactory.LeFactory.leobject().delete(cls, filters)
+        return cls.name2class('LeObject').delete(cls, filters)
         
     ## @brief Update a LeType in db
     def db_update(self):
     # @param cls
     # return bool
     def update(cls, filters, datas):
-        return leapi.lefactory.LeFactory.leobject().update(letype = cls, filters = filters, datas = datas)
+        return cls.leobject().update(letype = cls, filters = filters, datas = datas)
         
     ## @brief Insert a new LeType in the datasource
     # @param **datas list : A list of dict containing the datas

leapi/test/test_lefactory.py

 class TestLeFactorySyntax(TestCase):
 
     def test_generated_code_syntax(self):
-        py = LeFactory.generate_python(**leapi.test.utils.genepy_args)
+        fact = LeFactory('leapi/dyn.py')
+        py = fact.generate_python(**leapi.test.utils.genepy_args)
         pyc = compile(py, "dyn.py", 'exec')
         exec(pyc, globals())
 
         leapi.test.utils.cleanup(cls.tmpdir)
 
     def setUp(self):
-        backend=leapi.test.utils.genepy_args['backend_cls'](**leapi.test.utils.genepy_args['backend_args'])
-        self.model = EditorialModel.model.Model(backend = backend)
+        self.model = leapi.test.utils.genepy_args['model']
 
     def test_leobject(self):
         """ Testing the generated LeObject class """

leapi/test/utils.py

 import shutil
 import sys
 
-import EditorialModel
+from EditorialModel.model import Model
 import leapi
 from EditorialModel.backend.json_backend import EmBackendJson
 from leapi.datasources.dummy import DummyDatasource
 
 
 genepy_args = {
-    'backend_cls': EmBackendJson,
-    'backend_args': {'json_file': 'EditorialModel/test/me.json'},
+    'model' : Model(EmBackendJson(json_file = 'EditorialModel/test/me.json')),
     'datasource_cls': DummyDatasource,
     'datasource_args': {}
 }
 def tmp_load_factory_code(name='dyncode'):
     tmpdir = tempfile.mkdtemp('_lodel2_test_dyncode')
     fname = tmpdir+'/%s.py'%name
-    with open(fname, 'w+') as dynfp:
-        dynfp.write(LeFactory.generate_python(**genepy_args))
+    
     sys.path.append(tmpdir)
-    LeFactory.modname = name
+    fact = LeFactory(fname)
+    fact.create_pyfile(**genepy_args)
+
     return tmpdir
 
 

refreshdyn.py

+# -*- coding: utf-8 -*-
+
+from EditorialModel.model import Model
+from leapi.lefactory import LeFactory
+from EditorialModel.backend.json_backend import EmBackendJson
+from leapi.datasources.ledatasourcesql import LeDataSourceSQL
+
+OUTPUT = 'leapi/dyn.py'
+
+em = Model(EmBackendJson('EditorialModel/test/me.json'))
+
+fact = LeFactory('leapi/dyn.py')
+fact.create_pyfile(em, LeDataSourceSQL, {})
+print(fact.generate_python(em, LeDataSourceSQL, {}))
+
+