Feature/autocomplete (#75)

Author: Juliya Smith

CONTRIBUTING.md

@@ -81,18 +81,18 @@ def test_add_one_and_one_equals_two():
 See class documentation on the [Command](src/code42cli/commands.py) class for an explanation of its constructor parameters.
 
 1. If you are creating a new top-level command, create a new instance of `Command` and add it to the list returned
-    by `_load_top_commands()` function in `code42cli.main`.
+    by `load_commands()` function in `code42cli.main.MainSubcommandLoader`.
 
 2. If you are creating a new subcommand, find the top-level command that this will be a subcommand of in
-    `_load_top_commands()` in `code42cli.main` and navigate to the function assigned to be its subcommand loader.
-     Then, add a new instance of `Command` to the list returned by that function.
+    `load_commands()` in `code42cli.main.MainSubcommandLoader` and navigate to its subcommand loader's `load_commands()` 
+    Then, add a new instance of `Command` to the list returned.
 
 3. For commands that actually are executed (rather than just being groups), you will add a `handler` function as a constructor parameter.
    This will be the function that you want to execute when your command is run.
    * _Positional_ arguments of the handler will automatically become _required_ cli arguments.
      * The order that the positional arguments should be entered in on the cli is the same as the order in which they appear in the handler.
    * _Keyword_ arguments of the handler will automatically become _optional_ cli arguments
-   * the cli argument name will be the same as the handler param name except with `_` replaced with `-`, and prefixed with `--` if optional
+   * the cli argument name will be the same as the handler param name except with `_` replaced with `-`, and prefixed with `--` if optional.
 
     For example, consider the following python function:
 

README.md

@@ -203,3 +203,19 @@ reported.
 
 If you keep getting prompted for your password, try resetting with `code42 profile reset-pw`.
 If that doesn't work, delete your credentials file located at ~/.code42cli or the entry in keychain.
+
+## Tab completion
+
+For `zsh`, add these commands to your `.zshrc` file:
+
+```bash
+C42_COMPLETER=$(which code42cli_completer)
+autoload bashcompinit && bashcompinit
+complete -C '$C42_COMPLETER' code42
+```
+
+For bash, add just the first and last commands to your `.bash_profile`:
+```bash
+C42_COMPLETER=$(which code42cli_completer)
+complete -C '$C42_COMPLETER' code42
+```

bin/code42cli_completer

@@ -0,0 +1,17 @@
+# file inspired from awscli https://github.com/aws/aws-cli/blob/develop/bin/aws_completer
+
+import os
+if os.environ.get('LC_CTYPE', '') == 'UTF-8':
+    os.environ['LC_CTYPE'] = 'en_US.UTF-8'
+import code42cli.completer
+
+if __name__ == '__main__':
+    # bash exports COMP_LINE and COMP_POINT, tcsh COMMAND_LINE only
+    cline = os.environ.get('COMP_LINE') or os.environ.get('COMMAND_LINE') or ''
+    cpoint = int(os.environ.get('COMP_POINT') or len(cline))
+    try:
+        code42cli.completer.complete(cline, cpoint)
+    except KeyboardInterrupt:
+        # If the user hits Ctrl+C, we don't want to print
+        # a trace
+        pass

setup.py

@@ -52,5 +52,6 @@
         "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: Implementation :: CPython",
     ],
+    scripts=["bin/code42cli_completer"],
     entry_points={"console_scripts": ["code42=code42cli.main:main"]},
 )

src/code42cli/__init__.py

@@ -1 +1,2 @@
 PRODUCT_NAME = u"code42cli"
+MAIN_COMMAND = u"code42"

src/code42cli/bulk.py

@@ -1,4 +1,4 @@
-import os, inspect, sys
+import os, inspect
 
 from code42cli.compat import open, str
 from code42cli.worker import Worker
@@ -93,8 +93,6 @@ def run(self):
                 self._process_row(row)
             self.__worker.wait()
         self._print_results()
-        sys.stdout.flush()
-
 
     def _process_row(self, row):
         if isinstance(row, dict):

src/code42cli/cmds/alerts/main.py

@@ -1,5 +1,5 @@
 from code42cli.args import ArgConfig
-from code42cli.commands import Command
+from code42cli.commands import Command, SubcommandLoader
 from code42cli.cmds.alerts.extraction import extract
 from code42cli.cmds.search_shared import args, logger_factory
 from code42cli.cmds.search_shared.enums import (
@@ -12,45 +12,51 @@
 from code42cli.cmds.search_shared.cursor_store import AlertCursorStore
 
 
-def load_subcommands():
-    """Sets up the `alerts` subcommand with all of its subcommands."""
-    usage_prefix = u"code42 alerts"
-
-    print_func = Command(
-        u"print",
-        u"Print alerts to stdout",
-        u"{} {}".format(usage_prefix, u"print <optional-args>"),
-        handler=print_out,
-        arg_customizer=_load_search_args,
-        use_single_arg_obj=True,
-    )
-
-    write = Command(
-        u"write-to",
-        u"Write alerts to the file with the given name.",
-        u"{} {}".format(usage_prefix, u"write-to <filename> <optional-args>"),
-        handler=write_to,
-        arg_customizer=_load_write_to_args,
-        use_single_arg_obj=True,
-    )
-
-    send = Command(
-        u"send-to",
-        u"Send alerts to the given server address.",
-        u"{} {}".format(usage_prefix, u"send-to <server-address> <optional-args>"),
-        handler=send_to,
-        arg_customizer=_load_send_to_args,
-        use_single_arg_obj=True,
-    )
-
-    clear = Command(
-        u"clear-checkpoint",
-        u"Remove the saved alert checkpoint from 'incremental' (-i) mode.",
-        u"{} {}".format(usage_prefix, u"clear-checkpoint <optional-args>"),
-        handler=clear_checkpoint,
-    )
-
-    return [print_func, write, send, clear]
+class MainAlertsSubcommandLoader(SubcommandLoader):
+    PRINT = u"print"
+    WRITE_TO = u"write-to"
+    SEND_TO = u"send-to"
+    CLEAR_CHECKPOINT = u"clear-checkpoint"
+
+    def load_commands(self):
+        """Sets up the `alerts` subcommand with all of its subcommands."""
+        usage_prefix = u"code42 alerts"
+
+        print_func = Command(
+            self.PRINT,
+            u"Print alerts to stdout",
+            u"{} {}".format(usage_prefix, u"print <optional-args>"),
+            handler=print_out,
+            arg_customizer=_load_search_args,
+            use_single_arg_obj=True,
+        )
+
+        write = Command(
+            self.WRITE_TO,
+            u"Write alerts to the file with the given name.",
+            u"{} {}".format(usage_prefix, u"write-to <filename> <optional-args>"),
+            handler=write_to,
+            arg_customizer=_load_write_to_args,
+            use_single_arg_obj=True,
+        )
+
+        send = Command(
+            self.SEND_TO,
+            u"Send alerts to the given server address.",
+            u"{} {}".format(usage_prefix, u"send-to <server-address> <optional-args>"),
+            handler=send_to,
+            arg_customizer=_load_send_to_args,
+            use_single_arg_obj=True,
+        )
+
+        clear = Command(
+            self.CLEAR_CHECKPOINT,
+            u"Remove the saved alert checkpoint from 'incremental' (-i) mode.",
+            u"{} {}".format(usage_prefix, u"clear-checkpoint <optional-args>"),
+            handler=clear_checkpoint,
+        )
+
+        return [print_func, write, send, clear]
 
 
 def clear_checkpoint(sdk, profile):

src/code42cli/cmds/alerts/rules/commands.py

@@ -1,4 +1,5 @@
-from code42cli.commands import Command
+from code42cli import MAIN_COMMAND
+from code42cli.commands import Command, SubcommandLoader
 from code42cli.bulk import generate_template, BulkCommandType
 from code42cli.cmds.alerts.rules.user_rule import (
     add_user,
@@ -61,21 +62,24 @@ def _load_bulk_generate_template_description(argument_collection):
     cmd_type.set_choices(BulkCommandType())
 
 
-class AlertRulesBulkCommands(object):
-    @staticmethod
-    def load_commands():
-        usage_prefix = u"code42 alert-rules bulk"
+class AlertRulesBulkSubcommandLoader(SubcommandLoader):
+    GENERATE_TEMPLATE = u"generate-template"
+    ADD = u"add"
+    REMOVE = u"remove"
+
+    def load_commands(self):
+        usage_prefix = u"{} alert-rules bulk".format(MAIN_COMMAND)
 
         generate_template_cmd = Command(
-            u"generate-template",
+            self.GENERATE_TEMPLATE,
             u"Generate the necessary csv template needed for bulk adding users.",
             u"{} generate-template <cmd> <optional args>".format(usage_prefix),
             handler=_generate_template_file,
             arg_customizer=_load_bulk_generate_template_description,
         )
 
         bulk_add = Command(
-            u"add",
+            self.ADD,
             u"Update alert rule criteria to add users and all their aliases. "
             u"CSV file format: rule_id,username",
             u"{} add <filename>".format(usage_prefix),
@@ -84,7 +88,7 @@ def load_commands():
         )
 
         bulk_remove = Command(
-            u"remove",
+            self.REMOVE,
             u"Update alert rule criteria to remove users and all their aliases. "
             u"CSV file format: rule_id,username",
             u"{} remove <filename>".format(usage_prefix),
@@ -95,46 +99,55 @@ def load_commands():
         return [generate_template_cmd, bulk_add, bulk_remove]
 
 
-class AlertRulesCommands(object):
-    @staticmethod
-    def load_subcommands():
+class AlertRulesSubcommandLoader(SubcommandLoader):
+    ADD_USER = u"add-user"
+    REMOVE_USER = u"remove-user"
+    LIST = u"list"
+    SHOW = u"show"
+    BULK = u"bulk"
+
+    def __init__(self, root_command_name):
+        super(AlertRulesSubcommandLoader, self).__init__(root_command_name)
+        self._bulk_subcommand_loader = AlertRulesBulkSubcommandLoader(self.BULK)
+
+    def load_commands(self):
         usage_prefix = u"code42 alert-rules"
 
         add = Command(
-            u"add-user",
+            self.ADD_USER,
             u"Update alert rule criteria to monitor user aliases against the given username.",
             u"{} add-user --rule-id <id>  --username <username>".format(usage_prefix),
             handler=add_user,
             arg_customizer=_customize_add_arguments,
         )
 
         remove = Command(
-            u"remove-user",
+            self.REMOVE_USER,
             u"Update alert rule criteria to remove a user and all their aliases.",
             u"{} remove-user --rule-id <rule-id> --username <username>".format(usage_prefix),
             handler=remove_user,
             arg_customizer=_customize_remove_arguments,
         )
 
         list_rules = Command(
-            u"list",
+            self.LIST,
             u"Fetch existing alert rules.",
             u"{} list".format(usage_prefix),
             handler=get_rules,
         )
 
         show = Command(
-            u"show",
+            self.SHOW,
             u"Fetch configured alert-rules against the rule ID.",
             u"{} show <rule-id>".format(usage_prefix),
             handler=show_rule,
             arg_customizer=_customize_list_arguments,
         )
 
         bulk = Command(
-            u"bulk",
+            self.BULK,
             u"Tools for executing bulk commands.",
-            subcommand_loader=AlertRulesBulkCommands.load_commands,
+            subcommand_loader=self._bulk_subcommand_loader,
         )
 
         return [add, remove, list_rules, show, bulk]

src/code42cli/cmds/detectionlists/__init__.py

@@ -1,10 +1,10 @@
 from py42.exceptions import Py42BadRequestError
 
+from code42cli.cmds.detectionlists.commands import DetectionListSubcommandLoader
 from code42cli.bulk import generate_template, run_bulk_process
 from code42cli.file_readers import create_csv_reader, create_flat_file_reader
 from code42cli.errors import UserAlreadyAddedError, UserDoesNotExistError, UnknownRiskTagError
 from code42cli.cmds.detectionlists.enums import DetectionLists, DetectionListUserKeys, RiskTags
-from code42cli.cmds.detectionlists.commands import DetectionListCommandFactory
 from code42cli.cmds.detectionlists.bulk import BulkDetectionList, BulkHighRiskEmployee
 
 
@@ -46,13 +46,15 @@ class DetectionList(object):
             given `classmethods`.
         handlers (DetectionListHandlers): A DTO containing implementations for adding / removing 
             users from specific lists.
-        cmd_factory (DetectionListCommandFactory): A factory that creates detection list commands.
+        cmd_factory (DetectionListSubcommandLoader): A factory that creates detection list commands.
     """
 
-    def __init__(self, list_name, handlers, cmd_factory=None):
+    def __init__(self, list_name, handlers, subcommand_loader=None):
         self.name = list_name
         self.handlers = handlers
-        self.factory = cmd_factory or DetectionListCommandFactory(list_name)
+        self.subcommand_loader = subcommand_loader or DetectionListSubcommandLoader(list_name)
+        self.bulk_subcommand_loader = self.subcommand_loader.bulk_subcommand_loader
+        self.bulk_subcommand_loader.load_commands = lambda: self._load_bulk_subcommands
 
     @classmethod
     def create_high_risk_employee_list(cls, handlers):
@@ -82,39 +84,41 @@ def create_departing_employee_list(cls, handlers):
 
     def load_subcommands(self):
         """Loads high risk employee related subcommands"""
-        bulk = self.factory.create_bulk_command(lambda: self._load_bulk_subcommands())
-        add = self.factory.create_add_command(
+        bulk = self.subcommand_loader.create_bulk_command()
+        bulk.subcommand_loader.load_commands = lambda: self._load_bulk_subcommands()
+        add = self.subcommand_loader.create_add_command(
             self.handlers.add_employee, self.handlers.load_add_description
         )
-        remove = self.factory.create_remove_command(
+        remove = self.subcommand_loader.create_remove_command(
             self.handlers.remove_employee, load_username_description
         )
         return [bulk, add, remove]
 
     def _load_bulk_subcommands(self):
-
-        add = self.factory.create_bulk_add_command(self.bulk_add_employees)
-        remove = self.factory.create_bulk_remove_command(self.bulk_remove_employees)
+        add = self.bulk_subcommand_loader.create_bulk_add_command(self.bulk_add_employees)
+        remove = self.bulk_subcommand_loader.create_bulk_remove_command(self.bulk_remove_employees)
         commands = [add, remove]
 
         if self.name == DetectionLists.HIGH_RISK_EMPLOYEE:
             commands.extend(self._get_risk_tags_bulk_subcommands())
         else:
-            generate_template_cmd = self.factory.create_bulk_generate_template_command(
+            generate_template_cmd = self.bulk_subcommand_loader.create_bulk_generate_template_command(
                 self.generate_template_file
             )
             commands.append(generate_template_cmd)
         return commands
 
     def _get_risk_tags_bulk_subcommands(self):
-        bulk_add_risk_tags = self.factory.create_bulk_add_risk_tags_command(self.bulk_add_risk_tags)
-        bulk_remove_risk_tags = self.factory.create_bulk_remove_risk_tags_command(
+        bulk_add_risk_tags = self.bulk_subcommand_loader.create_bulk_add_risk_tags_command(
+            self.bulk_add_risk_tags
+        )
+        bulk_remove_risk_tags = self.bulk_subcommand_loader.create_bulk_remove_risk_tags_command(
             self.bulk_remove_risk_tags
         )
 
         self.handlers.add_handler(u"add_risk_tags", add_risk_tags)
         self.handlers.add_handler(u"remove_risk_tags", remove_risk_tags)
-        generate_template_cmd = self.factory.create_hre_bulk_generate_template_command(
+        generate_template_cmd = self.bulk_subcommand_loader.create_hre_bulk_generate_template_command(
             self.generate_template_file
         )
         return [bulk_add_risk_tags, bulk_remove_risk_tags, generate_template_cmd]

src/code42cli/cmds/detectionlists/bulk.py

@@ -11,10 +11,9 @@ def __iter__(self):
 
 
 class BulkDetectionList(object):
-
     def __init__(self):
         self.type = BulkCommandType
-        
+
     def get_handler(self, handlers, cmd):
         handler = None
         if cmd == self.type.ADD:
@@ -25,7 +24,6 @@ def get_handler(self, handlers, cmd):
 
 
 class BulkHighRiskEmployee(BulkDetectionList):
-
     def __init__(self):
         super(BulkHighRiskEmployee, self).__init__()
         self.type = HighRiskBulkCommandType