cleanup

tracim/lib/content.py

 
 import datetime
 import re
+import typing
 
 from tracim.translation import fake_translator as _
 
 from tracim.models.revision_protection import new_revision
 from tracim.models.auth import User
 from tracim.models.data import ActionDescription
-from tracim.models.data import BreadcrumbItem
 from tracim.models.data import ContentStatus
 from tracim.models.data import ContentRevisionRO
 from tracim.models.data import Content
 from tracim.models.data import UserRoleInWorkspace
 from tracim.models.data import Workspace
 
-def compare_content_for_sorting_by_type_and_name(content1: Content,
-                                                 content2: Content):
+
+def compare_content_for_sorting_by_type_and_name(
+        content1: Content,
+        content2: Content
+):
     """
     :param content1:
     :param content2:
         else:
             return 0
 
-def compare_tree_items_for_sorting_by_type_and_name(item1: NodeTreeItem, item2: NodeTreeItem):
+
+def compare_tree_items_for_sorting_by_type_and_name(
+        item1: NodeTreeItem,
+        item2: NodeTreeItem
+):
     return compare_content_for_sorting_by_type_and_name(item1.node, item2.node)
 
 
     def __init__(
             self,
             session: Session,
-            current_user: User,
+            current_user: typing.Optional[User],
             show_archived=False,
             show_deleted=False,
             show_temporary=False,

tracim/lib/group.py

 # -*- coding: utf-8 -*-
+import typing
 
 __author__ = 'damien'
 
 
 class GroupApi(object):
 
-    def __init__(self, session: Session, current_user: User):
+    def __init__(
+            self,
+            session: Session,
+            current_user: typing.Optional[User],
+    ):
         self._user = current_user
         self._session = session
 

tracim/lib/user.py

 
 class UserApi(object):
 
-    def __init__(self, current_user: User, session, config):
+    def __init__(self, current_user: typing.Optional[User], session, config):
         self._session = session
         self._user = current_user
         self._config = config

tracim/lib/userworkspace.py

 # -*- coding: utf-8 -*-
+import typing
 
 __author__ = 'damien'
 
 
         return role
 
-    def __init__(self, session: Session, current_user: User):
+    def __init__(self, session: Session, current_user: typing.Optional[User]):
         self._session = session
         self._user = current_user
 

tracim/tests/library/test_content_api.py

 
         user = uapi.create_user(email='this.is@user',
                                 groups=groups, save_now=True)
-        workspace = WorkspaceApi(current_user=user, session=self.session).create_workspace('test workspace',
-                                                        save_now=True)
+        workspace = WorkspaceApi(
+            current_user=user,
+            session=self.session
+        ).create_workspace('test workspace', save_now=True)
         api = ContentApi(
             current_user=user,
             session=self.session,
         # Refresh instances after commit
         user = uapi.get_one(uid)
         workspace_api = WorkspaceApi(current_user=user, session=self.session)
-        workspace= workspace_api.get_one(wid)
+        workspace = workspace_api.get_one(wid)
         api = ContentApi(current_user=user, session=self.session)
         items = api.get_all(None, ContentType.Any, workspace)
         eq_(2, len(items))
         # Refresh instances after commit
         user = uapi.get_one(uid)
         workspace_api = WorkspaceApi(current_user=user, session=self.session)
-        workspace= workspace_api.get_one(wid)
+        workspace = workspace_api.get_one(wid)
         api = ContentApi(
             current_user=user, 
             session=self.session
         items = api.get_all(None, ContentType.Any, workspace)
         eq_(2, len(items))
 
-
     def test_archive(self):
         uapi = UserApi(
             session=self.session,
             config=CFG(self.config.get_settings()),
             current_user=None,
         )
-        group_api = GroupApi(current_user=None,session=self.session)
+        group_api = GroupApi(current_user=None, session=self.session)
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
         # Refresh instances after commit
         user = uapi.get_one(uid)
         workspace_api = WorkspaceApi(current_user=user, session=self.session)
-        workspace= workspace_api.get_one(wid)
+        workspace = workspace_api.get_one(wid)
         api = ContentApi(
             current_user=user, 
             session=self.session
         # Refresh instances after commit
         user = uapi.get_one(uid)
         workspace_api = WorkspaceApi(current_user=user, session=self.session)
-        workspace= workspace_api.get_one(wid)
+        workspace = workspace_api.get_one(wid)
         api = ContentApi(
-            current_user=user, 
+            current_user=user,
             session=self.session
         )
 
             config=CFG(self.config.get_settings()),
             current_user=None,
         )
-        group_api = GroupApi(current_user=None,session=self.session)
+        group_api = GroupApi(current_user=None, session=self.session)
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(email='this.is@user',
-                                groups=groups, save_now=True)
-        workspace = WorkspaceApi(current_user=user, session=self.session).create_workspace('test workspace',
-                                                        save_now=True)
+        user = uapi.create_user(
+            email='this.is@user',
+            groups=groups,
+            save_now=True
+        )
+        workspace = WorkspaceApi(
+            current_user=user,
+            session=self.session
+        ).create_workspace(
+            'test workspace',
+            save_now=True
+        )
+
         api = ContentApi(
             current_user=user,
             session=self.session,
         # Refresh instances after commit
         user = uapi.get_one(uid)
         workspace_api = WorkspaceApi(current_user=user, session=self.session)
-        workspace= workspace_api.get_one(wid)
+        workspace = workspace_api.get_one(wid)
         api = ContentApi(
             current_user=user, 
             session=self.session
             config=CFG(self.config.get_settings()),
             current_user=None,
         )
-        group_api = GroupApi(current_user=None,session=self.session)
+        group_api = GroupApi(current_user=None, session=self.session)
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
         user = uapi.create_user(email='this.is@user',
                                 groups=groups, save_now=True)
-        workspace = WorkspaceApi(current_user=user, session=self.session).create_workspace('test workspace',
-                                                        save_now=True)
+        workspace = WorkspaceApi(
+            current_user=user,
+            session=self.session
+        ).create_workspace('test workspace', save_now=True)
         api = ContentApi(
             current_user=user, 
             session=self.session
         # Refresh instances after commit
         user = uapi.get_one(uid)
         workspace_api = WorkspaceApi(current_user=user, session=self.session)
-        workspace= workspace_api.get_one(wid)
+        workspace = workspace_api.get_one(wid)
         api = ContentApi(
             current_user=user,
             session=self.session
             config=CFG(self.config.get_settings()),
             current_user=None,
         )
-        group_api = GroupApi(current_user=None,session=self.session)
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session
+        )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
         user = uapi.create_user(email='this.is@user',
                                 groups=groups, save_now=True)
 
-        workspace = WorkspaceApi(current_user=user, session=self.session).create_workspace('test workspace',
-                                                        save_now=True)
+        workspace = WorkspaceApi(
+            current_user=user,
+            session=self.session
+        ).create_workspace(
+            'test workspace',
+            save_now=True
+        )
         api = ContentApi(
             current_user=user, 
             session=self.session
             config=CFG(self.config.get_settings()),
             current_user=None,
         )
-        group_api = GroupApi(current_user=None,session=self.session)
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session
+        )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
         user = uapi.create_user(email='this.is@user',
                                 groups=groups, save_now=True)
 
-        workspace = WorkspaceApi(current_user=user, session=self.session).create_workspace('test workspace',
-                                                        save_now=True)
+        workspace = WorkspaceApi(
+            current_user=user,
+            session=self.session
+        ).create_workspace(
+            'test workspace',
+            save_now=True
+        )
         api = ContentApi(
             current_user=user, 
             session=self.session
             config=CFG(self.config.get_settings()),
             current_user=None,
         )
-        group_api = GroupApi(current_user=None,session=self.session)
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session
+        )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
         user = uapi.create_user(email='this.is@user',
                                 groups=groups, save_now=True)
 
-        workspace = WorkspaceApi(current_user=user, session=self.session).create_workspace('test workspace',
-                                                        save_now=True)
+        workspace = WorkspaceApi(
+            current_user=user,
+            session=self.session
+        ).create_workspace(
+            'test workspace',
+            save_now=True
+        )
 
         api = ContentApi(
             current_user=user,
             config=CFG(self.config.get_settings()),
             current_user=None,
         )
-        group_api = GroupApi(current_user=None,session=self.session)
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session
+        )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
             groups=groups,
             save_now=True
         )
-        workspace = WorkspaceApi(current_user=user, session=self.session).create_workspace(
+        workspace = WorkspaceApi(
+            current_user=user,
+            session=self.session
+        ).create_workspace(
             'test workspace',
             save_now=True
         )
             config=CFG(self.config.get_settings()),
             current_user=None,
         )
-        group_api = GroupApi(current_user=None,session=self.session)
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session
+        )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
             groups=groups,
             save_now=True
         )
-        workspace = WorkspaceApi(current_user=user, session=self.session).create_workspace(
+        workspace = WorkspaceApi(
+            current_user=user,
+            session=self.session
+        ).create_workspace(
             'test workspace',
             save_now=True
         )
             config=CFG(self.config.get_settings()),
             current_user=None,
         )
-        group_api = GroupApi(current_user=None,session=self.session)
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session
+        )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
             groups=groups,
             save_now=True
         )
-        workspace = WorkspaceApi(current_user=user, session=self.session).create_workspace(
+        workspace = WorkspaceApi(
+            current_user=user,
+            session=self.session
+        ).create_workspace(
             'test workspace',
             save_now=True
         )
             config=CFG(self.config.get_settings()),
             current_user=None,
         )
-        group_api = GroupApi(current_user=None,session=self.session)
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session
+        )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
             current_user=user_a,
             session=self.session,
         )
-        role_api1.create_one(user_b, workspace1, UserRoleInWorkspace.READER,
-                            False)
+        role_api1.create_one(
+            user_b,
+            workspace1,
+            UserRoleInWorkspace.READER,
+            False
+        )
 
         role_api2 = RoleApi(
             current_user=user_b,
             session=self.session,
         )
 
-
         # Creates page_1 & page_2 in workspace 1
         #     and page_3 & page_4 in workspace 2
         page_1 = cont_api_a.create(ContentType.Page, workspace1, None,
             config=CFG(self.config.get_settings()),
             current_user=None,
         )
-        group_api = GroupApi(current_user=None,session=self.session)
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session
+        )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user_a = uapi.create_user(email='this.is@user',
-                                 groups=groups, save_now=True)
-        user_b = uapi.create_user(email='this.is@another.user',
-                                 groups=groups, save_now=True)
+        user_a = uapi.create_user(
+            email='this.is@user',
+            groups=groups,
+            save_now=True
+        )
+        user_b = uapi.create_user(
+            email='this.is@another.user',
+            groups=groups,
+            save_now=True
+        )
 
         wapi = WorkspaceApi(current_user=user_a, session=self.session)
-        workspace_api = WorkspaceApi(current_user=user_a, session=self.session)
+        workspace_api = WorkspaceApi(
+            current_user=user_a,
+            session=self.session
+        )
         workspace = wapi.create_workspace(
             'test workspace',
             save_now=True)
             current_user=user_a,
             session=self.session,
         )
-        role_api.create_one(user_b, workspace, UserRoleInWorkspace.READER, False)
+        role_api.create_one(
+            user_b,
+            workspace,
+            UserRoleInWorkspace.READER,
+            False
+        )
         cont_api_a = ContentApi(
             current_user=user_a,
             session=self.session,
         for rev in page_1.revisions:
             eq_(user_b in rev.read_by.keys(), True)
 
-
     def test_mark_read__all(self):
         uapi = UserApi(
             session=self.session,
             config=CFG(self.config.get_settings()),
             current_user=None,
         )
-        group_api = GroupApi(current_user=None,session=self.session)
+        group_api = GroupApi(current_user=None, session=self.session)
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user_a = uapi.create_user(email='this.is@user',
-                                 groups=groups, save_now=True)
-        user_b = uapi.create_user(email='this.is@another.user',
-                                 groups=groups, save_now=True)
+        user_a = uapi.create_user(
+            email='this.is@user',
+            groups=groups,
+            save_now=True
+        )
+        user_b = uapi.create_user(
+            email='this.is@another.user',
+            groups=groups,
+            save_now=True
+        )
 
         wapi = WorkspaceApi(
             current_user=user_a,
             current_user=user_a,
             session=self.session,
         )
-        role_api.create_one(user_b, workspace, UserRoleInWorkspace.READER, False)
+        role_api.create_one(
+            user_b,
+            workspace,
+            UserRoleInWorkspace.READER,
+            False
+        )
         cont_api_a = ContentApi(
             current_user=user_a,
             session=self.session,
             session=self.session,
         )
 
-        page_2 = cont_api_a.create(ContentType.Page, workspace, None, 'this is page1', do_save=True)
-        page_3 = cont_api_a.create(ContentType.Thread, workspace, None, 'this is page2', do_save=True)
-        page_4 = cont_api_a.create(ContentType.File, workspace, None, 'this is page3', do_save=True)
+        page_2 = cont_api_a.create(
+            ContentType.Page,
+            workspace,
+            None,
+            'this is page1',
+            do_save=True
+        )
+        page_3 = cont_api_a.create(
+            ContentType.Thread,
+            workspace,
+            None,
+            'this is page2',
+            do_save=True
+        )
+        page_4 = cont_api_a.create(
+            ContentType.File,
+            workspace,
+            None,
+            'this is page3',
+            do_save=True
+        )
 
         for rev in page_2.revisions:
             eq_(user_b not in rev.read_by.keys(), True)
         for rev in page_4.revisions:
             eq_(user_b in rev.read_by.keys(), True)
 
-
-
-
-
     def test_update(self):
         uapi = UserApi(
             session=self.session,
             config=CFG(self.config.get_settings()),
             current_user=None,
         )
-        group_api = GroupApi(current_user=None,session=self.session)
+        group_api = GroupApi(current_user=None, session=self.session)
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user1 = uapi.create_user(email='this.is@user',
-                                groups=groups, save_now=True)
+        user1 = uapi.create_user(
+            email='this.is@user',
+            groups=groups,
+            save_now=True
+        )
 
         workspace_api = WorkspaceApi(current_user=user1, session=self.session)
         workspace = workspace_api.create_workspace(
         user2.email = 'this.is@another.user'
         uapi.save(user2)
 
-        RoleApi(current_user=user1,session=self.session).create_one(user2, workspace,
-                                  UserRoleInWorkspace.CONTENT_MANAGER,
-                                  with_notif=False,
-                                  flush=True)
+        RoleApi(
+            current_user=user1,
+            session=self.session
+        ).create_one(
+            user2,
+            workspace,
+            UserRoleInWorkspace.CONTENT_MANAGER,
+            with_notif=False,
+            flush=True
+        )
 
         # Test starts here
 
            tm=transaction.manager,
            content=content2,
         ):
-            api2.update_content(content2, 'this is an updated page', 'new content')
+            api2.update_content(
+                content2,
+                'this is an updated page',
+                'new content'
+            )
         api2.save(content2)
         transaction.commit()
 
             config=CFG(self.config.get_settings()),
             current_user=None,
         )
-        group_api = GroupApi(current_user=None,session=self.session)
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session
+        )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
             save_now=True,
         )
 
-        workspace = WorkspaceApi(user1).create_workspace(
+        workspace = WorkspaceApi(
+            current_user=user1,
+            session=self.session,
+        ).create_workspace(
             'test workspace',
             save_now=True
         )
         user2.email = 'this.is@another.user'
         uapi.save(user2)
 
-        RoleApi(current_user=user1,session=self.session).create_one(
+        RoleApi(
+            current_user=user1,
+            session=self.session
+        ).create_one(
             user2,
             workspace,
             UserRoleInWorkspace.CONTENT_MANAGER,
         api.save(page, ActionDescription.CREATION, do_notify=True)
         transaction.commit()
 
-        api2 = ContentApi(user2)
+        api2 = ContentApi(
+            current_user=user2,
+            session=self.session,
+        )
         content2 = api2.get_one(page.content_id, ContentType.Any, workspace)
         with new_revision(
            session=self.session,
             config=CFG(self.config.get_settings()),
             current_user=None,
         )
-        group_api = GroupApi(current_user=None,session=self.session)
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session
+        )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user1 = uapi.create_user(email='this.is@user',
-                                groups=groups, save_now=True)
+        user1 = uapi.create_user(
+            email='this.is@user',
+            groups=groups,
+            save_now=True
+        )
 
         workspace_api = WorkspaceApi(current_user=user1, session=self.session)
         workspace = workspace_api.create_workspace(
         user2.email = 'this.is@another.user'
         uapi.save(user2)
 
-        RoleApi(current_user=user1,session=self.session).create_one(user2, workspace,
-                                  UserRoleInWorkspace.CONTENT_MANAGER,
-                                  with_notif=True,
-                                  flush=True)
+        RoleApi(
+            current_user=user1,
+            session=self.session,
+        ).create_one(
+            user2,
+            workspace,
+            UserRoleInWorkspace.CONTENT_MANAGER,
+            with_notif=True,
+            flush=True
+        )
 
         # Test starts here
         api = ContentApi(
             config=CFG(self.config.get_settings()),
             current_user=None,
         )
-        group_api = GroupApi(current_user=None,session=self.session)
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session,
+        )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
         user2.email = 'this.is@another.user'
         uapi.save(user2)
 
-        RoleApi(current_user=user1,session=self.session).create_one(
+        RoleApi(
+            current_user=user1,
+            session=self.session,
+        ).create_one(
             user2,
             workspace,
             UserRoleInWorkspace.CONTENT_MANAGER,
         api2.save(content2)
         transaction.commit()
 
-
     def test_archive_unarchive(self):
         uapi = UserApi(
             session=self.session,
             config=CFG(self.config.get_settings()),
             current_user=None,
         )
-        group_api = GroupApi(current_user=None,session=self.session)
+        group_api = GroupApi(current_user=None, session=self.session)
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user1 = uapi.create_user(email='this.is@user',
-                                groups=groups, save_now=True)
+        user1 = uapi.create_user(
+            email='this.is@user',
+            groups=groups,
+            save_now=True
+        )
         u1id = user1.user_id
 
         workspace_api = WorkspaceApi(current_user=user1, session=self.session)
         user2.email = 'this.is@another.user'
         uapi.save(user2)
 
-        RoleApi(current_user=user1,session=self.session).create_one(user2, workspace,
-                                  UserRoleInWorkspace.CONTENT_MANAGER,
-                                  with_notif=True,
-                                  flush=True)
+        RoleApi(
+            current_user=user1,
+            session=self.session
+        ).create_one(
+            user2,
+            workspace,
+            UserRoleInWorkspace.CONTENT_MANAGER,
+            with_notif=True,
+            flush=True
+        )
 
         # show archived is used at the top end of the test
         api = ContentApi(
         user1 = UserApi(
             current_user=None,
             session=self.session,
-            config= self.config
+            config=self.config,
         ).get_one(u1id)
         workspace = WorkspaceApi(
             current_user=user1,
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user1 = uapi.create_user(email='this.is@user',
-                                groups=groups, save_now=True)
+        user1 = uapi.create_user(
+            email='this.is@user',
+            groups=groups,
+            save_now=True
+        )
         u1id = user1.user_id
 
         workspace_api = WorkspaceApi(current_user=user1, session=self.session)
             config=CFG(self.config.get_settings()),
             current_user=None,
         )
-        group_api = GroupApi(current_user=None,session=self.session)
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session,
+        )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
         user = uapi.create_user(email='this.is@user',
                                 groups=groups, save_now=True)
 
-        workspace = WorkspaceApi(current_user=user, session=self.session).create_workspace('test workspace',
-                                                        save_now=True)
+        workspace = WorkspaceApi(
+            current_user=user,
+            session=self.session
+        ).create_workspace(
+            'test workspace',
+            save_now=True
+        )
 
         api = ContentApi(
             current_user=user, 
             config=CFG(self.config.get_settings()),
             current_user=None,
         )
-        group_api = GroupApi(current_user=None,session=self.session)
+        group_api = GroupApi(
+            current_user=None,
+            session=self.session,
+        )
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
         user = uapi.create_user(email='this.is@user',
                                 groups=groups, save_now=True)
 
-        workspace = WorkspaceApi(current_user=user, session=self.session).create_workspace('test workspace',
-                                                        save_now=True)
+        workspace = WorkspaceApi(
+            current_user=user,
+            session=self.session
+        ).create_workspace(
+            'test workspace',
+            save_now=True,
+        )
 
         api = ContentApi(
             current_user=user, 
             config=CFG(self.config.get_settings()),
             current_user=None,
         )
-        group_api = GroupApi(current_user=None,session=self.session)
+        group_api = GroupApi(current_user=None, session=self.session)
         groups = [group_api.get_one(Group.TIM_USER),
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
         user = uapi.create_user(email='this.is@user',
                                 groups=groups, save_now=True)
 
-        workspace = WorkspaceApi(current_user=user, session=self.session).create_workspace('test workspace',
-                                                        save_now=True)
-
-
-        api = ContentApi(
-            current_user=user, 
+        workspace = WorkspaceApi(
+            current_user=user,
             session=self.session
-        )
+        ).create_workspace('test workspace', save_now=True)
+
         api = ContentApi(
             current_user=user, 
             session=self.session
             tm=transaction.manager,
             content=p1,
         ):
-           p1.description = 'This is some amazing test'
+            p1.description = 'This is some amazing test'
 
         with new_revision(
             session=self.session,
         eq_(True, id1 in [o.content_id for o in res.all()])
         eq_(True, id2 in [o.content_id for o in res.all()])
 
-    def test_unit__search_exclude_content_under_deleted_or_archived_parents__ok(self):
-        admin = self.session.query(User).filter(User.email == 'admin@admin.admin').one()
-        workspace = self._create_workspace_and_test('workspace_1', admin)
-        folder_1 = self._create_content_and_test('folder_1', workspace=workspace, type=ContentType.Folder)
-        folder_2 = self._create_content_and_test('folder_2', workspace=workspace, type=ContentType.Folder)
-        page_1 = self._create_content_and_test('foo', workspace=workspace, type=ContentType.Page, parent=folder_1)
-        page_2 = self._create_content_and_test('bar', workspace=workspace, type=ContentType.Page, parent=folder_2)
+    def test_unit__search_exclude_content_under_deleted_or_archived_parents__ok(self):  # nopep8
+        admin = self.session.query(User)\
+            .filter(User.email == 'admin@admin.admin').one()
+        workspace = self._create_workspace_and_test(
+            'workspace_1',
+            admin
+        )
+        folder_1 = self._create_content_and_test(
+            'folder_1',
+            workspace=workspace,
+            type=ContentType.Folder
+        )
+        folder_2 = self._create_content_and_test(
+            'folder_2',
+            workspace=workspace,
+            type=ContentType.Folder
+        )
+        page_1 = self._create_content_and_test(
+            'foo', workspace=workspace,
+            type=ContentType.Page,
+            parent=folder_1
+        )
+        page_2 = self._create_content_and_test(
+            'bar',
+            workspace=workspace,
+            type=ContentType.Page,
+            parent=folder_2
+        )
 
         api = ContentApi(
             current_user=admin,
             save_now=True,
         )
 
-        bob_page = ContentApi(current_user=bob,session=self.session).create(
+        bob_page = ContentApi(
+            current_user=bob,
+            session=self.session
+        ).create(
             content_type=ContentType.Page,
             workspace=bob_workspace,
             label='bob_page',
             do_save=True,
         )
 
-        admin_page = ContentApi(current_user=admin,session=self.session).create(
+        admin_page = ContentApi(
+            current_user=admin,
+            session=self.session
+        ).create(
             content_type=ContentType.Page,
             workspace=admin_workspace,
             label='admin_page',
             do_save=True,
         )
 
-        bob_viewable = ContentApi(current_user=bob,session=self.session).get_all()
+        bob_viewable = ContentApi(
+            current_user=bob,
+            session=self.session
+        ).get_all()
         eq_(1, len(bob_viewable), 'Bob should view only one content')
         eq_(
             'bob_page',

tracim/tests/models/test_content_revision.py

 # -*- coding: utf-8 -*-
 from collections import OrderedDict
 
-from nose.tools import eq_
 from sqlalchemy import inspect
 
 from tracim.models import ContentRevisionRO
             'node',
             'revision_read_statuses',
         )
-        revision_columns = [attr.key for attr in inspect(revision).attrs if not attr.key in excluded_columns]
+        revision_columns = [attr.key for attr in inspect(revision).attrs
+                            if attr.key not in excluded_columns]
         new_revision = ContentRevisionRO()
 
         for revision_column in revision_columns: