Fixing the code because of DataSources changes

EditorialModel/fields.py

         self._fieldtype_args = kwargs
         self._fieldtype_args.update({'nullable': nullable, 'uniq': uniq, 'internal': self.internal})
         self.set_fieldtype_options(**self._fieldtype_args)
+        fieldtype_instance = self._fieldtype_cls(**self._fieldtype_args)
 
         if 'default' in kwargs:
-            if not fieldtype_instance.check(default):
+            if not fieldtype_instance.check_data_value(kwargs['default']):
                 raise TypeError("Default value ('%s') is not valid given the fieldtype '%s'" % (default, fieldtype))
 
         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)

EditorialModel/model.py

 # Contains the class managing and editorial model
 
 import EditorialModel
-from DataSource.dummy.migrationhandler import DummyMigrationHandler
+from DataSource.dummy.migrationhandler import MigrationHandler
 from EditorialModel.backend.dummy_backend import EmBackendDummy
 from EditorialModel.classes import EmClass
 from EditorialModel.fields import EmField
     # @param migration_handler : A migration handler
     def __init__(self, backend, migration_handler=None):
         if migration_handler is None:
-            self.migration_handler = DummyMigrationHandler()
-        elif issubclass(migration_handler.__class__, DummyMigrationHandler):
+            self.migration_handler = MigrationHandler()
+        elif issubclass(migration_handler.__class__, MigrationHandler):
             self.migration_handler = migration_handler
         else:
             raise TypeError("migration_handler should be an instance from a subclass of DummyMigrationhandler")

EditorialModel/test/test_classes.py

 from EditorialModel.fields import EmField
 from EditorialModel.model import Model
 from EditorialModel.backend.json_backend import EmBackendJson
-from DataSource.dummy.migrationhandler import DummyMigrationHandler
+from DataSource.dummy.migrationhandler import MigrationHandler
 
 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "Lodel.settings")
 EM_TEST = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'me.json')
 def setUpModule():
     global EM_TEST_OBJECT
     #EM_TEST_OBJECT = Model(EmBackendJson(EM_TEST), migration_handler=DjandoMigrationHandler('LodelTestInstance'))
-    EM_TEST_OBJECT = Model(EmBackendJson(EM_TEST), migration_handler=DummyMigrationHandler())
+    EM_TEST_OBJECT = Model(EmBackendJson(EM_TEST), migration_handler=MigrationHandler())
     logging.basicConfig(level=logging.CRITICAL)
 
 

EditorialModel/test/test_component.py

 from Lodel.utils.mlstring import MlString
 
 from EditorialModel.backend.json_backend import EmBackendJson
-from DataSource.dummy.migrationhandler import DummyMigrationHandler
+from DataSource.dummy.migrationhandler import MigrationHandler
 
 
 class TestEmComponent(unittest.TestCase):
     def test_hashes(self):
         """ Testing __hash__ and __eq__ methods """
         me1 = Model(EmBackendJson('EditorialModel/test/me.json'))
-        me2 = Model(EmBackendJson('EditorialModel/test/me.json'), migration_handler=DummyMigrationHandler())
+        me2 = Model(EmBackendJson('EditorialModel/test/me.json'), migration_handler=MigrationHandler())
 
         for comp_class in [EmClass, EmType, EmField]:
             comp_l1 = me1.components(comp_class)

EditorialModel/test/test_field.py

 import os
 
+import unittest
 from unittest import TestCase
 from EditorialModel.fields import EmField
 from EditorialModel.model import Model
         with self.assertRaises(ValueError, msg="Only common_fields should be internal='object'"):
             field = EM_TEST_OBJECT.create_component(EmField.__name__, {'name': 'testbadinternal','internal': 'object', 'class_id': self.test_class.uid, 'fieldtype': self.test_fieldtype})
 
+    @unittest.skip("rel2type are not uniq like this anymore")
     def test_double_rel2type(self):
         """ Test the rel2type unicity """
         em = EM_TEST_OBJECT

EditorialModel/test/test_model.py

 
 from EditorialModel.backend.json_backend import EmBackendJson
 from EditorialModel.backend.dummy_backend import EmBackendDummy
-from DataSource.dummy.migrationhandler import DummyMigrationHandler
+from DataSource.dummy.migrationhandler import MigrationHandler
 
 
 class TestModel(unittest.TestCase):
         model = Model(EmBackendJson('EditorialModel/test/me.json'))
         self.assertTrue(isinstance(model, Model))
 
-        model = Model(EmBackendJson('EditorialModel/test/me.json'), migration_handler=DummyMigrationHandler())
+        model = Model(EmBackendJson('EditorialModel/test/me.json'), migration_handler=MigrationHandler())
         self.assertTrue(isinstance(model, Model))
 
     def test_bad_init(self):
         """ Test initialisation with bad arguments """
-        for bad in [None, int, EmBackendDummy, DummyMigrationHandler, 'foobar']:
+        for bad in [None, int, EmBackendDummy, MigrationHandler, 'foobar']:
             with self.assertRaises(TypeError, msg="Tried to instanciate a Model with a bad backend"):
                 Model(bad)
-        for bad in [int, EmBackendDummy, DummyMigrationHandler, 'foobar']:
+        for bad in [int, EmBackendDummy, MigrationHandler, 'foobar']:
             with self.assertRaises(TypeError, msg="Tried to instanciate a Model with a migration_handler"):
                 Model(EmBackendDummy(), bad)
 
             for nat, sup_l in emtype.superiors().items():
                 superiors_list_orig[nat] = [sup.uid for sup in sup_l]
 
-        with patch.object(DummyMigrationHandler, 'register_change', return_value=None) as mh_mock:
-            self.ed_mod.migrate_handler(DummyMigrationHandler())
+        with patch.object(MigrationHandler, 'register_change', return_value=None) as mh_mock:
+            self.ed_mod.migrate_handler(MigrationHandler())
             #Getting cloned EM instance
             new_me = mh_mock.mock_calls[-1][1][0]
             for emtype in new_me.components(EmType):
 
     def test_migrate_handler_hashes(self):
         """ Testing that the migrate_handler() method create an EM with the same hash as the original EM """
-        with patch.object(DummyMigrationHandler, 'register_change', return_value=None) as mh_mock:
-            self.ed_mod.migrate_handler(DummyMigrationHandler())
+        with patch.object(MigrationHandler, 'register_change', return_value=None) as mh_mock:
+            self.ed_mod.migrate_handler(MigrationHandler())
             #Getting the cloned EM instance
             last_call = mh_mock.mock_calls[-1]
             self.assertEqual(hash(last_call[1][0]), hash(self.ed_mod))
     def test_hash(self):
         """ Test that __hash__ and __eq__ work properly on models """
         me1 = Model(EmBackendJson('EditorialModel/test/me.json'))
-        me2 = Model(EmBackendJson('EditorialModel/test/me.json'), migration_handler=DummyMigrationHandler())
+        me2 = Model(EmBackendJson('EditorialModel/test/me.json'), migration_handler=MigrationHandler())
 
         self.assertEqual(hash(me1), hash(me2), "When instanciate from the same backend & file but with another migration handler the hashes differs")
         self.assertTrue(me1.__eq__(me2))

install/utils.py

             os.unlink(my_file_path)
         with open(my_file_path, 'w') as my_file:
             my_file.write(template['content'])
-        print("Created %s" % my_file_path)
+        print("Created %s" % my_file_path)

leapi/lecrud.py

 import re
 
 from Lodel import logger
+from Lodel.settings import Settings
 from EditorialModel.fieldtypes.generic import DatasConstructor
 from Lodel.hooks import LodelHook
 
 ## @brief When an error concerns a datas
 class LeApiDataCheckError(LeApiErrors): pass
     
+class _MetaLeCrud(type):
+     def __getattribute__(self, name):
+        if name == '_datasource':
+            if super().__getattribute__('_datasource') is None:
+                module = importlib.import_module("DataSource.{pkg_name}.leapidatasource".format(
+                    pkg_name = Settings.ds_package,
+                    mod_name = 'leapidatasource'
+                ))
+                ds_cls = getattr(module, 'LeapiDataSource')
+                super().__setattr__('_datasource', ds_cls(**Settings.datasource_options))
+        return super().__getattribute__(name)
+
+
+        if 'leapidatasource' in globals():
+            if name == '_datasource' and isinstance(self._datasource, DummyDatasource):
+                #if name == '_datasource' and self._datasource == None:
+                leapids = globals()['leapidatasource']
+                if not isinstance(leapids, DummyDatasource):
+                    self._datasource = leapids({})
+        return super().__getattribute__(name)
 
 ## @brief Main class to handler lodel editorial components (relations and objects)
-class _LeCrud(object):
+class _LeCrud(object, metaclass = _MetaLeCrud):
     ## @brief The datasource
     _datasource = None
 
         ## @brief A flag to indicate if the object was fully intanciated or not
         self._instanciation_complete = len(kwargs) + 1 == len(self.fieldlist())
 
+    def __getattribute__(self, name):
+        if name == '_datasource':
+            return _MetaLeCrud.__getattribute__(self.__class__, name)
+        return super().__getattribute__(name)
+
     ## @brief Convert an EmType or EmClass name in a python class name
     # @param name str : The name
     # @return name.title()

leapi/lefactory.py

     
     ## @brief Write generated code to a file
     # @todo better options/params for file creation
-    def create_pyfile(self, model, datasource_cls, datasource_args):
+    def create_pyfile(self, model):
         with open(self._code_filename, "w+") as dynfp:
-            dynfp.write(self.generate_python(model, datasource_cls, datasource_args))
+            dynfp.write(self.generate_python(model))
 
     ## @brief Generate fieldtypes for concret classes
     # @param ft_dict dict : key = fieldname value = fieldtype __init__ args
     # @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
-    def generate_python(self, model, datasource_cls, datasource_args):
+    def generate_python(self, model):
         self.needed_fieldtypes = set() #Stores the list of fieldtypes that will be used by generated code
 
         model = model
 from leapi.letype import _LeType
 """
 
-        result += """
-import %s
-
-""" % (datasource_cls.__module__)
-
         #Generating the code for LeObject class
         leobj_me_uid = dict()
         for comp in model.components('EmType') + model.components('EmClass'):
 ## @brief _LeCrud concret class
 # @see leapi.lecrud._LeCrud
 class LeCrud(leapi.lecrud._LeCrud):
-    _datasource = {ds_classname}(**{ds_kwargs})
     _uid_fieldtype = None
 
 ## @brief _LeObject concret class
 class LeType(LeClass, _LeType):
     pass
 """.format(
-            ds_classname = datasource_cls.__module__ + '.' + datasource_cls.__name__,
-            ds_kwargs = repr(datasource_args),
             me_uid_l = repr(leobj_me_uid),
             leo_uid_fieldtype = leobj_uid_fieldtype,
             leo_fieldtypes = '{\n\t' + (',\n\t'.join(leobj_fieldtypes))+ '\n\t}',

leapi/test/test_lecrud.py

     #   Tests mocking the datasource
     # 
 
-    @patch('DataSource.dummy.leapidatasource.DummyDatasource.insert')
+    @patch('DataSource.dummy.leapidatasource.LeapiDataSource.insert')
     def test_insert(self, dsmock):
         from dyncode import Publication, Numero, LeObject, Personne, Article
         ndatas = [
             dsmock.reset_mock()
     
     ## @todo try failing on inserting from LeClass child or LeObject
-    @patch('DataSource.dummy.leapidatasource.DummyDatasource.insert')
+    @patch('DataSource.dummy.leapidatasource.LeapiDataSource.insert')
     def test_insert_fails(self, dsmock):
         from dyncode import Publication, Numero, LeObject, Personne, Article
         ndatas = [
                 assert not dsmock.called
         pass
     
-    @patch('DataSource.dummy.leapidatasource.DummyDatasource.update')
+    @patch('DataSource.dummy.leapidatasource.LeapiDataSource.update')
     def test_update(self, dsmock):
         from dyncode import Publication, Numero, LeObject
         
             dsmock.assert_called_once_with(ccls, eid, **qdatas)
     
     ## @todo test invalid get
-    @patch('DataSource.dummy.leapidatasource.DummyDatasource.select')
+    @patch('DataSource.dummy.leapidatasource.LeapiDataSource.select')
     def test_get(self, dsmock):
         """ Test the select method without group, limit, sort or offset """
         from dyncode import Publication, Numero, LeObject, Textes
                                     )
             dsmock.reset_mock()
     
-    @patch('DataSource.dummy.leapidatasource.DummyDatasource.select')
+    @patch('DataSource.dummy.leapidatasource.LeapiDataSource.select')
     def test_get_complete(self, dsmock):
         """ Test the select method with group limit sort and offset arguments """
         from dyncode import Numero

leapi/test/test_leobject.py

         """ Remove the temporary directory created at class setup """
         leapi.test.utils.cleanup(cls.tmpdir)
     
-    @patch('DataSource.dummy.leapidatasource.DummyDatasource.insert')
+    @patch('DataSource.dummy.leapidatasource.LeapiDataSource.insert')
     def test_insert(self, dsmock):
         from dyncode import Publication, Numero, LeObject
         ndatas = [
             dsmock.assert_called_once_with(Numero, **expt_dats)
             dsmock.reset_mock()
 
-    @patch('DataSource.dummy.leapidatasource.DummyDatasource.update')
+    @patch('DataSource.dummy.leapidatasource.LeapiDataSource.update')
     def test_update(self, dsmock):
         from dyncode import Publication, Numero, LeObject, Personne, Article, RelTextesPersonneAuteur
 
                 dsmock.assert_called_once_with(instance.__class__, instance.uidget(), **datas)
                 dsmock.reset_mock()
     
-    @patch('DataSource.dummy.leapidatasource.DummyDatasource.delete')
+    @patch('DataSource.dummy.leapidatasource.LeapiDataSource.delete')
     def test_delete(self, dsmock):
         from dyncode import Publication, Numero, LeObject, LeType, LeRelation
         

leapi/test/test_lerelation.py

             for i in range(3):
                 self.assertEqual(filter_res[i], res[i], "%s != %s"%(filter_res, res))
 
-    @patch('DataSource.dummy.leapidatasource.DummyDatasource.delete')
+    @patch('DataSource.dummy.leapidatasource.LeapiDataSource.delete')
     def test_delete(self, dsmock):
         """ Testing LeHierarch insert method """
         from dyncode import LeCrud, Publication, Numero, Personnes, LeObject, Rubrique, LeHierarch, LeRelation
 
 class LeHierarch(LeRelationTestCase):
     
-    @patch('DataSource.dummy.leapidatasource.DummyDatasource.select')
+    @patch('DataSource.dummy.leapidatasource.LeapiDataSource.select')
     def test_get(self, dsmock):
         """ Tests the LeHierarch.get() method without limit group order etc."""
         from dyncode import LeCrud, Publication, Numero, Personnes, LeObject, Rubrique, LeHierarch, LeRelation
 
             dsmock.reset_mock()
     
-    @patch('DataSource.dummy.leapidatasource.DummyDatasource.insert')
+    @patch('DataSource.dummy.leapidatasource.LeapiDataSource.insert')
     def test_insert(self, dsmock):
         """ Testing LeHierarch insert method """
         from dyncode import LeCrud, Publication, Numero, Personnes, LeObject, Rubrique, LeHierarch, LeRelation
             dsmock.reset_mock()
     
 
-    @patch('DataSource.dummy.leapidatasource.DummyDatasource.delete')
+    @patch('DataSource.dummy.leapidatasource.LeapiDataSource.delete')
     def test_delete(self, dsmock):
         """ Testing LeHierarch delete method """
         from dyncode import LeCrud, Publication, Numero, Personnes, LeObject, Rubrique, LeHierarch, LeRelation
         dsmock.assert_called_once_with(LeHierarch, 10)
         
     
-    @patch('DataSource.dummy.leapidatasource.DummyDatasource.update')
+    @patch('DataSource.dummy.leapidatasource.LeapiDataSource.update')
     def test_update(self, dsmock):
         """ test LeHierach update method"""
         from dyncode import LeHierarch
 
 class LeRel2TypeTestCase(LeRelationTestCase):
     
-    @patch('DataSource.dummy.leapidatasource.DummyDatasource.insert')
+    @patch('DataSource.dummy.leapidatasource.LeapiDataSource.insert')
     def test_insert(self, dsmock):
         """ test LeHierach update method"""
         from dyncode import LeObject, Article, Textes, Personne, Personnes, LeHierarch, LeRel2Type, RelTextesPersonneAuteur
             dsmock.assert_called_once_with(RelTextesPersonneAuteur, **eres)
             dsmock.reset_mock()
 
-    @patch('DataSource.dummy.leapidatasource.DummyDatasource.insert')
+    @patch('DataSource.dummy.leapidatasource.LeapiDataSource.insert')
     def test_insert_fails(self, dsmock):
         """ test LeHierach update method"""
         from dyncode import LeObject, Rubrique, Numero, Article, Textes, Personne, Personnes, LeHierarch, LeRel2Type, RelTextesPersonneAuteur

leapi/test/test_letype.py

         """ Remove the temporary directory created at class setup """
         leapi.test.utils.cleanup(cls.tmpdir)
 
-    @patch('DataSource.dummy.leapidatasource.DummyDatasource.select')
+    @patch('DataSource.dummy.leapidatasource.LeapiDataSource.select')
     def test_populate(self, dsmock):
         from dyncode import Publication, Numero, LeObject
 
             num.populate()
             dsmock.assert_called_once_with(Numero, missing_fields, [('lodel_id','=',1)],[])
 
-    @patch('DataSource.dummy.leapidatasource.DummyDatasource.update')
+    @patch('DataSource.dummy.leapidatasource.LeapiDataSource.update')
     def test_update(self, dsmock):
         from dyncode import Publication, Numero, LeObject
         
             mock_populate.assert_called_once_with()
             dsmock.assert_called_once_with(Numero, num.uidget(), **datas)
     
-    @patch('DataSource.dummy.leapidatasource.DummyDatasource.delete')
+    @patch('DataSource.dummy.leapidatasource.LeapiDataSource.delete')
     def test_delete(self, dsmock):
         from dyncode import Publication, Numero, LeObject
         

leapi/test/utils.py

 from EditorialModel.model import Model
 import leapi
 from EditorialModel.backend.json_backend import EmBackendJson
-from DataSource.MySQL.leapidatasource import DummyDatasource
+from DataSource.dummy.leapidatasource import LeapiDataSource
 from leapi.lefactory import LeFactory
 
 
 
 genepy_args = {
     'model' : Model(EmBackendJson(json_file = 'EditorialModel/test/me.json')),
-    'datasource_cls': DummyDatasource,
-    'datasource_args': {}
 }
 
 def tmp_load_factory_code(name='dyncode'):

refreshdyn.py

 from EditorialModel.model import Model
 from leapi.lefactory import LeFactory
 from EditorialModel.backend.json_backend import EmBackendJson
-from DataSource.MySQL.leapidatasource import LeDataSourceSQL
 
 OUTPUT = 'leapi/dyn.py' if len(sys.argv) == 1 else sys.argv[1]
 EMJSON = 'EditorialModel/test/me.json' if len(sys.argv) < 3 else sys.argv[2]
 em = Model(EmBackendJson(EMJSON))
 
 fact = LeFactory(OUTPUT)
-fact.create_pyfile(em, LeDataSourceSQL, {})
-print(fact.generate_python(em, LeDataSourceSQL, {}))
+fact.create_pyfile(em)
+print(fact.generate_python(em))