Removed the expensive imports from cmd2/__init__.py

anselor · anselor · commit e018bbd79b2d · 2018-04-25T11:40:33.000-04:00
Added some shared definitions to cmd2/__init__.py -> maybe there's a better place for these? Figured out how to trick bash into showing argument hints. It's a bit weird. Updated all of the tests and examples to import cmd2 resources from their new location without the automatic imports in cmd2/__init__.py For #369
diff --git a/cmd2/__init__.py b/cmd2/__init__.py
@@ -1,8 +1,8 @@
 #
 # -*- coding: utf-8 -*-
 #
-from .cmd2 import __version__, Cmd, set_posix_shlex, set_strip_quotes, AddSubmenu, CmdResult, categorize
-from .cmd2 import with_argument_list, with_argparser, with_argparser_and_unknown_args, with_category
+# from .cmd2 import __version__, Cmd, set_posix_shlex, set_strip_quotes, AddSubmenu, CmdResult, categorize
+# from .cmd2 import with_argument_list, with_argparser, with_argparser_and_unknown_args, with_category
 
 # Used for tab completion and word breaks. Do not change.
 QUOTES = ['"', "'"]
diff --git a/cmd2/argcomplete_bridge.py b/cmd2/argcomplete_bridge.py
@@ -2,7 +2,9 @@
 """Hijack the ArgComplete's bash completion handler to return AutoCompleter results"""
 
 import argcomplete
+from contextlib import redirect_stdout
 import copy
+from io import StringIO
 import os
 import shlex
 import sys
@@ -162,7 +164,13 @@ def __call__(self, argument_parser, completer=None, always_complete_options=True
         comp_point = int(os.environ["COMP_POINT"])
 
         comp_line = argcomplete.ensure_str(comp_line)
-        ### SWAPPED FOR AUTOCOMPLETER
+
+        ##############################
+        # SWAPPED FOR AUTOCOMPLETER
+        #
+        # Replaced with our own tokenizer function
+        ##############################
+
         # cword_prequote, cword_prefix, cword_suffix, comp_words, last_wordbreak_pos = split_line(comp_line, comp_point)
         tokens, _, begidx, endidx = tokens_for_completion(comp_line, comp_point)
 
@@ -172,7 +180,11 @@ def __call__(self, argument_parser, completer=None, always_complete_options=True
         # 2: python <script> [args]
         # 3: python -m <module> [args]
         start = int(os.environ["_ARGCOMPLETE"]) - 1
-        ### SWAPPED FOR AUTOCOMPLETER
+        ##############################
+        # SWAPPED FOR AUTOCOMPLETER
+        #
+        # Applying the same token dropping to our tokens
+        ##############################
         # comp_words = comp_words[start:]
         tokens = tokens[start:]
 
@@ -183,11 +195,20 @@ def __call__(self, argument_parser, completer=None, always_complete_options=True
         #       "\nSUFFIX: {!r}".format(cword_suffix),
         #       "\nWORDS:", comp_words)
 
-        ### SWAPPED FOR AUTOCOMPLETER
+        ##############################
+        # SWAPPED FOR AUTOCOMPLETER
+        #
+        # Replaced with our own completion function and customizing the returned values
+        ##############################
         # completions = self._get_completions(comp_words, cword_prefix, cword_prequote, last_wordbreak_pos)
-        completions = completer.complete_command(tokens, tokens[-1], comp_line, begidx, endidx)
 
-        if completions is not None:
+        # capture stdout from the autocompleter
+        result = StringIO()
+        with redirect_stdout(result):
+            completions = completer.complete_command(tokens, tokens[-1], comp_line, begidx, endidx)
+        outstr = result.getvalue()
+
+        if completions:
             # If any completion has a space in it, then quote all completions
             # this improves the user experience so they don't nede to go back and add a quote
             if ' ' in ''.join(completions):
@@ -196,6 +217,17 @@ def __call__(self, argument_parser, completer=None, always_complete_options=True
             argcomplete.debug("\nReturning completions:", completions)
 
             output_stream.write(ifs.join(completions).encode(argcomplete.sys_encoding))
+        elif outstr:
+            # if there are no completions, but we got something from stdout, try to print help
+
+            # trick the bash completion into thinking there are 2 completions that are unlikely
+            # to ever match.
+            outstr = outstr.replace('\n', ' ').replace('\t', ' ').replace('    ', ' ').strip()
+            # generate a filler entry that should always sort first
+            filler = ' {0:><{width}}'.format('', width=len(outstr))
+            outstr = ifs.join([filler, outstr])
+
+            output_stream.write(outstr.encode(argcomplete.sys_encoding))
         else:
             # if completions is None we assume we don't know how to handle it so let bash
             # go forward with normal filesystem completion
diff --git a/examples/alias_startup.py b/examples/alias_startup.py
@@ -6,10 +6,10 @@
 """
 import argparse
 
-import cmd2
+from cmd2 import cmd2
 import pyparsing
 
-from cmd2 import with_argument_list, with_argparser, with_argparser_and_unknown_args
+from cmd2.cmd2 import with_argument_list, with_argparser, with_argparser_and_unknown_args
 
 
 class AliasAndStartup(cmd2.Cmd):
diff --git a/examples/arg_print.py b/examples/arg_print.py
@@ -11,10 +11,8 @@
 """
 import argparse
 
-import cmd2
-import pyparsing
-
-from cmd2 import with_argument_list, with_argparser, with_argparser_and_unknown_args
+from cmd2 import cmd2
+from cmd2.cmd2 import with_argument_list, with_argparser, with_argparser_and_unknown_args
 
 
 class ArgumentAndOptionPrinter(cmd2.Cmd):
diff --git a/examples/argparse_example.py b/examples/argparse_example.py
@@ -14,7 +14,7 @@
 import argparse
 import sys
 
-from cmd2 import Cmd, with_argparser, with_argument_list
+from cmd2.cmd2 import Cmd, with_argparser, with_argument_list
 
 
 class CmdLineApp(Cmd):
diff --git a/examples/environment.py b/examples/environment.py
@@ -4,7 +4,7 @@
 A sample application for cmd2 demonstrating customized environment parameters
 """
 
-from cmd2 import Cmd
+from cmd2.cmd2 import Cmd
 
 
 class EnvironmentApp(Cmd):
diff --git a/examples/event_loops.py b/examples/event_loops.py
@@ -6,7 +6,7 @@
 
 This opens up the possibility of registering cmd2 input with event loops, like asyncio, without occupying the main loop.
 """
-import cmd2
+from cmd2 import cmd2
 
 
 class Cmd2EventBased(cmd2.Cmd):
diff --git a/examples/example.py b/examples/example.py
@@ -14,7 +14,7 @@
 import random
 import argparse
 
-from cmd2 import Cmd, with_argparser
+from cmd2.cmd2 import Cmd, with_argparser
 
 
 class CmdLineApp(Cmd):
diff --git a/examples/help_categories.py b/examples/help_categories.py
@@ -4,7 +4,7 @@
 A sample application for tagging categories on commands.
 """
 
-from cmd2 import Cmd, categorize, __version__, with_argparser, with_category
+from cmd2.cmd2 import Cmd, categorize, __version__, with_argparser, with_category
 import argparse
 
 
diff --git a/examples/paged_output.py b/examples/paged_output.py
@@ -3,8 +3,8 @@
 """A simple example demonstrating the using paged output via the ppaged() method.
 """
 
-import cmd2
-from cmd2 import with_argument_list
+from cmd2 import cmd2
+from cmd2.cmd2 import with_argument_list
 
 
 class PagedOutput(cmd2.Cmd):
diff --git a/examples/persistent_history.py b/examples/persistent_history.py
@@ -5,7 +5,7 @@
 This will allow end users of your cmd2-based application to use the arrow keys and Ctrl+r in a manner which persists
 across invocations of your cmd2 application.  This can make it much easier for them to use your application.
 """
-import cmd2
+from cmd2 import cmd2
 
 
 class Cmd2PersistentHistory(cmd2.Cmd):
diff --git a/examples/pirate.py b/examples/pirate.py
@@ -7,7 +7,7 @@
 It demonstrates many features of cmd2.
 """
 import argparse
-from cmd2 import Cmd, with_argparser
+from cmd2.cmd2 import Cmd, with_argparser
 
 
 class Pirate(Cmd):
diff --git a/examples/python_scripting.py b/examples/python_scripting.py
@@ -17,7 +17,7 @@
 import argparse
 import os
 
-import cmd2
+from cmd2 import cmd2
 
 
 class CmdLineApp(cmd2.Cmd):
diff --git a/examples/remove_unused.py b/examples/remove_unused.py
@@ -9,7 +9,7 @@
 Commands can also be removed entirely by using Python's "del".
 """
 
-import cmd2
+from cmd2 import cmd2
 
 
 class RemoveUnusedBuiltinCommands(cmd2.Cmd):
diff --git a/examples/subcommands.py b/examples/subcommands.py
@@ -1,18 +1,56 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # coding=utf-8
+# PYTHON_ARGCOMPLETE_OK
 """A simple example demonstrating how to use Argparse to support subcommands.
 
 
 This example shows an easy way for a single command to have many subcommands, each of which takes different arguments
 and provides separate contextual help.
 """
+from cmd2.argcomplete_bridge import CompletionFinder
+from cmd2.argparse_completer import AutoCompleter
 import argparse
 
-import cmd2
-from cmd2 import with_argparser
-
 sport_item_strs = ['Bat', 'Basket', 'Basketball', 'Football', 'Space Ball']
 
+# create the top-level parser for the base command
+base_parser = argparse.ArgumentParser(prog='base')
+base_subparsers = base_parser.add_subparsers(title='subcommands', help='subcommand help')
+
+# create the parser for the "foo" subcommand
+parser_foo = base_subparsers.add_parser('foo', help='foo help')
+parser_foo.add_argument('-x', type=int, default=1, help='integer')
+parser_foo.add_argument('y', type=float, help='float')
+
+# create the parser for the "bar" subcommand
+parser_bar = base_subparsers.add_parser('bar', help='bar help')
+
+bar_subparsers = parser_bar.add_subparsers(title='layer3', help='help for 3rd layer of commands')
+parser_bar.add_argument('z', help='string')
+
+bar_subparsers.add_parser('apple', help='apple help')
+bar_subparsers.add_parser('artichoke', help='artichoke help')
+bar_subparsers.add_parser('cranberries', help='cranberries help')
+
+# create the parser for the "sport" subcommand
+parser_sport = base_subparsers.add_parser('sport', help='sport help')
+sport_arg = parser_sport.add_argument('sport', help='Enter name of a sport')
+setattr(sport_arg, 'arg_choices', sport_item_strs)
+
+# Set both a function and tab completer for the "sport" subcommand
+
+if __name__ == '__main__':
+    with open('out.txt', 'a') as f:
+        f.write('Here 1')
+        f.flush()
+    completer = CompletionFinder()
+    completer(base_parser, AutoCompleter(base_parser))
+
+
+from cmd2 import cmd2
+from cmd2.cmd2 import with_argparser
+
+
 class SubcommandsExample(cmd2.Cmd):
     """
     Example cmd2 application where we a base command which has a couple subcommands
@@ -35,33 +73,8 @@ def base_sport(self, args):
         """sport subcommand of base command"""
         self.poutput('Sport is {}'.format(args.sport))
 
-    # create the top-level parser for the base command
-    base_parser = argparse.ArgumentParser(prog='base')
-    base_subparsers = base_parser.add_subparsers(title='subcommands', help='subcommand help')
-
-    # create the parser for the "foo" subcommand
-    parser_foo = base_subparsers.add_parser('foo', help='foo help')
-    parser_foo.add_argument('-x', type=int, default=1, help='integer')
-    parser_foo.add_argument('y', type=float, help='float')
     parser_foo.set_defaults(func=base_foo)
-
-    # create the parser for the "bar" subcommand
-    parser_bar = base_subparsers.add_parser('bar', help='bar help')
     parser_bar.set_defaults(func=base_bar)
-
-    bar_subparsers = parser_bar.add_subparsers(title='layer3', help='help for 3rd layer of commands')
-    parser_bar.add_argument('z', help='string')
-
-    bar_subparsers.add_parser('apple', help='apple help')
-    bar_subparsers.add_parser('artichoke', help='artichoke help')
-    bar_subparsers.add_parser('cranberries', help='cranberries help')
-
-    # create the parser for the "sport" subcommand
-    parser_sport = base_subparsers.add_parser('sport', help='sport help')
-    sport_arg = parser_sport.add_argument('sport', help='Enter name of a sport')
-    setattr(sport_arg, 'arg_choices', sport_item_strs)
-
-    # Set both a function and tab completer for the "sport" subcommand
     parser_sport.set_defaults(func=base_sport)
 
     @with_argparser(base_parser)
diff --git a/examples/submenus.py b/examples/submenus.py
@@ -11,7 +11,7 @@
 from __future__ import print_function
 import sys
 
-import cmd2
+from cmd2 import cmd2
 from IPython import embed
 
 
diff --git a/examples/tab_autocompletion.py b/examples/tab_autocompletion.py
@@ -10,8 +10,8 @@
 import itertools
 from typing import List
 
-import cmd2
-from cmd2 import with_argparser, with_category, argparse_completer
+from cmd2 import cmd2, argparse_completer
+from cmd2.cmd2 import with_argparser, with_category
 
 actors = ['Mark Hamill', 'Harrison Ford', 'Carrie Fisher', 'Alec Guinness', 'Peter Mayhew',
           'Anthony Daniels', 'Adam Driver', 'Daisy Ridley', 'John Boyega', 'Oscar Isaac',
diff --git a/examples/tab_completion.py b/examples/tab_completion.py
@@ -4,8 +4,8 @@
 """
 import argparse
 
-import cmd2
-from cmd2 import with_argparser, with_argument_list
+from cmd2 import cmd2
+from cmd2.cmd2 import with_argparser, with_argument_list
 
 # List of strings used with flag and index based completion functions
 food_item_strs = ['Pizza', 'Ham', 'Ham Sandwich', 'Potato']
diff --git a/examples/table_display.py b/examples/table_display.py
@@ -12,7 +12,7 @@
 """
 import functools
 
-import cmd2
+from cmd2 import cmd2
 import tabulate
 
 # Format to use with tabulate module when displaying tables
diff --git a/tests/conftest.py b/tests/conftest.py
@@ -10,7 +10,7 @@
 from pytest import fixture
 from unittest import mock
 
-import cmd2
+from cmd2 import cmd2
 
 # Prefer statically linked gnureadline if available (for macOS compatibility due to issues with libedit)
 try:
diff --git a/tests/test_argparse.py b/tests/test_argparse.py
@@ -5,7 +5,7 @@
 import argparse
 import pytest
 
-import cmd2
+from cmd2 import cmd2
 from unittest import mock
 
 from .conftest import run_cmd, StdOut
diff --git a/tests/test_cmd2.py b/tests/test_cmd2.py
diff --git a/tests/test_completion.py b/tests/test_completion.py
diff --git a/tests/test_parsing.py b/tests/test_parsing.py
diff --git a/tests/test_submenu.py b/tests/test_submenu.py
diff --git a/tests/test_transcript.py b/tests/test_transcript.py

Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,8 @@`
`1`	`1`	`#`
`2`	`2`	`# -- coding: utf-8 --`
`3`	`3`	`#`
`4`		`-from .cmd2 import __version__, Cmd, set_posix_shlex, set_strip_quotes, AddSubmenu, CmdResult, categorize`
`5`		`-from .cmd2 import with_argument_list, with_argparser, with_argparser_and_unknown_args, with_category`
	`4`	`+# from .cmd2 import __version__, Cmd, set_posix_shlex, set_strip_quotes, AddSubmenu, CmdResult, categorize`
	`5`	`+# from .cmd2 import with_argument_list, with_argparser, with_argparser_and_unknown_args, with_category`
`6`	`6`
`7`	`7`	`# Used for tab completion and word breaks. Do not change.`
`8`	`8`	`QUOTES = ['"', "'"]`