EmComponent : lint + pep8

EditorialModel/components.py

@@ -2,21 +2,14 @@
 
 ## @package EditorialModel.components
 # @brief Base objects for all EditorialModel components
-# 
+#
 # Defines the EditorialModel::components::EmComponent class
 
 import datetime
-import logging
-from collections import OrderedDict
 import hashlib
-
 import EditorialModel
-from EditorialModel.exceptions import *
 from Lodel.utils.mlstring import MlString
 
-logger = logging.getLogger('Lodel2.EditorialModel')
-
-
 ## This class is the mother class of all editorial model objects
 #
 # It gather all the properties and mechanism that are common to every editorial model objects
@@ -27,9 +20,9 @@ class EmComponent(object):
     ## Used by EmComponent::modify_rank
     ranked_in = None
 
-    def __init__(self, model, uid, name, string = None, help_text = None, date_update = None, date_create = None, rank = None):
+    def __init__(self, model, uid, name, string=None, help_text=None, date_update=None, date_create=None, rank=None):
         if type(self) == EmComponent:
-           raise NotImplementedError('Abstract class')
+            raise NotImplementedError('Abstract class')
         if model.__class__.__name__ != 'Model':
             raise TypeError("Excepted type for 'model' arg is <class 'Model'> but got {} instead".format(type(model)))
 
@@ -43,14 +36,14 @@ class EmComponent(object):
         self.check_type('string', MlString)
         self.help_text = MlString() if help_text is None else help_text
         self.check_type('help_text', MlString)
-        self.date_update = datetime.datetime.now() if date_update is None else date_update #WARNING timezone !
+        self.date_update = datetime.datetime.now() if date_update is None else date_update  # WARNING timezone !
         self.check_type('date_update', datetime.datetime)
-        self.date_create = datetime.datetime.now() if date_create is None else date_create #WARNING timezone !
+        self.date_create = datetime.datetime.now() if date_create is None else date_create  # WARNING timezone !
         self.check_type('date_create', datetime.datetime)
+        self._inited = False
 
         #Handling specials ranks for component creation
         self.rank = rank
-        pass
 
     ## @brief Return a dict with attributes name as key and attributes value as value
     # @note Used at creation and deletion to call the migration handler
@@ -75,11 +68,12 @@ class EmComponent(object):
     # Identify a component with his type and name
     def uniq_name(self):
         uname = self.__class__.__name__
-        if not isinstance(self, EditorialModel.fields.EmField):
+        if not isinstance(self, EditorialModel.fields.EmField):  # WARNING this could crash with fieldtypes
             try:
-                uname += '_'+self.em_class.name
-            except AttributeError: pass
-        uname += '_'+self.name
+                uname += '_' + self.em_class.name
+            except AttributeError:
+                pass
+        uname += '_' + self.name
         return uname
 
     ## @brief This function has to be called after the instanciation, checks, and init manipulations are done
@@ -89,24 +83,23 @@ class EmComponent(object):
 
     ## @brief Reimplementation for calling the migration handler to register the change
     def __setattr__(self, attr_name, value):
-        inited = '_inited' in self.__dict__
+        inited = '_inited' in self.__dict__ and self.__dict__['_inited']
         if inited:
             # if fails raise MigrationHandlerChangeError
-            self.model.migration_handler.register_change(self.model, self.uid, {attr_name: getattr(self, attr_name) }, {attr_name: value} )
+            self.model.migration_handler.register_change(self.model, self.uid, {attr_name: getattr(self, attr_name)}, {attr_name: value})
         super(EmComponent, self).__setattr__(attr_name, value)
         if inited:
             self.model.migration_handler.register_model_state(self.model, hash(self.model))
 
     ## Check the type of attribute named var_name
     # @param var_name str : the attribute name
-    # @param excepted_type tuple|type : Tuple of type or a type 
+    # @param excepted_type tuple|type : Tuple of type or a type
     # @throw AttributeError if wrong type detected
     def check_type(self, var_name, excepted_type):
         var = getattr(self, var_name)
-        
+
         if not isinstance(var, excepted_type):
-            raise AttributeError("Excepted %s to be an %s but got %s instead" % (var_name, str(excepted_type), str(type(var))) )
-        pass
+            raise AttributeError("Excepted %s to be an %s but got %s instead" % (var_name, str(excepted_type), str(type(var))))
 
     ## @brief Hash function that allows to compare two EmComponent
     # @return EmComponent+ClassName+uid
@@ -157,7 +150,7 @@ class EmComponent(object):
     def same_rank_group(self):
         components = self.model.components(self.__class__)
         ranked_in = self.__class__.ranked_in
-        return [ c for c in components if getattr(c, ranked_in) == getattr(self, ranked_in) ]
+        return [c for c in components if getattr(c, ranked_in) == getattr(self, ranked_in)]
 
     ## Set a new rank for this component
     # @note This function assume that ranks are properly set from 1 to x with no gap
@@ -171,38 +164,36 @@ class EmComponent(object):
     # @throw ValueError if out of bound value
     def set_rank(self, new_rank):
         if not isinstance(new_rank, int):
-            raise TypeError("Excepted <class int> but got "+str(type(new_rank)))
+            raise TypeError("Excepted <class int> but got " + str(type(new_rank)))
         if new_rank <= 0 or new_rank > self.get_max_rank():
-            raise ValueError("Invalid new rank : "+str(new_rank))
+            raise ValueError("Invalid new rank : " + str(new_rank))
 
-        mod = new_rank - self.rank #Indicates the "direction" of the "move"
+        mod = new_rank - self.rank  # Indicates the "direction" of the "move"
 
         if mod == 0:
             return True
 
-        limits = [ self.rank + ( 1 if mod > 0 else -1), new_rank ] #The range of modified ranks
+        limits = [self.rank + (1 if mod > 0 else -1), new_rank]  # The range of modified ranks
         limits.sort()
 
-        for component in [ c for c in self.same_rank_group() if c.rank >= limits[0] and c.rank <= limits[1] ] :
-            component.rank = component.rank + ( -1 if mod > 0 else 1 )
+        for component in [c for c in self.same_rank_group() if c.rank >= limits[0] and c.rank <= limits[1]]:
+            component.rank = component.rank + (-1 if mod > 0 else 1)
 
         self.rank = new_rank
 
         self.model.sort_components(self.__class__)
 
-        pass
-
     ## Modify a rank given an integer modifier
     # @param rank_mod int : can be a negative positive or zero integer
     # @throw TypeError if rank_mod is not an integer
     # @throw ValueError if rank_mod is out of bound
     def modify_rank(self, rank_mod):
         if not isinstance(rank_mod, int):
-            raise TypeError("Excepted <class int>, <class str>. But got "+str(type(rank_mod))+", "+str(type(sign)))
+            raise TypeError("Excepted <class int>. But got %s" % str(type(rank_mod)))
         try:
             self.set_rank(self.rank + rank_mod)
         except ValueError:
-            raise ValueError("The rank modifier '"+str(rank_mod)+"' is out of bounds")
+            raise ValueError("The rank modifier '%s' is out of bounds" % str(rank_mod))
 
     ## @brief Return a string representation of the component
     # @return A string representation of the component
@@ -211,4 +202,3 @@ class EmComponent(object):
             return "<%s #%s, 'non populated'>" % (type(self).__name__, self.uid)
         else:
             return "<%s #%s, '%s'>" % (type(self).__name__, self.uid, self.name)
-

EditorialModel/test/test_component.py

@@ -15,13 +15,13 @@ from EditorialModel.migrationhandler.dummy import DummyMigrationHandler
 
 class TestEmComponent(unittest.TestCase):
     def setUp(self):
-        self.me =  Model(EmBackendJson('EditorialModel/test/me.json'))
-    
+        self.model = Model(EmBackendJson('EditorialModel/test/me.json'))
+
     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(True))
-        
+        me1 = Model(EmBackendJson('EditorialModel/test/me.json'))
+        me2 = Model(EmBackendJson('EditorialModel/test/me.json'), migration_handler=DummyMigrationHandler(True))
+
         for comp_class in [EmClass, EmType, EmField, EmFieldGroup]:
             comp_l1 = me1.components(comp_class)
             comp_l2 = me2.components(comp_class)
@@ -43,11 +43,11 @@ class TestEmComponent(unittest.TestCase):
     def test_virtual_methods(self):
         """ Testing virtual methods """
         with self.assertRaises(NotImplementedError):
-            foo = EmComponent(self.me, self.me.new_uid(), 'Invalide')
+            _ = EmComponent(self.model, self.model.new_uid(), 'Invalide')
 
     def test_modify_rank(self):
         """ Testing modify_rank and set_rank method """
-        cls = self.me.classes()[0]
+        cls = self.model.classes()[0]
         orig_rank = cls.rank
 
         cls.modify_rank(1)
@@ -83,7 +83,7 @@ class TestEmComponent(unittest.TestCase):
 
     def test_check(self):
         """ Testing check method """
-        cls = self.me.classes()[0]
+        cls = self.model.classes()[0]
         cls.rank = 10000
 
         cls.check()
@@ -93,10 +93,9 @@ class TestEmComponent(unittest.TestCase):
         cls.check()
         self.assertEqual(cls.rank, 1)
 
-    
     def test_dump(self):
         """ Testing dump methods """
-        for comp in self.me.components():
+        for comp in self.model.components():
             dmp = comp.attr_dump()
             self.assertNotIn('uid', dmp)
             self.assertNotIn('model', dmp)
@@ -108,10 +107,8 @@ class TestEmComponent(unittest.TestCase):
     def test_uniq_name(self):
         """ Testing uniq_name method """
         names_l = []
-        for comp in self.me.components():
+        for comp in self.model.components():
             #Should be uniq only for types and classes
             if isinstance(comp, EmType) or isinstance(comp, EmClass):
                 self.assertNotIn(comp.uniq_name, names_l)
                 names_l.append(comp.uniq_name)
-
-