Merge branch 'pep8'

Database/sqlsetup.py

 
 def init_db(dbconfname='default', alchemy_logs=None, schema=None):
 
-    dbe = sqlutils.getEngine(dbconfname, alchemy_logs)
+    dbe = sqlutils.get_engine(dbconfname, alchemy_logs)
     meta = sqlutils.meta(dbe)
     meta.reflect()
     meta.drop_all(dbe)

Database/sqlutils.py

     return ret
 
 
-def getEngine(ename='default', sqlalogging=None):
-    return get_engine(ename=ename, sqlalogging=sqlalogging)
-
-
 ## Return a sqlalchemy.MetaData object
 # @param engine sqlalchemy.engine : A sqlalchemy engine
 # @return an sql alechemy MetaData instance bind to engine

EditorialModel/components.py

     @classmethod
     ## Shortcut that return the sqlAlchemy engine
     def db_engine(cls):
-        return sqlutils.getEngine(cls.dbconf)
+        return sqlutils.get_engine(cls.dbconf)
 
     ## Do the query on the database for EmComponent::populate()
     # @throw EmComponentNotExistError if the instance is not anymore stored in database

EditorialModel/test/test_classes.py

     # should be able to select on the created table
     def test_table_em_classes(self):
         """ Testing ability of EmClass to crate its associated table """
-        conn = sqlutils.getEngine().connect()
+        conn = sqlutils.get_engine().connect()
         a = sqlutils.meta(conn)
         try:
             newtable = sqla.Table('testClass', sqlutils.meta(conn))
     # test if the table is deleted after a call to delete
     def test_table_delete(self):
         """ Test associated table deletetion on EmClass deletion """
-        dbe = sqlutils.getEngine()
+        dbe = sqlutils.get_engine()
         for i,class_name in enumerate(self.names):
             cur_class = EmClass(class_name)
             self.assertTrue(cur_class.delete(), "delete method didn't return True but the class has no fieldgroups")
         test_class = EmClass(self.names[0])
         fieldgroup = EmFieldGroup.create('fooFieldGroup', test_class)
         self.assertFalse(test_class.delete(), "delete method returns True but the class has fieldgroup")
-        dbe = sqlutils.getEngine()
+        dbe = sqlutils.get_engine()
         meta = sqlutils.meta(dbe)
         self.assertIn(self.names[0], meta.tables, "Table has been deleted but the class has fieldgroup")
         try:
     # should be able to select on the created table
     def test_table_classes_types(self):
         """ Test if a table 'testEntity_keywords' was created """
-        conn = sqlutils.getEngine().connect()
+        conn = sqlutils.get_engine().connect()
         a = sqlutils.meta(conn)
         try:
             newtable = sqla.Table('testEntity_keywords', sqlutils.meta(conn))

EditorialModel/test/test_component.py

 
     sqlsetup.init_db('default', False, tables)   
 
-    dbe = sqlutils.getEngine('default')
+    dbe = sqlutils.get_engine('default')
 
     # Insertion of testings datas
     conn = dbe.connect()
         return globals()['tables']
     
     def setUp(self):
-        self.dber = sqlutils.getEngine('default')
+        self.dber = sqlutils.get_engine('default')
         self.test_values = self.__class__.test_values
         #Db RAZ
         #shutil.copyfile(TEST_COMPONENT_DBNAME+'_bck', globals()['component_test_dbfilename'])

EditorialModel/test/test_fieldgroups.py

 
     def setUp(self):
         super(TestInit, self).setUp()
-        conn = sqlutils.getEngine().connect()
+        conn = sqlutils.get_engine().connect()
 
         ent1 = EmClass('entity1')
         idx1 = EmClass('entry1')
             { 'uid': EmFieldGroup.new_uid(), 'name': 'fg3', 'string': '{"fr":"Super Fieldgroup"}', 'help': '{"en":"help"}', 'rank': 2 , 'class_id': idx1.uid, 'date_create': self.creadate, 'date_update': self.creadate},
         ]
 
-        req = sqla.Table('em_fieldgroup', sqlutils.meta(sqlutils.getEngine())).insert(self.tfg)
+        req = sqla.Table('em_fieldgroup', sqlutils.meta(sqlutils.get_engine())).insert(self.tfg)
         conn.execute(req)
         conn.close()
         pass