Merge remote-tracking branch 'origin/develop' into feature-windows

Conflicts:
	kamaki/cli/__init__.py
	kamaki/cli/argument.py
	kamaki/cli/command_shell.py
	kamaki/cli/command_tree.py
	kamaki/cli/commands/__init__.py
	kamaki/cli/commands/astakos_cli.py
	kamaki/cli/commands/config_cli.py
	kamaki/cli/commands/cyclades_cli.py
	kamaki/cli/commands/history_cli.py
	kamaki/cli/commands/image_cli.py
	kamaki/cli/commands/pithos_cli.py
	kamaki/cli/commands/test_cli.py
	kamaki/cli/config.py
	kamaki/cli/errors.py
	kamaki/cli/history.py
	kamaki/cli/utils.py
	kamaki/clients/connection/kamakicon.py
	kamaki/clients/tests.py

docs/conf.py

@@ -52,7 +52,7 @@ master_doc = 'index'
 
 # General information about the project.
 project = u'Kamaki'
-copyright = u'2012, GRNet'
+copyright = u'2012, GRNET'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
@@ -197,7 +197,7 @@ latex_elements = {
 # [howto/manual]).
 latex_documents = [
   ('index', 'Kamaki.tex', u'Kamaki Documentation',
-   u'GRNet', 'manual'),
+   u'GRNET', 'manual'),
 ]
 
 # The name of an image file (relative to this directory) to place at the top of
@@ -240,7 +240,7 @@ man_pages = [
 #  dir menu entry, description, category)
 texinfo_documents = [
   ('index', 'Kamaki', u'Kamaki Documentation',
-   u'GRNet', 'Kamaki', 'One line description of project.',
+   u'GRNET', 'Kamaki', 'One line description of project.',
    'Miscellaneous'),
 ]
 

docs/developers/adding-commands.rst

@@ -85,9 +85,9 @@ Kamaki interfaces make use of this CommandTree structure. Optimizations are poss
 
     def command(cmd_tree, prefix='', descedants_depth=None):
     """Load a class as a command
-        @cmd_tree is the CommandTree to be updated with a new command
-        @prefix of the commands allowed to be inserted ('' for all)
-        @descedants_depth is the depth of the tree descedants of the
+        :param cmd_tree: is the CommandTree to be updated with a new command
+        :param prefix: of the commands allowed to be inserted ('' for all)
+        :param descedants_depth: is the depth of the tree descedants of the
             prefix command.
     """
 
@@ -125,7 +125,7 @@ The description of each command is the first line of the class commend. The foll
 Declare run-time argument
 -------------------------
 
-The argument mechanism allows the definition of run-time arguments. Some basic argument types are defined at the `argument module <cli.html#module-kamaki.cli.argument>`_, but it is not uncommon to extent these classes in order to achieve specialized type checking and syntax control (e.g. at `pithos_cli module <cli.html#module-kamaki.cli.commands.pithos_cli>`_).
+The argument mechanism allows the definition of run-time arguments. Some basic argument types are defined at the `argument module <code.html#module-kamaki.cli.argument>`_, but it is not uncommon to extent these classes in order to achieve specialized type checking and syntax control (e.g. at `pithos_cli module <code.html#module-kamaki.cli.commands.pithos_cli>`_).
 
 To declare a run-time argument on a specific command, the object class should initialize a dict called *arguments* , where Argument objects are stored. Each argument object is a possible run-time argument. Syntax checking happens at client level, while the type checking is implemented in the Argument code (thus, many different Argument types might be needed).
 
@@ -138,7 +138,7 @@ To declare a run-time argument on a specific command, the object class should in
     class mygrp1_list_details():
         """list of details"""
 
-        def __init__(self, global_args={})
+        def __init__(self, global_args={}):
             global_args['match'] = ValueArgument(
                 'Filter results to match string',
                 '--match')
@@ -149,8 +149,8 @@ The main method and command parameters
 
 The command behavior for each command / class is coded in *main*. The parameters of *main* method defines the command parameters part of the syntax. In specific::
 
-    main(self, param)                   - obligatory parameter
-    main(self, param=None)              - optional parameter
+    main(self, param)                   - obligatory parameter <param>
+    main(self, param=None)              - optional parameter [param]
     main(self, param1, param2=42)       - <param1> [param2]
     main(self, param1____param2)        - <param1:param2>
     main(self, param1____param2=[])     - [param1:param2]

docs/developers/connection.rst

@@ -7,9 +7,9 @@ Since version 0.6 it is safe to use threaded connections.
 
 The Connection package uses httplib, standard python threads and a connection pooling mechanism.
 
-.. note:: in versions 0.6.0 to 0.6.1 the GRNet Synnefo *snf-common* package is used for its connection pooling module. Since version 0.6.2 the underlying pooling mechanism is packed in a new GRNet package called *objpool*, which is now used instead of snf-common.
+.. note:: in versions 0.6.0 to 0.6.1 the GRNET Synnefo *snf-common* package is used for its connection pooling module. Since version 0.6.2 the underlying pooling mechanism is packed in a new GRNET package called *objpool*, which is now used instead of snf-common.
 
 .. automodule:: kamaki.clients.connection
     :members:
     :show-inheritance:
-    :undoc-members:
\ No newline at end of file
+    :undoc-members:

docs/index.rst

@@ -8,10 +8,9 @@ Kamaki project documentation
 
 .. image:: /images/kamaki-logo.png
 
-./kamaki is a simple, yet intuitive, multipurpose command-line tool and client API for managing clouds.
+./kamaki is a simple, yet intuitive, multipurpose, interactive command-line tool and client API for managing clouds.
 
-It is an initial implementation of the OpenStack Compute API, v1.1, with custom
-extensions specific to the Synnefo IaaS cloud management software.
+As a develpment API is an initial implementation of the OpenStack Compute API, v1.1, with custom extensions specific to the `Synnefo IaaS <http://synnefo.org/>`_ cloud management software.
 
 ./kamaki is open source and released under a 2-clause BSD License.
 

docs/installation.rst

@@ -109,9 +109,13 @@ The following steps describe a command-line approach, but any graphic package ma
 
     $ sudo apt-get update
 
-.. note:: Safely ignore a signature verification error like the following, if it emerges:
+.. note:: Don't forget to get the GPG public key for the GRNET dev team:
 
-    .. warning:: GPG error: http://apt.dev.grnet.gr precise/sid InRelease: The following signatures couldn't be verified because the public key is not available: NO_PUBKEY XXXXXXXX
+    .. code-block:: console
+
+        $ curl https://dev.grnet.gr/files/apt-grnetdev.pub|apt-key add -
+
+    otherwise *apt-get update* will produce GPG warnings.
 
 3. Install kamaki
 """""""""""""""""

docs/man/kamaki.rst

@@ -87,6 +87,7 @@ Command user history, as stored in ~/.kamaki.history
 
 * all       show user history
 * clean     clean up history
+* load      Run previously executed command(s)
 
 
 server commands

docs/setup.rst

@@ -3,6 +3,29 @@ Setup
 
 Kamaki is easy to install from source or as a package. Some ui features are optional and can be install separately. Kamaki behavior can be configured in the kamaki config file.
 
+Quick Setup
+-----------
+
+The set up settings of the present paragraph are the only ones needed to have kamaki up and running all its client services.
+
+It is essential for users to get a configuration token (okeanos.grnet.gr users go `here <https://accounts.okeanos.grnet.gr/im/>`_) and provide it to kamaki:
+
+.. code-block:: console
+    :emphasize-lines: 1
+
+    Example 1.1: Set user token to myt0k3n==
+
+    $ kamaki set token myt0k3n==
+
+To use the storage service, a user should also provide the corresponding user-name:
+
+.. code-block:: console
+    :emphasize-lines: 1
+
+    Example 1.2: Set user name to user@domain.com
+
+    $ kamaki set account user@domain.com
+
 Optional features
 -----------------
 

docs/usage.rst

@@ -605,8 +605,6 @@ After a while, the user needs to work with multiple containers, therefore a defa
     2.  pithos (0B, 0 objects)
     3.  trash (2MB, 1 objects)
 
-.. warning:: In some cases, the config setting updates are not immediately effective. If that is the case, they will be after the next command run, whatever that command is.
-
 Using history
 ^^^^^^^^^^^^^
 
@@ -616,6 +614,57 @@ Session history is only available in interactive shell mode. Users can iterate t
 
 Permanent history is implemented as a command group and is common to both the one-command and shell interfaces. In specific, every syntactically correct command is appended in a history file (configured as *history.file* in settings, see `setup section <setup.html>`_ for details). Commands executed in one-command mode are mixed with the ones run in kamaki shell (also see :ref:`using-history-ref` section on this guide).
 
+Scripting
+^^^^^^^^^
+
+Since version 6.2, the history-load feature allows the sequential execution of previously run kamaki commands in kamaki shell.
+
+The following kamaki sequence copies and downloads a file from mycontainer1, uploads it to mycontainer2, then undo the proccess and repeats it with history-load
+
+.. code-block:: console
+    :emphasize-lines: 1,12,19,32
+
+    * Download mycontainer1:myfile and upload it to mycontainer2:myfile
+    [kamaki]: store
+
+    [store]: copy mycontainer1:somefile mycontainer1:myfile
+
+    [store]: download mycontainer1:myfile mylocalfile
+    Download completed
+
+    [store]: upload mylocalfile mycontainer2:myfile
+    Upload completed
+
+    * undo the process *
+    [store]: !rm mylocalfile
+
+    [store]: delete mycontainer1:myfile
+ 
+    [store]: delete mycontainer2:myfile
+
+    * check history entries *
+    [store]: exit
+
+    [kamaki]: history
+
+    [history]: show
+    1.  store
+    2.  store copy mycontainer1:somefile mycontainer1:myfile
+    3.  store download mycontainer1:myfile mylocalfile
+    4.  store upload mylocalfile mycontainer2:myfile
+    5.  history
+    6.  history show
+
+    *repeat the process *
+    [history]: load 2-4
+    store copy mycontainer1:somefile mycontainer1:myfile
+    store download mycontainer1:myfile mylocalfile
+    Download completed
+    store upload mylocalfile mycontainer2:myfile
+    Upload completed
+
+The above strategy is still very primitive. Users are advised to take advantage of their os shell scripting capabilities and combine them with kamaki one-command for powerful scripting. Still, the history-load functionality might prove handy for kamaki shell users.
+
 Tab completion
 ^^^^^^^^^^^^^^
 
@@ -640,26 +689,26 @@ Kamaki shell features the ability to execute OS-shell commands from any context.
 
     [kamaki]:!ls -al
     total 16
-    drwxrwxr-x 2 saxtouri saxtouri 4096 Nov 27 16:47 .
-    drwxrwxr-x 7 saxtouri saxtouri 4096 Nov 27 16:47 ..
-    -rw-rw-r-- 1 saxtouri saxtouri 8063 Jun 28 14:48 kamaki-logo.png
+    drwxrwxr-x 2 username username 4096 Nov 27 16:47 .
+    drwxrwxr-x 7 username username 4096 Nov 27 16:47 ..
+    -rw-rw-r-- 1 username username 8063 Jun 28 14:48 kamaki-logo.png
 
     [kamaki]:shell cp kamaki-logo.png logo-copy.png
 
     [kamaki]:shell ls -al
     total 24
-    drwxrwxr-x 2 saxtouri saxtouri 4096 Nov 27 16:47 .
-    drwxrwxr-x 7 saxtouri saxtouri 4096 Nov 27 16:47 ..
-    -rw-rw-r-- 1 saxtouri saxtouri 8063 Jun 28 14:48 kamaki-logo.png
-    -rw-rw-r-- 1 saxtouri saxtouri 8063 Jun 28 14:48 logo-copy.png
+    drwxrwxr-x 2 username username 4096 Nov 27 16:47 .
+    drwxrwxr-x 7 username username 4096 Nov 27 16:47 ..
+    -rw-rw-r-- 1 username username 8063 Jun 28 14:48 kamaki-logo.png
+    -rw-rw-r-- 1 username username 8063 Jun 28 14:48 logo-copy.png
 
 
-Kamaki shell commits command strings to the outside shell and prints the results, without interacting with it. After a command is finished, kamaki shell returns to its initial state, which involves the current directory, as show in example 4.7.2 .
+Kamaki shell commits command strings to the outside shell and prints the results, without interacting with it. After a command is finished, kamaki shell returns to its initial state, which involves the current directory, as show in example 4.8.2 .
 
 .. code-block:: console
     :emphasize-lines: 1
 
-    Example 4.7.2: Attempt (and fail) to change working directory
+    Example 4.8.2: Attempt (and fail) to change working directory
 
 
     [kamaki]:!pwd

kamaki/__init__.py

@@ -31,4 +31,4 @@
 # interpreted as representing official policies, either expressed
 # or implied, of GRNET S.A.
 
-__version__ = '0.6.1'
+__version__ = '0.6.2'

kamaki/cli/__init__.py

+# Copyright 2012-2013 GRNET S.A. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or
+# without modification, are permitted provided that the following
+# conditions are met:
+#
+#   1. Redistributions of source code must retain the above
+#      copyright notice, this list of conditions and the following
+#      disclaimer.
+#
+#   2. Redistributions in binary form must reproduce the above
+#      copyright notice, this list of conditions and the following
+#      disclaimer in the documentation and/or other materials
+#      provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
+# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# The views and conclusions contained in the software and
+# documentation are those of the authors and should not be
+# interpreted as representing official policies, either expressed
+# or implied, of GRNET S.A.command
+
+import logging
+from sys import argv, exit, stdout
+from os.path import basename
+from inspect import getargspec
+
+from kamaki.cli.argument import ArgumentParseManager
+from kamaki.cli.history import History
+from kamaki.cli.utils import print_dict, print_list, red, magenta, yellow
+from kamaki.cli.errors import CLIError
+
+_help = False
+_debug = False
+_verbose = False
+_colors = False
+kloger = None
+
+
+def _construct_command_syntax(cls):
+        spec = getargspec(cls.main.im_func)
+        args = spec.args[1:]
+        n = len(args) - len(spec.defaults or ())
+        required = ' '.join('<%s>' % x\
+            .replace('____', '[:')\
+            .replace('___', ':')\
+            .replace('__', ']').\
+            replace('_', ' ') for x in args[:n])
+        optional = ' '.join('[%s]' % x\
+            .replace('____', '[:')\
+            .replace('___', ':')\
+            .replace('__', ']').\
+            replace('_', ' ') for x in args[n:])
+        cls.syntax = ' '.join(x for x in [required, optional] if x)
+        if spec.varargs:
+            cls.syntax += ' <%s ...>' % spec.varargs
+
+
+def _get_cmd_tree_from_spec(spec, cmd_tree_list):
+    for tree in cmd_tree_list:
+        if tree.name == spec:
+            return tree
+    return None
+
+
+_best_match = []
+
+
+def _num_of_matching_terms(basic_list, attack_list):
+    if not attack_list:
+        return len(basic_list)
+
+    matching_terms = 0
+    for i, term in enumerate(basic_list):
+        try:
+            if term != attack_list[i]:
+                break
+        except IndexError:
+            break
+        matching_terms += 1
+    return matching_terms
+
+
+def _update_best_match(name_terms, prefix=[]):
+    if prefix:
+        pref_list = prefix if isinstance(prefix, list) else prefix.split('_')
+    else:
+        pref_list = []
+
+    num_of_matching_terms = _num_of_matching_terms(name_terms, pref_list)
+    global _best_match
+    if not prefix:
+        _best_match = []
+
+    if num_of_matching_terms and len(_best_match) <= num_of_matching_terms:
+        if len(_best_match) < num_of_matching_terms:
+            _best_match = name_terms[:num_of_matching_terms]
+        return True
+    return False
+
+
+def command(cmd_tree, prefix='', descedants_depth=1):
+    """Load a class as a command
+        e.g. spec_cmd0_cmd1 will be command spec cmd0
+
+        :param cmd_tree: is initialized in cmd_spec file and is the structure
+            where commands are loaded. Var name should be _commands
+        :param prefix: if given, load only commands prefixed with prefix,
+        :param descedants_depth: is the depth of the tree descedants of the
+            prefix command. It is used ONLY if prefix and if prefix is not
+            a terminal command
+
+        :returns: the specified class object
+    """
+
+    def wrap(cls):
+        global kloger
+        cls_name = cls.__name__
+
+        if not cmd_tree:
+            if _debug:
+                kloger.warning('command %s found but not loaded' % cls_name)
+            return cls
+
+        name_terms = cls_name.split('_')
+        if not _update_best_match(name_terms, prefix):
+            if _debug:
+                kloger.warning('%s failed to update_best_match' % cls_name)
+            return None
+
+        global _best_match
+        max_len = len(_best_match) + descedants_depth
+        if len(name_terms) > max_len:
+            partial = '_'.join(name_terms[:max_len])
+            if not cmd_tree.has_command(partial):  # add partial path
+                cmd_tree.add_command(partial)
+            if _debug:
+                kloger.warning('%s failed max_len test' % cls_name)
+            return None
+
+        cls.description, sep, cls.long_description\
+        = cls.__doc__.partition('\n')
+        _construct_command_syntax(cls)
+
+        cmd_tree.add_command(cls_name, cls.description, cls)
+        return cls
+    return wrap
+
+
+def get_cmd_terms():
+    global command
+    return [term for term in command.func_defaults[0]\
+        if not term.startswith('-')]
+
+cmd_spec_locations = [
+    'kamaki.cli.commands',
+    'kamaki.commands',
+    'kamaki.cli',
+    'kamaki',
+    '']
+
+
+def _setup_logging(silent=False, debug=False, verbose=False, include=False):
+    """handle logging for clients package"""
+
+    def add_handler(name, level, prefix=''):
+        h = logging.StreamHandler()
+        fmt = logging.Formatter(prefix + '%(message)s')
+        h.setFormatter(fmt)
+        logger = logging.getLogger(name)
+        logger.addHandler(h)
+        logger.setLevel(level)
+
+    if silent:
+        add_handler('', logging.CRITICAL)
+        return
+
+    if debug:
+        add_handler('requests', logging.INFO, prefix='* ')
+        add_handler('clients.send', logging.DEBUG, prefix='> ')
+        add_handler('clients.recv', logging.DEBUG, prefix='< ')
+        add_handler('kamaki', logging.DEBUG, prefix='DEBUG: ')
+    elif verbose:
+        add_handler('requests', logging.INFO, prefix='* ')
+        add_handler('clients.send', logging.INFO, prefix='> ')
+        add_handler('clients.recv', logging.INFO, prefix='< ')
+        add_handler('kamaki', logging.INFO, prefix='INFO: ')
+    elif include:
+        add_handler('clients.recv', logging.INFO)
+    add_handler('kamaki', logging.WARNING, prefix='WARNING: ')
+    global kloger
+    kloger = logging.getLogger('kamaki.warning')
+
+
+def _init_session(arguments):
+    global _help
+    _help = arguments['help'].value
+    global _debug
+    _debug = arguments['debug'].value
+    global _verbose
+    _verbose = arguments['verbose'].value
+    global _colors
+    _colors = arguments['config'].get('global', 'colors')
+    if not (stdout.isatty() and _colors == 'on'):
+        from kamaki.cli.utils import remove_colors
+        remove_colors()
+    _silent = arguments['silent'].value
+    _include = arguments['include'].value
+    _setup_logging(_silent, _debug, _verbose, _include)
+
+
+def get_command_group(unparsed, arguments):
+    groups = arguments['config'].get_groups()
+    for term in unparsed:
+        if term.startswith('-'):
+            continue
+        if term in groups:
+            unparsed.remove(term)
+            return term
+        return None
+    return None
+
+
+def _load_spec_module(spec, arguments, module):
+    spec_name = arguments['config'].get(spec, 'cli')
+    if spec_name is None:
+        return None
+    pkg = None
+    for location in cmd_spec_locations:
+        location += spec_name if location == '' else '.%s' % spec_name
+        try:
+            pkg = __import__(location, fromlist=[module])
+            return pkg
+        except ImportError:
+            continue
+    return pkg
+
+
+def _groups_help(arguments):
+    global _debug
+    global kloger
+    descriptions = {}
+    for spec in arguments['config'].get_groups():
+        pkg = _load_spec_module(spec, arguments, '_commands')
+        if pkg:
+            cmds = None
+            try:
+                cmds = [
+                    cmd for cmd in getattr(pkg, '_commands')\
+                    if arguments['config'].get(cmd.name, 'cli')
+                ]
+            except AttributeError:
+                if _debug:
+                    kloger.warning('No description for %s' % spec)
+            try:
+                for cmd in cmds:
+                    descriptions[cmd.name] = cmd.description
+            except TypeError:
+                if _debug:
+                    kloger.warning('no cmd specs in module %s' % spec)
+        elif _debug:
+            kloger.warning('Loading of %s cmd spec failed' % spec)
+    print('\nOptions:\n - - - -')
+    print_dict(descriptions)
+
+
+def _print_subcommands_help(cmd):
+    printout = {}
+    for subcmd in cmd.get_subcommands():
+        spec, sep, print_path = subcmd.path.partition('_')
+        printout[print_path.replace('_', ' ')] = subcmd.description
+    if printout:
+        print('\nOptions:\n - - - -')
+        print_dict(printout)
+
+
+def _update_parser_help(parser, cmd):
+    global _best_match
+    parser.syntax = parser.syntax.split('<')[0]
+    parser.syntax += ' '.join(_best_match)
+
+    if cmd.is_command:
+        cls = cmd.get_class()
+        parser.syntax += ' ' + cls.syntax
+        parser.update_arguments(cls().arguments)
+        # arguments = cls().arguments
+        # update_arguments(parser, arguments)
+    else:
+        parser.syntax += ' <...>'
+    if cmd.has_description:
+        parser.parser.description = cmd.help
+
+
+def _print_error_message(cli_err):
+    errmsg = '%s' % cli_err
+    if cli_err.importance == 1:
+        errmsg = magenta(errmsg)
+    elif cli_err.importance == 2:
+        errmsg = yellow(errmsg)
+    elif cli_err.importance > 2:
+        errmsg = red(errmsg)
+    stdout.write(errmsg)
+    print_list(cli_err.details)
+
+
+def _get_best_match_from_cmd_tree(cmd_tree, unparsed):
+    matched = [term for term in unparsed if not term.startswith('-')]
+    while matched:
+        try:
+            return cmd_tree.get_command('_'.join(matched))
+        except KeyError:
+            matched = matched[:-1]
+    return None
+
+
+def _exec_cmd(instance, cmd_args, help_method):
+    try:
+        return instance.main(*cmd_args)
+    except TypeError as err:
+        if err.args and err.args[0].startswith('main()'):
+            print(magenta('Syntax error'))
+            if _debug:
+                raise err
+            if _verbose:
+                print(unicode(err))
+            help_method()
+        else:
+            raise
+    return 1
+
+
+def set_command_params(parameters):
+    """Add a parameters list to a command
+
+    :param paramters: (list of str) a list of parameters
+    """
+    global command
+    def_params = list(command.func_defaults)
+    def_params[0] = parameters
+    command.func_defaults = tuple(def_params)
+
+
+#def one_cmd(parser, unparsed, arguments):
+def one_cmd(parser):
+    group = get_command_group(list(parser.unparsed), parser.arguments)
+    if not group:
+        parser.parser.print_help()
+        _groups_help(parser.arguments)
+        exit(0)
+
+    nonargs = [term for term in parser.unparsed if not term.startswith('-')]
+    set_command_params(nonargs)
+
+    global _best_match
+    _best_match = []
+