[pep8] fix E203 and E303
authorNoe Gaumont <ngaumont@logilab.fr>
Fri, 12 Apr 2019 09:55:44 +0200
changeset 201 fb1509b08c30
parent 200 5c43ce22f938
child 202 5b3945773663
[pep8] fix E203 and E303
cubicweb_keyword/hooks.py
cubicweb_keyword/sobjects.py
cubicweb_keyword/views.py
test/test_classification.py
test/test_descendant_of.py
--- a/cubicweb_keyword/hooks.py	Fri Apr 12 09:38:13 2019 +0200
+++ b/cubicweb_keyword/hooks.py	Fri Apr 12 09:55:44 2019 +0200
@@ -10,6 +10,8 @@
 from cubicweb import ValidationError
 from cubicweb.server.hook import Hook, Operation, match_rtype
 from yams.schema import role_name
+from cubicweb import _
+
 
 class BeforeAddDescendantOf(Hook):
     """check indirect cycle for ``descendant_of`` relation
@@ -51,12 +53,11 @@
         # immediate test direct cycles
         if self.eidfrom == self.eidto:
             msg = self._cw._('keyword cannot be subkeyword of himself')
-            raise ValidationError(self.eidfrom, {role_name(self.rtype, 'subject') : msg})
+            raise ValidationError(self.eidfrom, {role_name(self.rtype, 'subject'): msg})
         SetIncludedInRelationOp(self._cw, vreg=self._cw.vreg,
                                 eidfrom=self.eidfrom, eidto=self.eidto)
 
 
-
 class RemoveDescendantOfRelation(Hook):
     """removes ``descendant_of`` relation
 
@@ -88,7 +89,7 @@
             if subkw.included_in[0].eid != kw.included_in[0].eid:
                 msgid = "keywords %(subkw)s and %(kw)s belong to different classifications"
                 raise ValidationError(subkw.eid, {role_name('subkeyword_of', 'subject'): cnx._(msgid) %
-                                                  {'subkw' : subkw.eid, 'kw' : kw.eid}})
+                                                  {'subkw': subkw.eid, 'kw': kw.eid}})
         else:
             cnx.execute('SET SK included_in C WHERE SK eid %(x)s, '
                             'SK subkeyword_of K, K included_in C',
--- a/cubicweb_keyword/sobjects.py	Fri Apr 12 09:38:13 2019 +0200
+++ b/cubicweb_keyword/sobjects.py	Fri Apr 12 09:55:44 2019 +0200
@@ -41,7 +41,7 @@
         session = self.req
         try:
             return session.execute('Any N WHERE X eid %(x)s, X name N',
-                                   {'x' : entity.eid}, 'x')[0][0]
+                                   {'x': entity.eid}, 'x')[0][0]
         except IndexError:
             return u'?'
 
--- a/cubicweb_keyword/views.py	Fri Apr 12 09:38:13 2019 +0200
+++ b/cubicweb_keyword/views.py	Fri Apr 12 09:55:44 2019 +0200
@@ -248,7 +248,7 @@
 def js_possible_keywords(self, eid):
     rql = ('DISTINCT Any N WHERE K is Keyword, K name N, NOT K applied_to X, '
            'X eid %(x)s, K included_in C, C classifies ET, X is ET')
-    rset = self.cursor.execute(rql, {'x' : eid, 'u' : self._cw.user.eid}, 'x')
+    rset = self.cursor.execute(rql, {'x': eid, 'u': self._cw.user.eid}, 'x')
     return [name for (name,) in rset]
 
 @ajaxfunc(output_type='json')
@@ -256,7 +256,7 @@
     msg = self._cw._('keywords applied')
     kwrset = self.cursor.execute('Any K,N,C WHERE K is Keyword, K name N, K included_in C, '
                                  'C classifies ET, X eid %(x)s, X is ET',
-                                 {'x' : eid}, 'x')
+                                 {'x': eid}, 'x')
     if not kwrset:
         return self._cw._('No suitable classification scheme found')
     classification = kwrset[0][2] # XXX what if we have several classifications ?
@@ -267,9 +267,9 @@
     if invalid_keywords:
         for keyword in invalid_keywords:
             neweid = self.cursor.execute('INSERT Keyword K: K name %(name)s, K included_in C WHERE C eid %(c)s',
-                                         {'name' : keyword, 'c' : classification}, 'c')[0][0]
+                                         {'name': keyword, 'c': classification}, 'c')[0][0]
             kweids[keyword] = str(neweid)
     if kweids:
         self.cursor.execute('SET KW applied_to X WHERE X eid %%(x)s, KW eid IN (%s)'
-                            % ','.join(kweids.values()), {'x' : eid}, 'x')
+                            % ','.join(kweids.values()), {'x': eid}, 'x')
     return msg
--- a/test/test_classification.py	Fri Apr 12 09:38:13 2019 +0200
+++ b/test/test_classification.py	Fri Apr 12 09:55:44 2019 +0200
@@ -31,14 +31,12 @@
             self.assertEqual(len(rset), 1)
             self.assertEqual(rset[0][0], 'classif1')
 
-
     def test_cannot_create_subkeyword_from_other_classification(self):
         with self.admin_access.cnx() as cnx:
             cnx.execute('SET K1 subkeyword_of K2 WHERE K1 eid %(k1)s, K2 eid %(k2)s',
                         {'k1': self.kwgroup_eid, 'k2': self.kwuser_eid})
             self.assertRaises(ValidationError, cnx.commit)
 
-
     def test_cannot_create_cycles(self):
         with self.admin_access.cnx() as cnx:
             # direct obvious cycle
--- a/test/test_descendant_of.py	Fri Apr 12 09:38:13 2019 +0200
+++ b/test/test_descendant_of.py	Fri Apr 12 09:55:44 2019 +0200
@@ -14,115 +14,127 @@
 
     def test_keyword_add1(self):
         with self.admin_access.cnx() as cnx:
-            kw1_eid = cnx.create_entity('Keyword', name=u'kw1', included_in=self.classif1_eid).eid
-            kw2_eid = cnx.create_entity('Keyword', name=u'kw2', subkeyword_of=kw1_eid, included_in=self.classif1_eid).eid
-            kw3_eid = cnx.create_entity('Keyword', name=u'kw3', subkeyword_of=kw2_eid, included_in=self.classif1_eid).eid
-            kw4_eid = cnx.create_entity('Keyword', name=u'kw4', subkeyword_of=kw3_eid, included_in=self.classif1_eid).eid
-            kw5_eid = cnx.create_entity('Keyword', name=u'kw5', subkeyword_of=kw4_eid, included_in=self.classif1_eid).eid
+            ce = cnx.create_entity
+            kw1_eid = ce('Keyword', name=u'kw1', included_in=self.classif1_eid).eid
+            kw2_eid = ce('Keyword', name=u'kw2', subkeyword_of=kw1_eid, included_in=self.classif1_eid).eid
+            kw3_eid = ce('Keyword', name=u'kw3', subkeyword_of=kw2_eid, included_in=self.classif1_eid).eid
+            kw4_eid = ce('Keyword', name=u'kw4', subkeyword_of=kw3_eid, included_in=self.classif1_eid).eid
+            kw5_eid = ce('Keyword', name=u'kw5', subkeyword_of=kw4_eid, included_in=self.classif1_eid).eid
             cnx.commit()
             parent = cnx.find('Keyword', eid=kw1_eid).one()
             child = cnx.find('Keyword', eid=kw5_eid).one()
-            self.assertCountEqual([kw.name for kw in child.cw_adapt_to('ITree').iterparents()], ['kw4', 'kw3', 'kw2', 'kw1'])
+            self.assertCountEqual([kw.name for kw in child.cw_adapt_to('ITree').iterparents()],
+                                  ['kw4', 'kw3', 'kw2', 'kw1'])
             self.assertCountEqual([kw.name for kw in child.descendant_of], ['kw4', 'kw3', 'kw2', 'kw1'])
             self.assertCountEqual([kw.name for kw in parent.reverse_descendant_of], ['kw5', 'kw4', 'kw3', 'kw2'])
-            self.assertCountEqual([kw.name for kw in parent.cw_adapt_to('ITree').recurse_children()], ['kw5', 'kw4', 'kw3', 'kw2'])
+            self.assertCountEqual([kw.name for kw in parent.cw_adapt_to('ITree').recurse_children()],
+                                  ['kw5', 'kw4', 'kw3', 'kw2'])
 
     def test_keyword_add2(self):
         with self.admin_access.cnx() as cnx:
-            kw1_eid = cnx.create_entity('Keyword', name=u'kw1', included_in=self.classif1_eid).eid
-            kw2_eid = cnx.create_entity('Keyword', name=u'kw2', subkeyword_of=kw1_eid, included_in=self.classif1_eid).eid
-            kw3_eid = cnx.create_entity('Keyword', name=u'kw3', included_in=self.classif1_eid).eid
-            kw4_eid = cnx.create_entity('Keyword', name=u'kw4', subkeyword_of=kw3_eid, included_in=self.classif1_eid).eid
-            kw5_eid = cnx.create_entity('Keyword', name=u'kw5',  subkeyword_of=kw4_eid, included_in=self.classif1_eid).eid
+            ce = cnx.create_entity
+            kw1_eid = ce('Keyword', name=u'kw1', included_in=self.classif1_eid).eid
+            kw2_eid = ce('Keyword', name=u'kw2', subkeyword_of=kw1_eid, included_in=self.classif1_eid).eid
+            kw3_eid = ce('Keyword', name=u'kw3', included_in=self.classif1_eid).eid
+            kw4_eid = ce('Keyword', name=u'kw4', subkeyword_of=kw3_eid, included_in=self.classif1_eid).eid
+            kw5_eid = ce('Keyword', name=u'kw5',  subkeyword_of=kw4_eid, included_in=self.classif1_eid).eid
             cnx.commit()
             cnx.execute('SET K3 subkeyword_of K2 WHERE K3 eid %(kw3)s, K2 eid %(kw2)s',
-                         {'kw3':kw3_eid, 'kw2':kw2_eid})
+                        {'kw3': kw3_eid, 'kw2': kw2_eid})
             cnx.commit()
             parent = cnx.find('Keyword', eid=kw1_eid).one()
             child = cnx.find('Keyword', eid=kw5_eid).one()
-            self.assertCountEqual([kw.name for kw in child.cw_adapt_to('ITree').iterparents()], ['kw4', 'kw3', 'kw2', 'kw1'])
+            self.assertCountEqual([kw.name for kw in child.cw_adapt_to('ITree').iterparents()],
+                                  ['kw4', 'kw3', 'kw2', 'kw1'])
             self.assertCountEqual([kw.name for kw in child.descendant_of], ['kw4', 'kw3', 'kw2', 'kw1'])
             self.assertCountEqual([kw.name for kw in parent.reverse_descendant_of], ['kw5', 'kw4', 'kw3', 'kw2'])
-            self.assertCountEqual([kw.name for kw in parent.cw_adapt_to('ITree').recurse_children()], ['kw5', 'kw4', 'kw3', 'kw2'])
+            self.assertCountEqual([kw.name for kw in parent.cw_adapt_to('ITree').recurse_children()],
+                                  ['kw5', 'kw4', 'kw3', 'kw2'])
 
     def test_keyword_add3(self):
         with self.admin_access.cnx() as cnx:
-            kw1_eid = cnx.create_entity('Keyword', name=u'kw1', included_in=self.classif1_eid).eid
-            kw2_eid = cnx.create_entity('Keyword', name=u'kw2', subkeyword_of=kw1_eid, included_in=self.classif1_eid).eid
-            kw3_eid = cnx.create_entity('Keyword', name=u'kw3', included_in=self.classif1_eid).eid
-            kw4_eid = cnx.create_entity('Keyword', name=u'kw4', included_in=self.classif1_eid).eid
-            kw5_eid = cnx.create_entity('Keyword', name=u'kw5', subkeyword_of=kw4_eid, included_in=self.classif1_eid).eid
+            ce = cnx.create_entity
+            kw1_eid = ce('Keyword', name=u'kw1', included_in=self.classif1_eid).eid
+            kw2_eid = ce('Keyword', name=u'kw2', subkeyword_of=kw1_eid, included_in=self.classif1_eid).eid
+            kw3_eid = ce('Keyword', name=u'kw3', included_in=self.classif1_eid).eid
+            kw4_eid = ce('Keyword', name=u'kw4', included_in=self.classif1_eid).eid
+            kw5_eid = ce('Keyword', name=u'kw5', subkeyword_of=kw4_eid, included_in=self.classif1_eid).eid
             cnx.commit()
             cnx.execute('SET K2 subkeyword_of K3 WHERE K2 eid %(k2)s, K3 eid %(k3)s',
-                         {'k2': kw4_eid, 'k3': kw3_eid})
+                        {'k2': kw4_eid, 'k3': kw3_eid})
             cnx.execute('SET K3 subkeyword_of K4 WHERE K3 eid %(k3)s, K4 eid %(k4)s',
-                         {'k3': kw3_eid, 'k4': kw2_eid})
+                        {'k3': kw3_eid, 'k4': kw2_eid})
             cnx.commit()
             child = cnx.find('Keyword', eid=kw5_eid).one()
             parent = cnx.find('Keyword', eid=kw1_eid).one()
             self.assertCountEqual([kw.name for kw in child.descendant_of], ['kw4', 'kw3', 'kw2', 'kw1'])
             # XXX check the order of iterparents
-            self.assertCountEqual([kw.name for kw in child.cw_adapt_to('ITree').iterparents()], ['kw4', 'kw3', 'kw2', 'kw1'])
-            self.assertCountEqual([kw.name for kw in parent.cw_adapt_to('ITree').recurse_children()], ['kw2', 'kw3', 'kw4', 'kw5'])
+            self.assertCountEqual([kw.name for kw in child.cw_adapt_to('ITree').iterparents()],
+                                  ['kw4', 'kw3', 'kw2', 'kw1'])
+            self.assertCountEqual([kw.name for kw in parent.cw_adapt_to('ITree').recurse_children()],
+                                  ['kw2', 'kw3', 'kw4', 'kw5'])
             self.assertCountEqual([kw.name for kw in parent.reverse_descendant_of], ['kw2', 'kw3', 'kw4', 'kw5'])
 
     def test_keyword_add4(self):
         with self.admin_access.cnx() as cnx:
-            kw0_eid = cnx.create_entity('Keyword', name=u'kw0', included_in=self.classif1_eid).eid
-            kw1_eid = cnx.create_entity('Keyword', name=u'kw1', included_in=self.classif1_eid).eid
-            kw2_eid = cnx.create_entity('Keyword', name=u'kw2', subkeyword_of=kw1_eid, included_in=self.classif1_eid).eid
-            kw3_eid = cnx.create_entity('Keyword', name=u'kw3', included_in=self.classif1_eid).eid
-            kw4_eid = cnx.create_entity('Keyword', name=u'kw4', included_in=self.classif1_eid).eid
-            kw5_eid = cnx.create_entity('Keyword', name=u'kw5',  subkeyword_of=kw4_eid, included_in=self.classif1_eid).eid
+            ce = cnx.create_entity
+            kw0_eid = ce('Keyword', name=u'kw0', included_in=self.classif1_eid).eid
+            kw1_eid = ce('Keyword', name=u'kw1', included_in=self.classif1_eid).eid
+            kw2_eid = ce('Keyword', name=u'kw2', subkeyword_of=kw1_eid, included_in=self.classif1_eid).eid
+            kw3_eid = ce('Keyword', name=u'kw3', included_in=self.classif1_eid).eid
+            kw4_eid = ce('Keyword', name=u'kw4', included_in=self.classif1_eid).eid
+            kw5_eid = ce('Keyword', name=u'kw5',  subkeyword_of=kw4_eid, included_in=self.classif1_eid).eid
             cnx.execute('SET K3 subkeyword_of K2 WHERE K3 eid %(kw3)s, K2 eid %(kw2)s',
-                         {'kw2': kw2_eid, 'kw3': kw3_eid})
-            cnx.commit();
+                        {'kw2': kw2_eid, 'kw3': kw3_eid})
+            cnx.commit()
             kw3 = cnx.find('Keyword', eid=kw3_eid).one()
             self.assertCountEqual([kw.name for kw in kw3.descendant_of], ['kw1', 'kw2'])
             cnx.execute('SET K3 descendant_of K0 WHERE K3 eid %(kw3)s, K0 eid %(kw0)s',
-                          {'kw3': kw3_eid, 'kw0': kw0_eid})
+                        {'kw3': kw3_eid, 'kw0': kw0_eid})
             cnx.commit()
             kw3 = cnx.find('Keyword', eid=kw3_eid).one()
             self.assertCountEqual([kw.name for kw in kw3.descendant_of], ['kw0', 'kw1', 'kw2'])
             cnx.execute('SET K3 descendant_of K4 WHERE K3 eid %(kw3)s, K4 eid %(kw4)s',
-                          {'kw3': kw3_eid, 'kw4': kw4_eid})
+                        {'kw3': kw3_eid, 'kw4': kw4_eid})
             cnx.commit()
             kw3 = cnx.find('Keyword', eid=kw3_eid).one()
             self.assertCountEqual([kw.name for kw in kw3.descendant_of], ['kw0', 'kw1', 'kw2', 'kw4'])
             cnx.execute('SET K3 descendant_of K5 WHERE K3 eid %(kw3)s, K5 eid %(kw5)s',
-                           {'kw3': kw3_eid, 'kw5': kw5_eid})
+                        {'kw3': kw3_eid, 'kw5': kw5_eid})
             cnx.commit()
             kw3.cw_clear_all_caches()
             self.assertCountEqual([kw.name for kw in kw3.descendant_of], ['kw0', 'kw1', 'kw2', 'kw4', 'kw5'])
 
     def test_keyword_update1(self):
         with self.admin_access.cnx() as cnx:
-            kw1_eid = cnx.create_entity('Keyword', name=u'kw1', included_in=self.classif1_eid).eid
-            kw2_eid = cnx.create_entity('Keyword', name=u'kw2', subkeyword_of=kw1_eid, included_in=self.classif1_eid).eid
-            kw3_eid = cnx.create_entity('Keyword', name=u'kw3', included_in=self.classif1_eid).eid
-            kw4_eid = cnx.create_entity('Keyword', name=u'kw4', included_in=self.classif1_eid).eid
-            kw5_eid = cnx.create_entity('Keyword', name=u'kw5',  subkeyword_of=kw4_eid, included_in=self.classif1_eid).eid
+            ce = cnx.create_entity
+            kw1_eid = ce('Keyword', name=u'kw1', included_in=self.classif1_eid).eid
+            kw2_eid = ce('Keyword', name=u'kw2', subkeyword_of=kw1_eid, included_in=self.classif1_eid).eid
+            kw3_eid = ce('Keyword', name=u'kw3', included_in=self.classif1_eid).eid
+            kw4_eid = ce('Keyword', name=u'kw4', included_in=self.classif1_eid).eid
+            kw5_eid = ce('Keyword', name=u'kw5',  subkeyword_of=kw4_eid, included_in=self.classif1_eid).eid
             cnx.execute('SET K3 subkeyword_of K2 WHERE K3 eid %(kw3)s, K2 eid %(kw2)s',
-                          {'kw3': kw3_eid, 'kw2': kw2_eid})
+                        {'kw3': kw3_eid, 'kw2': kw2_eid})
             cnx.commit();
             kw3 = cnx.find('Keyword', eid=kw3_eid).one()
             self.assertCountEqual([kw.name for kw in kw3.descendant_of], ['kw1', 'kw2'])
             cnx.execute('SET K3 subkeyword_of K4 WHERE K3 eid %(kw3)s, K4 eid %(kw4)s',
-                          {'kw3': kw3_eid, 'kw4': kw4_eid})
+                        {'kw3': kw3_eid, 'kw4': kw4_eid})
             cnx.commit()
             kw3 = cnx.find('Keyword', eid=kw3_eid).one()
             self.assertCountEqual([kw.name for kw in kw3.descendant_of], ['kw4'])
             cnx.execute('SET K3 subkeyword_of K5 WHERE K3 eid %(kw3)s, K5 eid %(kw5)s',
-                         {'kw3': kw3_eid, 'kw5': kw5_eid})
+                        {'kw3': kw3_eid, 'kw5': kw5_eid})
             cnx.commit()
             kw3 = cnx.find('Keyword', eid=kw3_eid).one()
             self.assertCountEqual([kw.name for kw in kw3.descendant_of], ['kw4', 'kw5'])
 
     def test_keyword_descendant_of(self):
         with self.admin_access.cnx() as cnx:
-            kw1_eid = cnx.create_entity('Keyword', name=u'kw1', included_in=self.classif1_eid).eid
-            kw2_eid = cnx.create_entity('Keyword', name=u'kw2', subkeyword_of=kw1_eid, included_in=self.classif1_eid).eid
-            kw3_eid = cnx.create_entity('Keyword', name=u'kw3', subkeyword_of=kw1_eid, included_in=self.classif1_eid).eid
+            ce = cnx.create_entity
+            kw1_eid = ce('Keyword', name=u'kw1', included_in=self.classif1_eid).eid
+            kw2_eid = ce('Keyword', name=u'kw2', subkeyword_of=kw1_eid, included_in=self.classif1_eid).eid
+            kw3_eid = ce('Keyword', name=u'kw3', subkeyword_of=kw1_eid, included_in=self.classif1_eid).eid
             cnx.commit()
 
             kw1 = cnx.find('Keyword', eid=kw1_eid).one()
@@ -132,11 +144,11 @@
             self.assertCountEqual([kw.name for kw in kw3.descendant_of], ['kw1', ])
             self.assertCountEqual([kw.name for kw in kw1.reverse_descendant_of], ['kw3', 'kw2'])
             self.assertCountEqual([kw.name for kw in kw1.cw_adapt_to('ITree').recurse_children()], ['kw2', 'kw3'])
-            kw0_eid = cnx.create_entity('Keyword', name=u'kw0', included_in=self.classif1_eid).eid
+            kw0_eid = ce('Keyword', name=u'kw0', included_in=self.classif1_eid).eid
 
             cnx.execute('SET K1 subkeyword_of K0 WHERE K1 eid %(kw1)s, K0 eid %(kw0)s',
-                          {'kw1': kw1_eid, 'kw0': kw0_eid})
-            cnx.commit();
+                        {'kw1': kw1_eid, 'kw0': kw0_eid})
+            cnx.commit()
 
             kw0 = cnx.find('Keyword', eid=kw0_eid).one()
             kw1 = cnx.find('Keyword', eid=kw1_eid).one()
@@ -144,23 +156,23 @@
             kw3 = cnx.find('Keyword', eid=kw3_eid).one()
             self.assertCountEqual([kw.name for kw in kw0.cw_adapt_to('ITree').recurse_children()], ['kw1', 'kw2', 'kw3'])
             self.assertCountEqual([kw.name for kw in kw0.reverse_descendant_of], ['kw3', 'kw2', 'kw1'])
-            self.assertCountEqual([kw.name for kw in kw1.descendant_of], ['kw0',])
+            self.assertCountEqual([kw.name for kw in kw1.descendant_of], ['kw0'])
             self.assertCountEqual([kw.name for kw in kw2.descendant_of], ['kw1', 'kw0'])
             self.assertCountEqual([kw.name for kw in kw3.descendant_of], ['kw1', 'kw0'])
 
-
     def test_keyword_delete(self):
         """*after_delete_relation* of ``subkeyword_of``
         """
         with self.admin_access.cnx() as cnx:
-            kw1_eid = cnx.create_entity('Keyword', name=u'kw1', included_in=self.classif1_eid).eid
-            kw2_eid = cnx.create_entity('Keyword', name=u'kw2', subkeyword_of=kw1_eid, included_in=self.classif1_eid).eid
-            kw3_eid = cnx.create_entity('Keyword', name=u'kw3', subkeyword_of=kw2_eid, included_in=self.classif1_eid).eid
-            kw4_eid = cnx.create_entity('Keyword', name=u'kw4', subkeyword_of=kw3_eid, included_in=self.classif1_eid).eid
-            kw5_eid = cnx.create_entity('Keyword', name=u'kw5',  subkeyword_of=kw4_eid, included_in=self.classif1_eid).eid
+            ce = cnx.create_entity
+            kw1_eid = ce('Keyword', name=u'kw1', included_in=self.classif1_eid).eid
+            kw2_eid = ce('Keyword', name=u'kw2', subkeyword_of=kw1_eid, included_in=self.classif1_eid).eid
+            kw3_eid = ce('Keyword', name=u'kw3', subkeyword_of=kw2_eid, included_in=self.classif1_eid).eid
+            kw4_eid = ce('Keyword', name=u'kw4', subkeyword_of=kw3_eid, included_in=self.classif1_eid).eid
+            ce('Keyword', name=u'kw5',  subkeyword_of=kw4_eid, included_in=self.classif1_eid).eid
             cnx.commit()
             cnx.execute('DELETE K subkeyword_of K3 WHERE K is Keyword, K eid %(kw3)s',
-                         {'kw3':kw3_eid})
+                        {'kw3': kw3_eid})
             cnx.commit()
             kw3 = cnx.find('Keyword', eid=kw3_eid).one()
             self.assertCountEqual([kw.name for kw in kw3.cw_adapt_to('ITree').iterparents()], [])
@@ -171,18 +183,20 @@
     def test_no_add_descendant_cycle(self):
         """no ``descendant_of`` cycle"""
         with self.admin_access.cnx() as cnx:
-            kw1 = cnx.create_entity('Keyword', name=u'kw1', included_in=self.classif1_eid)
-            kw2 = cnx.create_entity('Keyword', name=u'kw2', subkeyword_of=kw1, included_in=self.classif1_eid)
-            kw3 = cnx.create_entity('Keyword', name=u'kw3', subkeyword_of=kw2, included_in=self.classif1_eid)
+            ce = cnx.create_entity
+            kw1 = ce('Keyword', name=u'kw1', included_in=self.classif1_eid)
+            kw2 = ce('Keyword', name=u'kw2', subkeyword_of=kw1, included_in=self.classif1_eid)
+            kw3 = ce('Keyword', name=u'kw3', subkeyword_of=kw2, included_in=self.classif1_eid)
             cnx.commit()
-            rql = 'SET K1 descendant_of K3 WHERE K1 eid %(kw1)s, K3 eid %(kw3)s' % {'kw1':kw1.eid,  'kw3':kw3.eid}
+            rql = 'SET K1 descendant_of K3 WHERE K1 eid %(kw1)s, K3 eid %(kw3)s' % {'kw1': kw1.eid,  'kw3': kw3.eid}
             self.assertRaises(ValidationError, cnx.execute, rql)
             cnx.rollback()
-            kw4 = cnx.create_entity('Keyword', name=u'kw4', included_in=self.classif1_eid)
-            kw5 = cnx.create_entity('Keyword', name=u'kw4', subkeyword_of=kw4, included_in=self.classif1_eid)
+            kw4 = ce('Keyword', name=u'kw4', included_in=self.classif1_eid)
+            kw5 = ce('Keyword', name=u'kw4', subkeyword_of=kw4, included_in=self.classif1_eid)
             cnx.commit()
-            with self.assertRaises(ValidationError) as cm:
-                cnx.execute('SET K4 descendant_of K5 WHERE K4 eid %(kw4)s, K5 eid %(kw5)s' % {'kw4':kw4.eid,  'kw5':kw5.eid})
+            with self.assertRaises(ValidationError):
+                cnx.execute('SET K4 descendant_of K5 WHERE K4 eid %(kw4)s, K5 eid %(kw5)s',
+                            {'kw4': kw4.eid,  'kw5': kw5.eid})
 
 if __name__ == '__main__':
     from logilab.common.testlib import unittest_main