typing for commands

tracim/command/__init__.py

 from cliff.commandmanager import CommandManager
 
 from pyramid.paster import bootstrap
+from pyramid.scripting import AppEnvironment
 from tracim.exceptions import CommandAbortedError
 
 
-
 class TracimCLI(App):
-
-    def __init__(self):
+    def __init__(self) -> None:
         super(TracimCLI, self).__init__(
             description='TracimCli',
             version='0.1',
             deferred_help=True,
             )
 
-    def initialize_app(self, argv):
+    def initialize_app(self, argv) -> None:
         self.LOG.debug('initialize_app')
 
-    def prepare_to_run_command(self, cmd):
+    def prepare_to_run_command(self, cmd) -> None:
         self.LOG.debug('prepare_to_run_command %s', cmd.__class__.__name__)
 
-    def clean_up(self, cmd, result, err):
+    def clean_up(self, cmd, result, err) -> None:
         self.LOG.debug('clean_up %s', cmd.__class__.__name__)
         if err:
             self.LOG.debug('got an error: %s', err)
     """
     auto_setup_context = True
 
-    def take_action(self, parsed_args):
+    def take_action(self, parsed_args: argparse.Namespace) -> None:
         super(AppContextCommand, self).take_action(parsed_args)
         if self.auto_setup_context:
             with bootstrap(parsed_args.config_file) as app_context:
                 with app_context['request'].tm:
                     self.take_app_action(parsed_args, app_context)
 
-    def get_parser(self, prog_name):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
         parser = super(AppContextCommand, self).get_parser(prog_name)
 
         parser.add_argument(
     #     transaction.commit()
 
 
+# TODO - G.M - 10-04-2018 - [Cleanup][tempExample] - Drop this
 class TestTracimCommand(AppContextCommand):
 
-    def take_app_action(self, parser, app_context):
+    def take_app_action(
+            self,
+            parser: argparse.ArgumentParser,
+            app_context: AppEnvironment
+    ) -> None:
         print('test')
 
 

tracim/command/initializedb.py

 # -*- coding: utf-8 -*-
+import argparse
+
+import plaster_pastedeploy
 import transaction
 from pyramid.paster import (
     get_appsettings,
 class InitializeDBCommand(AppContextCommand):
     auto_setup_context = False
 
-    def get_description(self):
+    def get_description(self) -> str:
         return "Initialize DB"
 
-    def get_parser(self, prog_name):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
         parser = super().get_parser(prog_name)
         return parser
 
-    def take_action(self, parsed_args):
+    def take_action(self, parsed_args: argparse.Namespace) -> None:
         super(InitializeDBCommand, self).take_action(parsed_args)
         config_uri = parsed_args.config_file
         setup_logging(config_uri)
         self._populate_database(settings)
 
     @classmethod
-    def _create_schema(cls, settings):
+    def _create_schema(
+            cls,
+            settings: plaster_pastedeploy.ConfigDict
+    ) -> None:
         print("- Create Schemas of databases -")
         engine = get_engine(settings)
         DeclarativeBase.metadata.create_all(engine)
 
     @classmethod
-    def _populate_database(cls, settings):
+    def _populate_database(
+            cls,
+            settings: plaster_pastedeploy.ConfigDict
+    ) -> None:
         engine = get_engine(settings)
         session_factory = get_session_factory(engine)
         app_config = CFG(settings)

tracim/command/user.py

 # -*- coding: utf-8 -*-
+import argparse
+from pyramid.scripting import AppEnvironment
 import transaction
 from sqlalchemy.exc import IntegrityError
 
 from tracim.lib.core.group import GroupApi
 from tracim.lib.core.user import UserApi
 from tracim.models import User
+from tracim.models import Group
 
 
 class UserCommand(AppContextCommand):
 
     action = NotImplemented
 
-    def get_description(self):
+    def get_description(self) -> str:
         return '''Create or update user.'''
 
-    def get_parser(self, prog_name):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
         parser = super().get_parser(prog_name)
 
         parser.add_argument(
 
         return parser
 
-    def _user_exist(self, login):
+    def _user_exist(self, login: str) -> User:
         return self._user_api.user_with_email_exists(login)
 
-    def _get_group(self, name):
+    def _get_group(self, name: str) -> Group:
         return self._group_api.get_one_with_name(name)
 
-    def _add_user_to_named_group(self, user, group_name):
+    def _add_user_to_named_group(
+            self,
+            user: str,
+            group_name: str
+    ) -> None:
         group = self._get_group(group_name)
         if user not in group.users:
             group.users.append(user)
         self._session.flush()
 
-    def _remove_user_from_named_group(self, user, group_name):
+    def _remove_user_from_named_group(
+            self,
+            user: User,
+            group_name: str
+    ) -> None:
         group = self._get_group(group_name)
         if user in group.users:
             group.users.remove(user)
         self._session.flush()
 
-    def _create_user(self, login, password, **kwargs):
+    def _create_user(self, login: str, password: str, **kwargs) -> User:
         if not password:
             if self._password_required():
-                raise CommandAbortedError("You must provide -p/--password parameter")
+                raise CommandAbortedError(
+                    "You must provide -p/--password parameter"
+                )
             password = ''
 
         try:
-            user =self._user_api.create_user(email=login)
+            user = self._user_api.create_user(email=login)
             user.password = password
             self._user_api.save(user)
             # TODO - G.M - 04-04-2018 - [Caldav] Check this code
 
         return user
 
-    def _update_password_for_login(self, login, password):
+    def _update_password_for_login(self, login: str, password: str) -> None:
         user = self._user_api.get_one_by_email(login)
         user.password = password
         self._session.flush()
         transaction.commit()
 
-    def take_app_action(self, parsed_args, app_context):
+    def take_app_action(
+            self,
+            parsed_args: argparse.Namespace,
+            app_context: AppEnvironment
+    ) -> None:
         # TODO - G.M - 05-04-2018 -Refactor this in order
         # to not setup object var outside of __init__ .
         self._session = app_context['request'].dbsession
 
         print("User created/updated")
 
-    def _proceed_user(self, parsed_args):
+    def _proceed_user(self, parsed_args: argparse.Namespace) -> User:
         self._check_context(parsed_args)
 
         if self.action == self.ACTION_CREATE:
 
         return user
 
-    def _proceed_groups(self, user, parsed_args):
+    def _proceed_groups(
+            self,
+            user: User,
+            parsed_args: argparse.Namespace
+    ) -> None:
         # User always in "users" group
         self._add_user_to_named_group(user, 'users')
 
         for group_name in parsed_args.remove_from_group:
             self._remove_user_from_named_group(user, group_name)
 
-    def _password_required(self):
+    def _password_required(self) -> bool:
         # TODO - G.M - 04-04-2018 - [LDAP] Check this code
         # if config.get('auth_type') == LDAPAuth.name:
         #     return False
         return True
 
-    def _check_context(self, parsed_args):
+    def _check_context(self, parsed_args: argparse.Namespace) -> None:
         # TODO - G.M - 04-04-2018 - [LDAP] Check this code
         # if config.get('auth_type') == LDAPAuth.name:
         #     auth_instance = config.get('auth_instance')