Replacing EmComponent method getDbE by db_engine

Database/sqlutils.py

     from EditorialModel.components import EmComponent #dirty circula inclusion hack
     if not issubclass(cls, EmComponent) or cls.table == None:
         raise TypeError("Excepting an EmComponent child class not an "+str(cls))
-    engine = cls.getDbE()
+    engine = cls.db_engine()
     return sqla.Table(cls.table, meta(engine))
 
 ## This function is intended to execute ddl defined in sqlalter

EditorialModel/components.py

     ## Shortcut that return the sqlAlchemy engine
     def db_engine(cls):
         return sqlutils.getEngine(cls.dbconf)
-    @classmethod
-    def getDbE(cls): return cls.db_engine();
 
     ## Do the query on the database for EmComponent::populate()
     # @throw EmComponentNotExistError if the instance is not anymore stored in database
     def _populate_db(self):
-        dbe = self.__class__.getDbE()
+        dbe = self.__class__.db_engine()
         component = sql.Table(self.table, sqlutils.meta(dbe))
         req = sql.sql.select([component])
 
         kwargs['uid'] = cls.new_uid()
         kwargs['date_update'] = kwargs['date_create'] = datetime.datetime.utcnow()
 
-        dbe = cls.getDbE()
+        dbe = cls.db_engine()
         conn = dbe.connect()
 
         kwargs['rank'] = -1  # Warning !!!
     # @throw RunTimeError if it was unable to do the Db update
     def _save_db(self, values):
         """ Do the query on the db """
-        dbe = self.__class__.getDbE()
+        dbe = self.__class__.db_engine()
         component = sql.Table(self.table, sqlutils.meta(dbe))
         req = sql.update(component, values=values).where(component.c.uid == self.uid)
 
     # @throw RunTimeError if it was unable to do the deletion
     def delete(self):
         #<SQL>
-        dbe = self.__class__.getDbE()
+        dbe = self.__class__.db_engine()
         component = sql.Table(self.table, sqlutils.meta(dbe))
         req = component.delete().where(component.c.uid == self.uid)
         conn = dbe.connect()
     # Retourne le rank le plus élevé pour le groupe de component au quel apartient l'objet actuelle
     #return int
     def get_max_rank(self):
-        dbe = self.__class__.getDbE()
+        dbe = self.__class__.db_engine()
         component = sql.Table(self.table, sqlutils.meta(dbe))
         req = sql.sql.select([component.c.rank]).where(getattr(component.c, self.ranked_in) == getattr(self, self.ranked_in)).order_by(component.c.rank.desc())
         conn = dbe.connect()
         
         if isinstance(new_rank, int):
             if (new_rank >= 0):
-                dbe = self.__class__.getDbE()
+                dbe = self.__class__.db_engine()
                 component = sql.Table(self.table, sqlutils.meta(dbe))
                 req = sql.sql.select([component.c.uid, component.c.rank])
 
         if cls.table is None:
             raise NotImplementedError("Abstract method")
 
-        dbe = cls.getDbE()
+        dbe = cls.db_engine()
 
         uidtable = sql.Table('uids', sqlutils.meta(dbe))
         conn = dbe.connect()

EditorialModel/test/test_field.py

     # @param field EmField: EmField object
     # @return Number of found records
     def _get_field_records_Db(self,field):
-        dbe = EmComponent.getDbE()
+        dbe = EmComponent.db_engine()
         fieldtable = sqla.Table(EmField.table, sqlutils.meta(dbe))
         conn = dbe.connect()
         req = fieldtable.select().where(fieldtable.c.uid==field.uid).where(fieldtable.c.name==field.name)
     # @param table_name str: Name of the table
     # @return list of columns
     def _get_table_columns_Db(self, table_name):
-        table = sqla.Table(table_name, sqlutils.meta(EmComponent.getDbE()))
+        table = sqla.Table(table_name, sqlutils.meta(EmComponent.db_engine()))
         return table.c
 
 ## TestField (Class)

EditorialModel/types.py

     def field_groups(self):
         fg_table = sqlutils.getTable(EmFieldGroup)
         req = fg_table.select(fg_table.c.uid).where(fg_table.c.class_id == self.class_id)
-        conn = self.__class__.getDbE().connect()
+        conn = self.__class__.db_engine().connect()
         res = conn.execute(req)
         rows = res.fetchall()
         conn.close()
     # @return sqlalchemy em_type_hierarchy table object
     # @todo Don't hardcode table name
     def _tableHierarchy(cl):
-        return sql.Table('em_type_hierarchy', sqlutils.meta(cl.getDbE()))
+        return sql.Table('em_type_hierarchy', sqlutils.meta(cl.db_engine()))
 
     @property
     ## Return the EmClassType of the type
     # @throw RunTimeError if a nature fetched from db is not valid
     # @see EmType::subordinates(), EmType::superiors()
     def _subOrSup(self, sup = True):
-        conn = self.getDbE().connect()
+        conn = self.db_engine().connect()
         htable = self.__class__._tableHierarchy()
         req = htable.select()
         if sup:
         elif self.name != em_type.name:
             raise ValueError("Not allowed to put a different em_type as superior in a relation of nature '"+relation_nature+"'")
 
-        conn = self.getDbE().connect()
+        conn = self.db_engine().connect()
         htable = self.__class__._tableHierarchy()
         values = { 'subordinate_id': self.uid, 'superior_id': em_type.uid, 'nature': relation_nature }
         req = htable.insert(values=values)
         if relation_nature not in EmClassType.natures(self.classtype['name']):
             raise ValueError("Invalid nature for add_superior : '"+relation_nature+"'. Allowed relations for this type are "+str(EmClassType.natures(self.classtype['name'])))
 
-        conn = self.getDbE().connect()
+        conn = self.db_engine().connect()
         htable = self.__class__._tableHierarchy()
         req = htable.delete(htable.c.superior_id == em_type.uid and htable.c.nature == relation_nature)
         conn.execute(req)
     ## @brief Return the list of all the types linked to this type, should they be superiors or subordinates
     # @return A list of EmType objects
     def _linked_types_Db(self):
-        conn = self.getDbE().connect()
+        conn = self.db_engine().connect()
         htable = self.__class__._tableHierarchy()
         req = htable.select(htable.c.superior_id, htable.c.subordinate_id)
         req = req.where(sql.or_(htable.c.subordinate_id == self.uid, htable.c.superior_id == self.uid))