better typing + pep8

tracim/lib/utils/authorization.py

 # We prefer to use decorators
 
 
-def require_same_user_or_profile(group: int):
+def require_same_user_or_profile(group: int) -> typing.Callable:
     """
     Decorator for view to restrict access of tracim request if candidate user
     is distinct from authenticated user and not with high enough profile.
     like Group.TIM_USER or Group.TIM_MANAGER
     :return:
     """
-    def decorator(func):
+    def decorator(func: typing.Callable) -> typing.Callable:
         @functools.wraps(func)
-        def wrapper(self, context, request: 'TracimRequest'):
+        def wrapper(self, context, request: 'TracimRequest') -> typing.Callable:
             auth_user = request.current_user
             candidate_user = request.candidate_user
             if auth_user.user_id == candidate_user.user_id or \
     return decorator
 
 
-def require_profile(group: int):
+def require_profile(group: int) -> typing.Callable:
     """
     Decorator for view to restrict access of tracim request if profile is
     not high enough
     like Group.TIM_USER or Group.TIM_MANAGER
     :return:
     """
-    def decorator(func):
+    def decorator(func: typing.Callable) -> typing.Callable:
         @functools.wraps(func)
-        def wrapper(self, context, request: 'TracimRequest'):
+        def wrapper(self, context, request: 'TracimRequest') -> typing.Callable:
             user = request.current_user
             if user.profile.id >= group:
                 return func(self, context, request)
     return decorator
 
 
-def require_workspace_role(minimal_required_role: int):
+def require_workspace_role(minimal_required_role: int) -> typing.Callable:
     """
     Restricts access to endpoint to minimal role or raise an exception.
     Check role for current_workspace.
     UserRoleInWorkspace.CONTRIBUTOR or UserRoleInWorkspace.READER
     :return: decorator
     """
-    def decorator(func):
+    def decorator(func: typing.Callable) -> typing.Callable:
         @functools.wraps(func)
-        def wrapper(self, context, request: 'TracimRequest'):
+        def wrapper(self, context, request: 'TracimRequest') -> typing.Callable:
             user = request.current_user
             workspace = request.current_workspace
             if workspace.get_user_role(user) >= minimal_required_role:
     return decorator
 
 
-def require_candidate_workspace_role(minimal_required_role: int):
+def require_candidate_workspace_role(minimal_required_role: int) -> typing.Callable:  # nopep8
     """
     Restricts access to endpoint to minimal role or raise an exception.
     Check role for candidate_workspace.
     UserRoleInWorkspace.CONTRIBUTOR or UserRoleInWorkspace.READER
     :return: decorator
     """
-    def decorator(func):
+    def decorator(func: typing.Callable) -> typing.Callable:
 
-        def wrapper(self, context, request: 'TracimRequest'):
+        def wrapper(self, context, request: 'TracimRequest') -> typing.Callable:
             user = request.current_user
             workspace = request.candidate_workspace
 
     return decorator
 
 
-def require_content_types(content_types: typing.List['NewContentType']):
+def require_content_types(content_types: typing.List['NewContentType']) -> typing.Callable:  # nopep8
     """
     Restricts access to specific file type or raise an exception.
     Check role for candidate_workspace.
     :param content_types: list of NewContentType object
     :return: decorator
     """
-    def decorator(func):
+    def decorator(func: typing.Callable) -> typing.Callable:
         @functools.wraps(func)
-        def wrapper(self, context, request: 'TracimRequest'):
+        def wrapper(self, context, request: 'TracimRequest') -> typing.Callable:
             content = request.current_content
             current_content_type_slug = ContentType(content.type).slug
-            content_types_slug = [content_type.slug for content_type in content_types]
+            content_types_slug = [content_type.slug for content_type in content_types]  # nopep8
             if current_content_type_slug in content_types_slug:
                 return func(self, context, request)
             raise ContentTypeNotAllowed()
 def require_comment_ownership_or_role(
         minimal_required_role_for_owner: int,
         minimal_required_role_for_anyone: int,
-) -> None:
+) -> typing.Callable:
     """
     Decorator for view to restrict access of tracim request if role is
     not high enough and user is not owner of the current_content
-    :param minimal_required_role_for_owner_access: minimal role for owner
+    :param minimal_required_role_for_owner: minimal role for owner
     of current_content to access to this view
     :param minimal_required_role_for_anyone: minimal role for anyone to
     access to this view.
     :return:
     """
-    def decorator(func):
+    def decorator(func: typing.Callable) -> typing.Callable:
         @functools.wraps(func)
-        def wrapper(self, context, request: 'TracimRequest'):
+        def wrapper(self, context, request: 'TracimRequest') -> typing.Callable:
             user = request.current_user
             workspace = request.current_workspace
             comment = request.current_comment
                 return func(self, context, request)
             raise InsufficientUserWorkspaceRole()
         return wrapper
-    return decorator
+    return decorator

tracim/lib/utils/request.py

         :return: Workspace of the request
         """
         if self._current_workspace is None:
-            self._current_workspace = self._get_current_workspace(self.current_user, self)
+            self._current_workspace = self._get_current_workspace(self.current_user, self)   # nopep8
         return self._current_workspace
 
     @current_workspace.setter
         self._current_user = user
 
     @property
-    def current_content(self) -> User:
+    def current_content(self) -> Content:
         """
         Get current  content from path
         """
         self._current_content = content
 
     @property
-    def current_comment(self) -> User:
+    def current_comment(self) -> Content:
         """
         Get current comment from path
         """
             )
         self._current_comment = content
     # TODO - G.M - 24-05-2018 - Find a better naming for this ?
+
     @property
     def candidate_user(self) -> User:
         """
             workspace: Workspace,
             content: Content,
             request: 'TracimRequest'
-    ):
+    ) -> Content:
         """
         Get current content from request
         :param user: User who want to check the workspace
             user: User,
             workspace: Workspace,
             request: 'TracimRequest'
-    ):
+    ) -> Content:
         """
         Get current content from request
         :param user: User who want to check the workspace
             if 'workspace_id' in request.matchdict:
                 workspace_id = request.matchdict['workspace_id']
             if not workspace_id:
-                raise WorkspaceNotFoundInTracimRequest('No workspace_id property found in request')
+                raise WorkspaceNotFoundInTracimRequest('No workspace_id property found in request')  # nopep8
             wapi = WorkspaceApi(
                 current_user=user,
                 session=request.dbsession,
             if 'new_workspace_id' in request.json_body:
                 workspace_id = request.json_body['new_workspace_id']
             if not workspace_id:
-                raise WorkspaceNotFoundInTracimRequest('No new_workspace_id property found in body')
+                raise WorkspaceNotFoundInTracimRequest('No new_workspace_id property found in body')  # nopep8
             wapi = WorkspaceApi(
                 current_user=user,
                 session=request.dbsession,