From 9731d8a4bb7ee2cc8554eaf133bb85498a4c7d80 Mon Sep 17 00:00:00 2001
From: maxim-yurchuk <maxim-yurchuk@yandex-team.com>
Date: Wed, 9 Oct 2024 12:29:46 +0300
Subject: publishFullContrib: true for ydb

<HIDDEN_URL>
commit_hash:c82a80ac4594723cebf2c7387dec9c60217f603e
---
 contrib/python/argcomplete/py2/.dist-info/METADATA | 413 +++++++++++++
 .../argcomplete/py2/.dist-info/top_level.txt       |   1 +
 .../python/argcomplete/py2/argcomplete/__init__.py | 687 +++++++++++++++++++++
 .../py2/argcomplete/_check_console_script.py       |  57 ++
 .../argcomplete/py2/argcomplete/_check_module.py   |  92 +++
 .../bash_completion.d/python-argcomplete           | 106 ++++
 .../python/argcomplete/py2/argcomplete/compat.py   |  25 +
 .../argcomplete/py2/argcomplete/completers.py      | 108 ++++
 .../argcomplete/py2/argcomplete/my_argparse.py     | 331 ++++++++++
 .../python/argcomplete/py2/argcomplete/my_shlex.py | 328 ++++++++++
 .../py2/argcomplete/shell_integration.py           | 121 ++++
 contrib/python/argcomplete/py2/ya.make             |  36 ++
 12 files changed, 2305 insertions(+)
 create mode 100644 contrib/python/argcomplete/py2/.dist-info/METADATA
 create mode 100644 contrib/python/argcomplete/py2/.dist-info/top_level.txt
 create mode 100644 contrib/python/argcomplete/py2/argcomplete/__init__.py
 create mode 100644 contrib/python/argcomplete/py2/argcomplete/_check_console_script.py
 create mode 100644 contrib/python/argcomplete/py2/argcomplete/_check_module.py
 create mode 100644 contrib/python/argcomplete/py2/argcomplete/bash_completion.d/python-argcomplete
 create mode 100644 contrib/python/argcomplete/py2/argcomplete/compat.py
 create mode 100644 contrib/python/argcomplete/py2/argcomplete/completers.py
 create mode 100644 contrib/python/argcomplete/py2/argcomplete/my_argparse.py
 create mode 100644 contrib/python/argcomplete/py2/argcomplete/my_shlex.py
 create mode 100644 contrib/python/argcomplete/py2/argcomplete/shell_integration.py
 create mode 100644 contrib/python/argcomplete/py2/ya.make

(limited to 'contrib/python/argcomplete/py2')

diff --git a/contrib/python/argcomplete/py2/.dist-info/METADATA b/contrib/python/argcomplete/py2/.dist-info/METADATA
new file mode 100644
index 00000000000..8d849dd9182
--- /dev/null
+++ b/contrib/python/argcomplete/py2/.dist-info/METADATA
@@ -0,0 +1,413 @@
+Metadata-Version: 2.1
+Name: argcomplete
+Version: 1.12.3
+Summary: Bash tab completion for argparse
+Home-page: https://github.com/kislyuk/argcomplete
+Author: Andrey Kislyuk
+Author-email: kislyuk@gmail.com
+License: Apache Software License
+Project-URL: Documentation, https://kislyuk.github.io/argcomplete
+Project-URL: Source Code, https://github.com/kislyuk/argcomplete
+Project-URL: Issue Tracker, https://github.com/kislyuk/argcomplete/issues
+Project-URL: Change Log, https://github.com/kislyuk/argcomplete/blob/master/Changes.rst
+Platform: MacOS X
+Platform: Posix
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Shells
+Classifier: Topic :: Terminals
+Requires-Dist: importlib-metadata (<5,>=0.23) ; python_version == "2.7"
+Requires-Dist: importlib-metadata (<5,>=0.23) ; python_version == "3.5"
+Requires-Dist: importlib-metadata (<5,>=0.23) ; python_version == "3.6"
+Requires-Dist: importlib-metadata (<5,>=0.23) ; python_version == "3.7"
+Provides-Extra: test
+Requires-Dist: coverage ; extra == 'test'
+Requires-Dist: flake8 ; extra == 'test'
+Requires-Dist: pexpect ; extra == 'test'
+Requires-Dist: wheel ; extra == 'test'
+
+argcomplete - Bash tab completion for argparse
+==============================================
+*Tab complete all the things!*
+
+Argcomplete provides easy, extensible command line tab completion of arguments for your Python script.
+
+It makes two assumptions:
+
+* You're using bash as your shell (limited support for zsh, fish, and tcsh is available)
+* You're using `argparse <http://docs.python.org/3/library/argparse.html>`_ to manage your command line arguments/options
+
+Argcomplete is particularly useful if your program has lots of options or subparsers, and if your program can
+dynamically suggest completions for your argument/option values (for example, if the user is browsing resources over
+the network).
+
+Installation
+------------
+::
+
+    pip3 install argcomplete
+    activate-global-python-argcomplete
+
+See `Activating global completion`_ below for details about the second step (or if it reports an error).
+
+Refresh your bash environment (start a new shell or ``source /etc/profile``).
+
+Synopsis
+--------
+Python code (e.g. ``my-awesome-script``):
+
+.. code-block:: python
+
+    #!/usr/bin/env python
+    # PYTHON_ARGCOMPLETE_OK
+    import argcomplete, argparse
+    parser = argparse.ArgumentParser()
+    ...
+    argcomplete.autocomplete(parser)
+    args = parser.parse_args()
+    ...
+
+Shellcode (only necessary if global completion is not activated - see `Global completion`_ below), to be put in e.g. ``.bashrc``::
+
+    eval "$(register-python-argcomplete my-awesome-script)"
+
+argcomplete.autocomplete(*parser*)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+This method is the entry point to the module. It must be called **after** ArgumentParser construction is complete, but
+**before** the ``ArgumentParser.parse_args()`` method is called. The method looks for an environment variable that the
+completion hook shellcode sets, and if it's there, collects completions, prints them to the output stream (fd 8 by
+default), and exits. Otherwise, it returns to the caller immediately.
+
+.. admonition:: Side effects
+
+ Argcomplete gets completions by running your program. It intercepts the execution flow at the moment
+ ``argcomplete.autocomplete()`` is called. After sending completions, it exits using ``exit_method`` (``os._exit``
+ by default). This means if your program has any side effects that happen before ``argcomplete`` is called, those
+ side effects will happen every time the user presses ``<TAB>`` (although anything your program prints to stdout or
+ stderr will be suppressed). For this reason it's best to construct the argument parser and call
+ ``argcomplete.autocomplete()`` as early as possible in your execution flow.
+
+.. admonition:: Performance
+
+ If the program takes a long time to get to the point where ``argcomplete.autocomplete()`` is called, the tab completion
+ process will feel sluggish, and the user may lose confidence in it. So it's also important to minimize the startup time
+ of the program up to that point (for example, by deferring initialization or importing of large modules until after
+ parsing options).
+
+Specifying completers
+---------------------
+You can specify custom completion functions for your options and arguments. Two styles are supported: callable and
+readline-style. Callable completers are simpler. They are called with the following keyword arguments:
+
+* ``prefix``: The prefix text of the last word before the cursor on the command line.
+  For dynamic completers, this can be used to reduce the work required to generate possible completions.
+* ``action``: The ``argparse.Action`` instance that this completer was called for.
+* ``parser``: The ``argparse.ArgumentParser`` instance that the action was taken by.
+* ``parsed_args``: The result of argument parsing so far (the ``argparse.Namespace`` args object normally returned by
+  ``ArgumentParser.parse_args()``).
+
+Completers should return their completions as a list of strings. An example completer for names of environment
+variables might look like this:
+
+.. code-block:: python
+
+    def EnvironCompleter(**kwargs):
+        return os.environ
+
+To specify a completer for an argument or option, set the ``completer`` attribute of its associated action. An easy
+way to do this at definition time is:
+
+.. code-block:: python
+
+    from argcomplete.completers import EnvironCompleter
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--env-var1").completer = EnvironCompleter
+    parser.add_argument("--env-var2").completer = EnvironCompleter
+    argcomplete.autocomplete(parser)
+
+If you specify the ``choices`` keyword for an argparse option or argument (and don't specify a completer), it will be
+used for completions.
+
+A completer that is initialized with a set of all possible choices of values for its action might look like this:
+
+.. code-block:: python
+
+    class ChoicesCompleter(object):
+        def __init__(self, choices):
+            self.choices = choices
+
+        def __call__(self, **kwargs):
+            return self.choices
+
+The following two ways to specify a static set of choices are equivalent for completion purposes:
+
+.. code-block:: python
+
+    from argcomplete.completers import ChoicesCompleter
+
+    parser.add_argument("--protocol", choices=('http', 'https', 'ssh', 'rsync', 'wss'))
+    parser.add_argument("--proto").completer=ChoicesCompleter(('http', 'https', 'ssh', 'rsync', 'wss'))
+
+Note that if you use the ``choices=<completions>`` option, argparse will show
+all these choices in the ``--help`` output by default. To prevent this, set
+``metavar`` (like ``parser.add_argument("--protocol", metavar="PROTOCOL",
+choices=('http', 'https', 'ssh', 'rsync', 'wss'))``).
+
+The following `script <https://raw.github.com/kislyuk/argcomplete/master/docs/examples/describe_github_user.py>`_ uses
+``parsed_args`` and `Requests <http://python-requests.org/>`_ to query GitHub for publicly known members of an
+organization and complete their names, then prints the member description:
+
+.. code-block:: python
+
+    #!/usr/bin/env python
+    # PYTHON_ARGCOMPLETE_OK
+    import argcomplete, argparse, requests, pprint
+
+    def github_org_members(prefix, parsed_args, **kwargs):
+        resource = "https://api.github.com/orgs/{org}/members".format(org=parsed_args.organization)
+        return (member['login'] for member in requests.get(resource).json() if member['login'].startswith(prefix))
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--organization", help="GitHub organization")
+    parser.add_argument("--member", help="GitHub member").completer = github_org_members
+
+    argcomplete.autocomplete(parser)
+    args = parser.parse_args()
+
+    pprint.pprint(requests.get("https://api.github.com/users/{m}".format(m=args.member)).json())
+
+`Try it <https://raw.github.com/kislyuk/argcomplete/master/docs/examples/describe_github_user.py>`_ like this::
+
+    ./describe_github_user.py --organization heroku --member <TAB>
+
+If you have a useful completer to add to the `completer library
+<https://github.com/kislyuk/argcomplete/blob/master/argcomplete/completers.py>`_, send a pull request!
+
+Readline-style completers
+~~~~~~~~~~~~~~~~~~~~~~~~~
+The readline_ module defines a completer protocol in rlcompleter_. Readline-style completers are also supported by
+argcomplete, so you can use the same completer object both in an interactive readline-powered shell and on the bash
+command line. For example, you can use the readline-style completer provided by IPython_ to get introspective
+completions like you would get in the IPython shell:
+
+.. _readline: http://docs.python.org/3/library/readline.html
+.. _rlcompleter: http://docs.python.org/3/library/rlcompleter.html#completer-objects
+.. _IPython: http://ipython.org/
+
+.. code-block:: python
+
+    import IPython
+    parser.add_argument("--python-name").completer = IPython.core.completer.Completer()
+
+``argcomplete.CompletionFinder.rl_complete`` can also be used to plug in an argparse parser as a readline completer.
+
+Printing warnings in completers
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Normal stdout/stderr output is suspended when argcomplete runs. Sometimes, though, when the user presses ``<TAB>``, it's
+appropriate to print information about why completions generation failed. To do this, use ``warn``:
+
+.. code-block:: python
+
+    from argcomplete import warn
+
+    def AwesomeWebServiceCompleter(prefix, **kwargs):
+        if login_failed:
+            warn("Please log in to Awesome Web Service to use autocompletion")
+        return completions
+
+Using a custom completion validator
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+By default, argcomplete validates your completions by checking if they start with the prefix given to the completer. You
+can override this validation check by supplying the ``validator`` keyword to ``argcomplete.autocomplete()``:
+
+.. code-block:: python
+
+    def my_validator(current_input, keyword_to_check_against):
+        # Pass through ALL options even if they don't all start with 'current_input'
+        return True
+
+    argcomplete.autocomplete(parser, validator=my_validator)
+
+Global completion
+-----------------
+In global completion mode, you don't have to register each argcomplete-capable executable separately. Instead, bash
+will look for the string **PYTHON_ARGCOMPLETE_OK** in the first 1024 bytes of any executable that it's running
+completion for, and if it's found, follow the rest of the argcomplete protocol as described above.
+
+Additionally, completion is activated for scripts run as ``python <script>`` and ``python -m <module>``.
+This also works for alternate Python versions (e.g. ``python3`` and ``pypy``), as long as that version of Python has
+argcomplete installed.
+
+.. admonition:: Bash version compatibility
+
+ Global completion requires bash support for ``complete -D``, which was introduced in bash 4.2. On OS X or older Linux
+ systems, you will need to update bash to use this feature. Check the version of the running copy of bash with
+ ``echo $BASH_VERSION``. On OS X, install bash via `Homebrew <http://brew.sh/>`_ (``brew install bash``), add
+ ``/usr/local/bin/bash`` to ``/etc/shells``, and run ``chsh`` to change your shell.
+
+ Global completion is not currently compatible with zsh.
+
+.. note:: If you use setuptools/distribute ``scripts`` or ``entry_points`` directives to package your module,
+ argcomplete will follow the wrapper scripts to their destination and look for ``PYTHON_ARGCOMPLETE_OK`` in the
+ destination code.
+
+If you choose not to use global completion, or ship a bash completion module that depends on argcomplete, you must
+register your script explicitly using ``eval "$(register-python-argcomplete my-awesome-script)"``. Standard bash
+completion registration roules apply: namely, the script name is passed directly to ``complete``, meaning it is only tab
+completed when invoked exactly as it was registered. In the above example, ``my-awesome-script`` must be on the path,
+and the user must be attempting to complete it by that name. The above line alone would **not** allow you to complete
+``./my-awesome-script``, or ``/path/to/my-awesome-script``.
+
+
+Activating global completion
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+The script ``activate-global-python-argcomplete`` will try to install the file
+``bash_completion.d/python-argcomplete`` (`see on GitHub`_) into an appropriate location on your system
+(``/etc/bash_completion.d/`` or ``~/.bash_completion.d/``). If it
+fails, but you know the correct location of your bash completion scripts directory, you can specify it with ``--dest``::
+
+    activate-global-python-argcomplete --dest=/path/to/bash_completion.d
+
+Otherwise, you can redirect its shellcode output into a file::
+
+    activate-global-python-argcomplete --dest=- > file
+
+The file's contents should then be sourced in e.g. ``~/.bashrc``.
+
+.. _`see on GitHub`: https://github.com/kislyuk/argcomplete/blob/master/argcomplete/bash_completion.d/python-argcomplete
+
+Zsh Support
+------------
+To activate completions for zsh you need to have ``bashcompinit`` enabled in zsh::
+
+    autoload -U bashcompinit
+    bashcompinit
+
+Afterwards you can enable completion for your scripts with ``register-python-argcomplete``::
+
+    eval "$(register-python-argcomplete my-awesome-script)"
+
+Tcsh Support
+------------
+To activate completions for tcsh use::
+
+    eval `register-python-argcomplete --shell tcsh my-awesome-script`
+
+The ``python-argcomplete-tcsh`` script provides completions for tcsh.
+The following is an example of the tcsh completion syntax for
+``my-awesome-script`` emitted by ``register-python-argcomplete``::
+
+    complete my-awesome-script 'p@*@`python-argcomplete-tcsh my-awesome-script`@'
+
+Fish Support
+------------
+To activate completions for fish use::
+
+    register-python-argcomplete --shell fish my-awesome-script | source
+
+or create new completion file, e.g::
+
+    register-python-argcomplete --shell fish my-awesome-script > ~/.config/fish/completions/my-awesome-script.fish
+
+Completion Description For Fish
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+By default help string is added as completion description.
+
+.. image:: docs/fish_help_string.png
+
+You can disable this feature by removing ``_ARGCOMPLETE_DFS`` variable, e.g::
+
+    register-python-argcomplete --shell fish my-awesome-script | grep -v _ARGCOMPLETE_DFS | .
+
+Git Bash Support
+----------------
+Due to limitations of file descriptor inheritance on Windows,
+Git Bash not supported out of the box. You can opt in to using
+temporary files instead of file descriptors for for IPC
+by setting the environment variable ``ARGCOMPLETE_USE_TEMPFILES``,
+e.g. by adding ``export ARGCOMPLETE_USE_TEMPFILES=1`` to ``~/.bashrc``.
+
+For full support, consider using Bash with the
+Windows Subsystem for Linux (WSL).
+
+External argcomplete script
+---------------------------
+To register an argcomplete script for an arbitrary name, the ``--external-argcomplete-script`` argument of the ``register-python-argcomplete`` script can be used::
+
+    eval "$(register-python-argcomplete --external-argcomplete-script /path/to/script arbitrary-name)"
+
+This allows, for example, to use the auto completion functionality of argcomplete for an application not written in Python. 
+The command line interface of this program must be additionally implemented in a Python script with argparse and argcomplete and whenever the application is called the registered external argcomplete script is used for auto completion.
+
+This option can also be used in combination with the other supported shells.
+
+Python Support
+--------------
+Argcomplete requires Python 2.7 or 3.5+.
+
+Common Problems
+---------------
+If global completion is not completing your script, bash may have registered a
+default completion function::
+
+    $ complete | grep my-awesome-script
+    complete -F _minimal my-awesome-script
+
+You can fix this by restarting your shell, or by running
+``complete -r my-awesome-script``.
+
+Debugging
+---------
+Set the ``_ARC_DEBUG`` variable in your shell to enable verbose debug output every time argcomplete runs. This will
+disrupt the command line composition state of your terminal, but make it possible to see the internal state of the
+completer if it encounters problems.
+
+Acknowledgments
+---------------
+Inspired and informed by the optcomplete_ module by Martin Blais.
+
+.. _optcomplete: http://pypi.python.org/pypi/optcomplete
+
+Links
+-----
+* `Project home page (GitHub) <https://github.com/kislyuk/argcomplete>`_
+* `Documentation <https://kislyuk.github.io/argcomplete/>`_
+* `Package distribution (PyPI) <https://pypi.python.org/pypi/argcomplete>`_
+* `Change log <https://github.com/kislyuk/argcomplete/blob/master/Changes.rst>`_
+* `xontrib-argcomplete <https://github.com/anki-code/xontrib-argcomplete>`_ - support argcomplete in `xonsh <https://github.com/xonsh/xonsh>`_ shell
+
+Bugs
+~~~~
+Please report bugs, issues, feature requests, etc. on `GitHub <https://github.com/kislyuk/argcomplete/issues>`_.
+
+License
+-------
+Licensed under the terms of the `Apache License, Version 2.0 <http://www.apache.org/licenses/LICENSE-2.0>`_.
+
+.. image:: https://github.com/kislyuk/argcomplete/workflows/Python%20package/badge.svg
+        :target: https://github.com/kislyuk/argcomplete/actions
+.. image:: https://codecov.io/github/kislyuk/argcomplete/coverage.svg?branch=master
+        :target: https://codecov.io/github/kislyuk/argcomplete?branch=master
+.. image:: https://img.shields.io/pypi/v/argcomplete.svg
+        :target: https://pypi.python.org/pypi/argcomplete
+.. image:: https://img.shields.io/pypi/l/argcomplete.svg
+        :target: https://pypi.python.org/pypi/argcomplete
+
+
diff --git a/contrib/python/argcomplete/py2/.dist-info/top_level.txt b/contrib/python/argcomplete/py2/.dist-info/top_level.txt
new file mode 100644
index 00000000000..e60624ffee6
--- /dev/null
+++ b/contrib/python/argcomplete/py2/.dist-info/top_level.txt
@@ -0,0 +1 @@
+argcomplete
diff --git a/contrib/python/argcomplete/py2/argcomplete/__init__.py b/contrib/python/argcomplete/py2/argcomplete/__init__.py
new file mode 100644
index 00000000000..c2c8390b980
--- /dev/null
+++ b/contrib/python/argcomplete/py2/argcomplete/__init__.py
@@ -0,0 +1,687 @@
+# Copyright 2012-2019, Andrey Kislyuk and argcomplete contributors.
+# Licensed under the Apache License. See https://github.com/kislyuk/argcomplete for more info.
+
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import os, sys, argparse, contextlib
+from . import completers, my_shlex as shlex
+from .compat import USING_PYTHON2, str, sys_encoding, ensure_str, ensure_bytes
+from .completers import FilesCompleter, SuppressCompleter
+from .my_argparse import IntrospectiveArgumentParser, action_is_satisfied, action_is_open, action_is_greedy
+from .shell_integration import shellcode
+
+_DEBUG = "_ARC_DEBUG" in os.environ
+
+debug_stream = sys.stderr
+
+def debug(*args):
+    if _DEBUG:
+        if USING_PYTHON2:
+            # debug_stream has to be binary mode in Python 2.
+            # Attempting to write unicode directly uses the default ascii conversion.
+            # Convert any unicode to bytes, leaving non-string input alone.
+            args = [ensure_bytes(x) if isinstance(x, str) else x for x in args]
+        print(file=debug_stream, *args)
+
+BASH_FILE_COMPLETION_FALLBACK = 79
+BASH_DIR_COMPLETION_FALLBACK = 80
+
+safe_actions = (argparse._StoreAction,
+                argparse._StoreConstAction,
+                argparse._StoreTrueAction,
+                argparse._StoreFalseAction,
+                argparse._AppendAction,
+                argparse._AppendConstAction,
+                argparse._CountAction)
+
+@contextlib.contextmanager
+def mute_stdout():
+    stdout = sys.stdout
+    sys.stdout = open(os.devnull, "w")
+    try:
+        yield
+    finally:
+        sys.stdout = stdout
+
+@contextlib.contextmanager
+def mute_stderr():
+    stderr = sys.stderr
+    sys.stderr = open(os.devnull, "w")
+    try:
+        yield
+    finally:
+        sys.stderr.close()
+        sys.stderr = stderr
+
+class ArgcompleteException(Exception):
+    pass
+
+def split_line(line, point=None):
+    if point is None:
+        point = len(line)
+    lexer = shlex.shlex(line, posix=True)
+    lexer.whitespace_split = True
+    lexer.wordbreaks = os.environ.get("_ARGCOMPLETE_COMP_WORDBREAKS", "")
+    words = []
+
+    def split_word(word):
+        # TODO: make this less ugly
+        point_in_word = len(word) + point - lexer.instream.tell()
+        if isinstance(lexer.state, (str, bytes)) and lexer.state in lexer.whitespace:
+            point_in_word += 1
+        if point_in_word > len(word):
+            debug("In trailing whitespace")
+            words.append(word)
+            word = ""
+        prefix, suffix = word[:point_in_word], word[point_in_word:]
+        prequote = ""
+        # posix
+        if lexer.state is not None and lexer.state in lexer.quotes:
+            prequote = lexer.state
+        # non-posix
+        # if len(prefix) > 0 and prefix[0] in lexer.quotes:
+        #    prequote, prefix = prefix[0], prefix[1:]
+
+        return prequote, prefix, suffix, words, lexer.last_wordbreak_pos
+
+    while True:
+        try:
+            word = lexer.get_token()
+            if word == lexer.eof:
+                # TODO: check if this is ever unsafe
+                # raise ArgcompleteException("Unexpected end of input")
+                return "", "", "", words, None
+            if lexer.instream.tell() >= point:
+                debug("word", word, "split, lexer state: '{s}'".format(s=lexer.state))
+                return split_word(word)
+            words.append(word)
+        except ValueError:
+            debug("word", lexer.token, "split (lexer stopped, state: '{s}')".format(s=lexer.state))
+            if lexer.instream.tell() >= point:
+                return split_word(lexer.token)
+            else:
+                msg = ("Unexpected internal state. "
+                       "Please report this bug at https://github.com/kislyuk/argcomplete/issues.")
+                raise ArgcompleteException(msg)
+
+def default_validator(completion, prefix):
+    return completion.startswith(prefix)
+
+class CompletionFinder(object):
+    """
+    Inherit from this class if you wish to override any of the stages below. Otherwise, use
+    ``argcomplete.autocomplete()`` directly (it's a convenience instance of this class). It has the same signature as
+    :meth:`CompletionFinder.__call__()`.
+    """
+    def __init__(self, argument_parser=None, always_complete_options=True, exclude=None, validator=None,
+                 print_suppressed=False, default_completer=FilesCompleter(), append_space=None):
+        self._parser = argument_parser
+        self.always_complete_options = always_complete_options
+        self.exclude = exclude
+        if validator is None:
+            validator = default_validator
+        self.validator = validator
+        self.print_suppressed = print_suppressed
+        self.completing = False
+        self._display_completions = {}
+        self.default_completer = default_completer
+        if append_space is None:
+            append_space = os.environ.get("_ARGCOMPLETE_SUPPRESS_SPACE") != "1"
+        self.append_space = append_space
+
+    def __call__(self, argument_parser, always_complete_options=True, exit_method=os._exit, output_stream=None,
+                 exclude=None, validator=None, print_suppressed=False, append_space=None,
+                 default_completer=FilesCompleter()):
+        """
+        :param argument_parser: The argument parser to autocomplete on
+        :type argument_parser: :class:`argparse.ArgumentParser`
+        :param always_complete_options:
+            Controls the autocompletion of option strings if an option string opening character (normally ``-``) has not
+            been entered. If ``True`` (default), both short (``-x``) and long (``--x``) option strings will be
+            suggested. If ``False``, no option strings will be suggested. If ``long``, long options and short options
+            with no long variant will be suggested. If ``short``, short options and long options with no short variant
+            will be suggested.
+        :type always_complete_options: boolean or string
+        :param exit_method:
+            Method used to stop the program after printing completions. Defaults to :meth:`os._exit`. If you want to
+            perform a normal exit that calls exit handlers, use :meth:`sys.exit`.
+        :type exit_method: callable
+        :param exclude: List of strings representing options to be omitted from autocompletion
+        :type exclude: iterable
+        :param validator:
+            Function to filter all completions through before returning (called with two string arguments, completion
+            and prefix; return value is evaluated as a boolean)
+        :type validator: callable
+        :param print_suppressed:
+            Whether or not to autocomplete options that have the ``help=argparse.SUPPRESS`` keyword argument set.
+        :type print_suppressed: boolean
+        :param append_space:
+            Whether to append a space to unique matches. The default is ``True``.
+        :type append_space: boolean
+
+        .. note::
+            If you are not subclassing CompletionFinder to override its behaviors,
+            use ``argcomplete.autocomplete()`` directly. It has the same signature as this method.
+
+        Produces tab completions for ``argument_parser``. See module docs for more info.
+
+        Argcomplete only executes actions if their class is known not to have side effects. Custom action classes can be
+        added to argcomplete.safe_actions, if their values are wanted in the ``parsed_args`` completer argument, or
+        their execution is otherwise desirable.
+        """
+        self.__init__(argument_parser, always_complete_options=always_complete_options, exclude=exclude,
+                      validator=validator, print_suppressed=print_suppressed, append_space=append_space,
+                      default_completer=default_completer)
+
+        if "_ARGCOMPLETE" not in os.environ:
+            # not an argument completion invocation
+            return
+
+        global debug_stream
+        try:
+            debug_stream = os.fdopen(9, "w")
+        except:
+            debug_stream = sys.stderr
+        debug()
+
+        if output_stream is None:
+            filename = os.environ.get("_ARGCOMPLETE_STDOUT_FILENAME")
+            if filename is not None:
+                debug("Using output file {}".format(filename))
+                output_stream = open(filename, "wb")
+
+        if output_stream is None:
+            try:
+                output_stream = os.fdopen(8, "wb")
+            except:
+                debug("Unable to open fd 8 for writing, quitting")
+                exit_method(1)
+
+        # print("", stream=debug_stream)
+        # for v in "COMP_CWORD COMP_LINE COMP_POINT COMP_TYPE COMP_KEY _ARGCOMPLETE_COMP_WORDBREAKS COMP_WORDS".split():
+        #     print(v, os.environ[v], stream=debug_stream)
+
+        ifs = os.environ.get("_ARGCOMPLETE_IFS", "\013")
+        if len(ifs) != 1:
+            debug("Invalid value for IFS, quitting [{v}]".format(v=ifs))
+            exit_method(1)
+
+        dfs = os.environ.get("_ARGCOMPLETE_DFS")
+        if dfs and len(dfs) != 1:
+            debug("Invalid value for DFS, quitting [{v}]".format(v=dfs))
+            exit_method(1)
+
+        comp_line = os.environ["COMP_LINE"]
+        comp_point = int(os.environ["COMP_POINT"])
+
+        comp_line = ensure_str(comp_line)
+        cword_prequote, cword_prefix, cword_suffix, comp_words, last_wordbreak_pos = split_line(comp_line, comp_point)
+
+        # _ARGCOMPLETE is set by the shell script to tell us where comp_words
+        # should start, based on what we're completing.
+        # 1: <script> [args]
+        # 2: python <script> [args]
+        # 3: python -m <module> [args]
+        start = int(os.environ["_ARGCOMPLETE"]) - 1
+        comp_words = comp_words[start:]
+
+        if cword_prefix and cword_prefix[0] in self._parser.prefix_chars and "=" in cword_prefix:
+            # Special case for when the current word is "--optional=PARTIAL_VALUE". Give the optional to the parser.
+            comp_words.append(cword_prefix.split("=", 1)[0])
+
+        debug("\nLINE: {!r}".format(comp_line),
+              "\nPOINT: {!r}".format(comp_point),
+              "\nPREQUOTE: {!r}".format(cword_prequote),
+              "\nPREFIX: {!r}".format(cword_prefix),
+              "\nSUFFIX: {!r}".format(cword_suffix),
+              "\nWORDS:", comp_words)
+
+        completions = self._get_completions(comp_words, cword_prefix, cword_prequote, last_wordbreak_pos)
+
+        if dfs:
+            display_completions = {key_part: value.replace(ifs, " ") if value else ""
+                                   for key, value in self._display_completions.items()
+                                   for key_part in key}
+            completions = [dfs.join((key, display_completions.get(key) or "")) for key in completions]
+
+        debug("\nReturning completions:", completions)
+        output_stream.write(ifs.join(completions).encode(sys_encoding))
+        output_stream.flush()
+        debug_stream.flush()
+        exit_method(0)
+
+    def _get_completions(self, comp_words, cword_prefix, cword_prequote, last_wordbreak_pos):
+        active_parsers = self._patch_argument_parser()
+
+        parsed_args = argparse.Namespace()
+        self.completing = True
+
+        if USING_PYTHON2:
+            # Python 2 argparse only properly works with byte strings.
+            comp_words = [ensure_bytes(word) for word in comp_words]
+
+        try:
+            debug("invoking parser with", comp_words[1:])
+            with mute_stderr():
+                a = self._parser.parse_known_args(comp_words[1:], namespace=parsed_args)
+            debug("parsed args:", a)
+        except BaseException as e:
+            debug("\nexception", type(e), str(e), "while parsing args")
+
+        self.completing = False
+
+        if "--" in comp_words:
+            self.always_complete_options = False
+
+        completions = self.collect_completions(active_parsers, parsed_args, cword_prefix, debug)
+        completions = self.filter_completions(completions)
+        completions = self.quote_completions(completions, cword_prequote, last_wordbreak_pos)
+        return completions
+
+    def _patch_argument_parser(self):
+        """
+        Since argparse doesn't support much introspection, we monkey-patch it to replace the parse_known_args method and
+        all actions with hooks that tell us which action was last taken or about to be taken, and let us have the parser
+        figure out which subparsers need to be activated (then recursively monkey-patch those).
+        We save all active ArgumentParsers to extract all their possible option names later.
+        """
+        self.active_parsers = []
+        self.visited_positionals = []
+
+        completer = self
+
+        def patch(parser):
+            completer.visited_positionals.append(parser)
+            completer.active_parsers.append(parser)
+
+            if isinstance(parser, IntrospectiveArgumentParser):
+                return
+
+            classname = "MonkeyPatchedIntrospectiveArgumentParser"
+            if USING_PYTHON2:
+                classname = bytes(classname)
+            parser.__class__ = type(classname, (IntrospectiveArgumentParser, parser.__class__), {})
+
+            for action in parser._actions:
+
+                if hasattr(action, "_orig_class"):
+                    continue
+
+                # TODO: accomplish this with super
+                class IntrospectAction(action.__class__):
+                    def __call__(self, parser, namespace, values, option_string=None):
+                        debug("Action stub called on", self)
+                        debug("\targs:", parser, namespace, values, option_string)
+                        debug("\torig class:", self._orig_class)
+                        debug("\torig callable:", self._orig_callable)
+
+                        if not completer.completing:
+                            self._orig_callable(parser, namespace, values, option_string=option_string)
+                        elif issubclass(self._orig_class, argparse._SubParsersAction):
+                            debug("orig class is a subparsers action: patching and running it")
+                            patch(self._name_parser_map[values[0]])
+                            self._orig_callable(parser, namespace, values, option_string=option_string)
+                        elif self._orig_class in safe_actions:
+                            if not self.option_strings:
+                                completer.visited_positionals.append(self)
+
+                            self._orig_callable(parser, namespace, values, option_string=option_string)
+
+                action._orig_class = action.__class__
+                action._orig_callable = action.__call__
+                action.__class__ = IntrospectAction
+
+        patch(self._parser)
+
+        debug("Active parsers:", self.active_parsers)
+        debug("Visited positionals:", self.visited_positionals)
+
+        return self.active_parsers
+
+    def _get_subparser_completions(self, parser, cword_prefix):
+        def filter_aliases(aliases, prefix):
+            return tuple(x for x in aliases if x.startswith(prefix))
+
+        aliases_by_parser = {}
+        for key in parser.choices.keys():
+            p = parser.choices[key]
+            aliases_by_parser.setdefault(p, []).append(key)
+
+        for action in parser._get_subactions():
+            subcmd_with_aliases = filter_aliases(aliases_by_parser[parser.choices[action.dest]], cword_prefix)
+            if subcmd_with_aliases:
+                self._display_completions[subcmd_with_aliases] = action.help
+
+        completions = [subcmd for subcmd in parser.choices.keys() if subcmd.startswith(cword_prefix)]
+        return completions
+
+    def _include_options(self, action, cword_prefix):
+        if len(cword_prefix) > 0 or self.always_complete_options is True:
+            return [ensure_str(opt) for opt in action.option_strings if ensure_str(opt).startswith(cword_prefix)]
+        long_opts = [ensure_str(opt) for opt in action.option_strings if len(opt) > 2]
+        short_opts = [ensure_str(opt) for opt in action.option_strings if len(opt) <= 2]
+        if self.always_complete_options == "long":
+            return long_opts if long_opts else short_opts
+        elif self.always_complete_options == "short":
+            return short_opts if short_opts else long_opts
+        return []
+
+    def _get_option_completions(self, parser, cword_prefix):
+        self._display_completions.update(
+            [[tuple(ensure_str(x) for x in action.option_strings
+             if ensure_str(x).startswith(cword_prefix)), action.help]
+             for action in parser._actions
+             if action.option_strings])
+
+        option_completions = []
+        for action in parser._actions:
+            if not self.print_suppressed:
+                completer = getattr(action, "completer", None)
+                if isinstance(completer, SuppressCompleter) and completer.suppress():
+                    continue
+                if action.help == argparse.SUPPRESS:
+                    continue
+            if not self._action_allowed(action, parser):
+                continue
+            if not isinstance(action, argparse._SubParsersAction):
+                option_completions += self._include_options(action, cword_prefix)
+        return option_completions
+
+    @staticmethod
+    def _action_allowed(action, parser):
+        # Logic adapted from take_action in ArgumentParser._parse_known_args
+        # (members are saved by my_argparse.IntrospectiveArgumentParser)
+        for conflict_action in parser._action_conflicts.get(action, []):
+            if conflict_action in parser._seen_non_default_actions:
+                return False
+        return True
+
+    def _complete_active_option(self, parser, next_positional, cword_prefix, parsed_args, completions):
+        debug("Active actions (L={l}): {a}".format(l=len(parser.active_actions), a=parser.active_actions))
+
+        isoptional = cword_prefix and cword_prefix[0] in parser.prefix_chars
+        optional_prefix = ""
+        greedy_actions = [x for x in parser.active_actions if action_is_greedy(x, isoptional)]
+        if greedy_actions:
+            assert len(greedy_actions) == 1, "expect at most 1 greedy action"
+            # This means the action will fail to parse if the word under the cursor is not given
+            # to it, so give it exclusive control over completions (flush previous completions)
+            debug("Resetting completions because", greedy_actions[0], "must consume the next argument")
+            self._display_completions = {}
+            completions = []
+        elif isoptional:
+            if "=" in cword_prefix:
+                # Special case for when the current word is "--optional=PARTIAL_VALUE".
+                # The completer runs on PARTIAL_VALUE. The prefix is added back to the completions
+                # (and chopped back off later in quote_completions() by the COMP_WORDBREAKS logic).
+                optional_prefix, _, cword_prefix = cword_prefix.partition("=")
+            else:
+                # Only run completers if current word does not start with - (is not an optional)
+                return completions
+
+        complete_remaining_positionals = False
+        # Use the single greedy action (if there is one) or all active actions.
+        for active_action in greedy_actions or parser.active_actions:
+            if not active_action.option_strings:  # action is a positional
+                if action_is_open(active_action):
+                    # Any positional arguments after this may slide down into this action
+                    # if more arguments are added (since the user may not be done yet),
+                    # so it is extremely difficult to tell which completers to run.
+                    # Running all remaining completers will probably show more than the user wants
+                    # but it also guarantees we won't miss anything.
+                    complete_remaining_positionals = True
+                if not complete_remaining_positionals:
+                    if action_is_satisfied(active_action) and not action_is_open(active_action):
+                        debug("Skipping", active_action)
+                        continue
+
+            debug("Activating completion for", active_action, active_action._orig_class)
+            # completer = getattr(active_action, "completer", DefaultCompleter())
+            completer = getattr(active_action, "completer", None)
+
+            if completer is None:
+                if active_action.choices is not None and not isinstance(active_action, argparse._SubParsersAction):
+                    completer = completers.ChoicesCompleter(active_action.choices)
+                elif not isinstance(active_action, argparse._SubParsersAction):
+                    completer = self.default_completer
+
+            if completer:
+                if isinstance(completer, SuppressCompleter) and completer.suppress():
+                    continue
+
+                if callable(completer):
+                    completions_from_callable = [c for c in completer(
+                        prefix=cword_prefix, action=active_action, parser=parser, parsed_args=parsed_args)
+                        if self.validator(c, cword_prefix)]
+
+                    if completions_from_callable:
+                        completions += completions_from_callable
+                        if isinstance(completer, completers.ChoicesCompleter):
+                            self._display_completions.update(
+                                [[(x,), active_action.help] for x in completions_from_callable])
+                        else:
+                            self._display_completions.update(
+                                [[(x,), ""] for x in completions_from_callable])
+                else:
+                    debug("Completer is not callable, trying the readline completer protocol instead")
+                    for i in range(9999):
+                        next_completion = completer.complete(cword_prefix, i)
+                        if next_completion is None:
+                            break
+                        if self.validator(next_completion, cword_prefix):
+                            self._display_completions.update({(next_completion,): ""})
+                            completions.append(next_completion)
+                if optional_prefix:
+                    completions = [optional_prefix + "=" + completion for completion in completions]
+                debug("Completions:", completions)
+        return completions
+
+    def collect_completions(self, active_parsers, parsed_args, cword_prefix, debug):
+        """
+        Visits the active parsers and their actions, executes their completers or introspects them to collect their
+        option strings. Returns the resulting completions as a list of strings.
+
+        This method is exposed for overriding in subclasses; there is no need to use it directly.
+        """
+        completions = []
+
+        debug("all active parsers:", active_parsers)
+        active_parser = active_parsers[-1]
+        debug("active_parser:", active_parser)
+        if self.always_complete_options or (len(cword_prefix) > 0 and cword_prefix[0] in active_parser.prefix_chars):
+            completions += self._get_option_completions(active_parser, cword_prefix)
+        debug("optional options:", completions)
+
+        next_positional = self._get_next_positional()
+        debug("next_positional:", next_positional)
+
+        if isinstance(next_positional, argparse._SubParsersAction):
+            completions += self._get_subparser_completions(next_positional, cword_prefix)
+
+        completions = self._complete_active_option(active_parser, next_positional, cword_prefix, parsed_args,
+                                                   completions)
+        debug("active options:", completions)
+        debug("display completions:", self._display_completions)
+
+        return completions
+
+    def _get_next_positional(self):
+        """
+        Get the next positional action if it exists.
+        """
+        active_parser = self.active_parsers[-1]
+        last_positional = self.visited_positionals[-1]
+
+        all_positionals = active_parser._get_positional_actions()
+        if not all_positionals:
+            return None
+
+        if active_parser == last_positional:
+            return all_positionals[0]
+
+        i = 0
+        for i in range(len(all_positionals)):
+            if all_positionals[i] == last_positional:
+                break
+
+        if i + 1 < len(all_positionals):
+            return all_positionals[i + 1]
+
+        return None
+
+    def filter_completions(self, completions):
+        """
+        Ensures collected completions are Unicode text, de-duplicates them, and excludes those specified by ``exclude``.
+        Returns the filtered completions as an iterable.
+
+        This method is exposed for overriding in subclasses; there is no need to use it directly.
+        """
+        # On Python 2, we have to make sure all completions are unicode objects before we continue and output them.
+        # Otherwise, because python disobeys the system locale encoding and uses ascii as the default encoding, it will
+        # try to implicitly decode string objects using ascii, and fail.
+        completions = [ensure_str(c) for c in completions]
+
+        # De-duplicate completions and remove excluded ones
+        if self.exclude is None:
+            self.exclude = set()
+        seen = set(self.exclude)
+        return [c for c in completions if c not in seen and not seen.add(c)]
+
+    def quote_completions(self, completions, cword_prequote, last_wordbreak_pos):
+        """
+        If the word under the cursor started with a quote (as indicated by a nonempty ``cword_prequote``), escapes
+        occurrences of that quote character in the completions, and adds the quote to the beginning of each completion.
+        Otherwise, escapes all characters that bash splits words on (``COMP_WORDBREAKS``), and removes portions of
+        completions before the first colon if (``COMP_WORDBREAKS``) contains a colon.
+
+        If there is only one completion, and it doesn't end with a **continuation character** (``/``, ``:``, or ``=``),
+        adds a space after the completion.
+
+        This method is exposed for overriding in subclasses; there is no need to use it directly.
+        """
+        special_chars = "\\"
+        # If the word under the cursor was quoted, escape the quote char.
+        # Otherwise, escape all special characters and specially handle all COMP_WORDBREAKS chars.
+        if cword_prequote == "":
+            # Bash mangles completions which contain characters in COMP_WORDBREAKS.
+            # This workaround has the same effect as __ltrim_colon_completions in bash_completion
+            # (extended to characters other than the colon).
+            if last_wordbreak_pos:
+                completions = [c[last_wordbreak_pos + 1:] for c in completions]
+            special_chars += "();<>|&!`$* \t\n\"'"
+        elif cword_prequote == '"':
+            special_chars += '"`$!'
+
+        if os.environ.get("_ARGCOMPLETE_SHELL") in ("tcsh", "fish"):
+            # tcsh and fish escapes special characters itself.
+            special_chars = ""
+        elif cword_prequote == "'":
+            # Nothing can be escaped in single quotes, so we need to close
+            # the string, escape the single quote, then open a new string.
+            special_chars = ""
+            completions = [c.replace("'", r"'\''") for c in completions]
+
+        for char in special_chars:
+            completions = [c.replace(char, "\\" + char) for c in completions]
+
+        if self.append_space:
+            # Similar functionality in bash was previously turned off by supplying the "-o nospace" option to complete.
+            # Now it is conditionally disabled using "compopt -o nospace" if the match ends in a continuation character.
+            # This code is retained for environments where this isn't done natively.
+            continuation_chars = "=/:"
+            if len(completions) == 1 and completions[0][-1] not in continuation_chars:
+                if cword_prequote == "":
+                    completions[0] += " "
+
+        return completions
+
+    def rl_complete(self, text, state):
+        """
+        Alternate entry point for using the argcomplete completer in a readline-based REPL. See also
+        `rlcompleter <https://docs.python.org/2/library/rlcompleter.html#completer-objects>`_.
+        Usage:
+
+        .. code-block:: python
+
+            import argcomplete, argparse, readline
+            parser = argparse.ArgumentParser()
+            ...
+            completer = argcomplete.CompletionFinder(parser)
+            readline.set_completer_delims("")
+            readline.set_completer(completer.rl_complete)
+            readline.parse_and_bind("tab: complete")
+            result = input("prompt> ")
+
+        (Use ``raw_input`` instead of ``input`` on Python 2, or use `eight <https://github.com/kislyuk/eight>`_).
+        """
+        if state == 0:
+            cword_prequote, cword_prefix, cword_suffix, comp_words, first_colon_pos = split_line(text)
+            comp_words.insert(0, sys.argv[0])
+            matches = self._get_completions(comp_words, cword_prefix, cword_prequote, first_colon_pos)
+            self._rl_matches = [text + match[len(cword_prefix):] for match in matches]
+
+        if state < len(self._rl_matches):
+            return self._rl_matches[state]
+        else:
+            return None
+
+    def get_display_completions(self):
+        """
+        This function returns a mapping of option names to their help strings for displaying to the user
+
+        Usage:
+
+        .. code-block:: python
+
+            def display_completions(substitution, matches, longest_match_length):
+                _display_completions = argcomplete.autocomplete.get_display_completions()
+                print("")
+                if _display_completions:
+                    help_len = [len(x) for x in _display_completions.values() if x]
+
+                    if help_len:
+                        maxlen = max([len(x) for x in _display_completions])
+                        print("\\n".join("{0:{2}} -- {1}".format(k, v, maxlen)
+                                        for k, v in sorted(_display_completions.items())))
+                    else:
+                        print("    ".join(k for k in sorted(_display_completions)))
+                else:
+                    print(" ".join(x for x in sorted(matches)))
+
+                import readline
+                print("cli /> {0}".format(readline.get_line_buffer()), end="")
+                readline.redisplay()
+
+            ...
+            readline.set_completion_display_matches_hook(display_completions)
+
+        """
+        return {" ".join(k): v for k, v in self._display_completions.items()}
+
+class ExclusiveCompletionFinder(CompletionFinder):
+    @staticmethod
+    def _action_allowed(action, parser):
+        if not CompletionFinder._action_allowed(action, parser):
+            return False
+
+        append_classes = (argparse._AppendAction, argparse._AppendConstAction)
+        if action._orig_class in append_classes:
+            return True
+
+        if action not in parser._seen_non_default_actions:
+            return True
+
+        return False
+
+autocomplete = CompletionFinder()
+autocomplete.__doc__ = """ Use this to access argcomplete. See :meth:`argcomplete.CompletionFinder.__call__()`. """
+
+def warn(*args):
+    """
+    Prints **args** to standard error when running completions. This will interrupt the user's command line interaction;
+    use it to indicate an error condition that is preventing your completer from working.
+    """
+    # Don't be tempted to use `print("\n",..., *args)`,
+    # as that will indent **args** by one space character
+    print(file=debug_stream)
+    print(file=debug_stream, *args)
diff --git a/contrib/python/argcomplete/py2/argcomplete/_check_console_script.py b/contrib/python/argcomplete/py2/argcomplete/_check_console_script.py
new file mode 100644
index 00000000000..fdfb88fa789
--- /dev/null
+++ b/contrib/python/argcomplete/py2/argcomplete/_check_console_script.py
@@ -0,0 +1,57 @@
+"""
+Utility for locating the module (or package's __init__.py)
+associated with a given console_script name
+and verifying it contains the PYTHON_ARGCOMPLETE_OK marker.
+
+Such scripts are automatically generated and cannot contain
+the marker themselves, so we defer to the containing module or package.
+
+For more information on setuptools console_scripts, see
+https://setuptools.readthedocs.io/en/latest/setuptools.html#automatic-script-creation
+
+Intended to be invoked by argcomplete's global completion function.
+"""
+import os
+import sys
+
+try:
+    from importlib.metadata import entry_points as importlib_entry_points
+except ImportError:
+    from importlib_metadata import entry_points as importlib_entry_points
+
+from ._check_module import ArgcompleteMarkerNotFound, find
+
+
+def main():
+    # Argument is the full path to the console script.
+    script_path = sys.argv[1]
+
+    # Find the module and function names that correspond to this
+    # assuming it is actually a console script.
+    name = os.path.basename(script_path)
+    entry_points = [ep for ep in importlib_entry_points()["console_scripts"] if ep.name == name]
+    if not entry_points:
+        raise ArgcompleteMarkerNotFound('no entry point found matching script')
+    entry_point = entry_points[0]
+    module_name, function_name = entry_point.value.split(":", 1)
+
+    # Check this looks like the script we really expected.
+    with open(script_path) as f:
+        script = f.read()
+    if 'from {} import {}'.format(module_name, function_name) not in script:
+        raise ArgcompleteMarkerNotFound('does not appear to be a console script')
+    if 'sys.exit({}())'.format(function_name) not in script:
+        raise ArgcompleteMarkerNotFound('does not appear to be a console script')
+
+    # Look for the argcomplete marker in the script it imports.
+    with open(find(module_name, return_package=True)) as f:
+        head = f.read(1024)
+    if 'PYTHON_ARGCOMPLETE_OK' not in head:
+        raise ArgcompleteMarkerNotFound('marker not found')
+
+
+if __name__ == '__main__':
+    try:
+        main()
+    except ArgcompleteMarkerNotFound as e:
+        sys.exit(e)
diff --git a/contrib/python/argcomplete/py2/argcomplete/_check_module.py b/contrib/python/argcomplete/py2/argcomplete/_check_module.py
new file mode 100644
index 00000000000..4f39d782f8b
--- /dev/null
+++ b/contrib/python/argcomplete/py2/argcomplete/_check_module.py
@@ -0,0 +1,92 @@
+"""
+Utility for locating a module (or package's __main__.py) with a given name
+and verifying it contains the PYTHON_ARGCOMPLETE_OK marker.
+
+The module name should be specified in a form usable with `python -m`.
+
+Intended to be invoked by argcomplete's global completion function.
+"""
+import os
+import sys
+import tokenize
+
+try:
+    from importlib.util import find_spec
+except ImportError:
+    from collections import namedtuple
+    from imp import find_module
+
+    ModuleSpec = namedtuple(
+        'ModuleSpec', ['origin', 'has_location', 'submodule_search_locations'])
+
+    def find_spec(name):
+        """Minimal implementation as required by `find`."""
+        try:
+            f, path, _ = find_module(name)
+        except ImportError:
+            return None
+        has_location = path is not None
+        if f is None:
+            return ModuleSpec(None, has_location, [path])
+        f.close()
+        return ModuleSpec(path, has_location, None)
+
+
+class ArgcompleteMarkerNotFound(RuntimeError):
+    pass
+
+
+def find(name, return_package=False):
+    names = name.split('.')
+    spec = find_spec(names[0])
+    if spec is None:
+        raise ArgcompleteMarkerNotFound(
+            'no module named "{}"'.format(names[0]))
+    if not spec.has_location:
+        raise ArgcompleteMarkerNotFound('cannot locate file')
+    if spec.submodule_search_locations is None:
+        if len(names) != 1:
+            raise ArgcompleteMarkerNotFound(
+                '{} is not a package'.format(names[0]))
+        return spec.origin
+    if len(spec.submodule_search_locations) != 1:
+        raise ArgcompleteMarkerNotFound('expecting one search location')
+    path = os.path.join(spec.submodule_search_locations[0], *names[1:])
+    if os.path.isdir(path):
+        filename = '__main__.py'
+        if return_package:
+            filename = '__init__.py'
+        return os.path.join(path, filename)
+    else:
+        return path + '.py'
+
+
+def main():
+    try:
+        name = sys.argv[1]
+    except IndexError:
+        raise ArgcompleteMarkerNotFound('missing argument on the command line')
+
+    filename = find(name)
+    if hasattr(tokenize, 'open'):
+        open_func = tokenize.open
+    else:
+        open_func = open
+
+    try:
+        fp = open_func(filename)
+    except OSError:
+        raise ArgcompleteMarkerNotFound('cannot open file')
+
+    with fp:
+        head = fp.read(1024)
+
+    if 'PYTHON_ARGCOMPLETE_OK' not in head:
+        raise ArgcompleteMarkerNotFound('marker not found')
+
+
+if __name__ == '__main__':
+    try:
+        main()
+    except ArgcompleteMarkerNotFound as e:
+        sys.exit(e)
diff --git a/contrib/python/argcomplete/py2/argcomplete/bash_completion.d/python-argcomplete b/contrib/python/argcomplete/py2/argcomplete/bash_completion.d/python-argcomplete
new file mode 100644
index 00000000000..c776992153d
--- /dev/null
+++ b/contrib/python/argcomplete/py2/argcomplete/bash_completion.d/python-argcomplete
@@ -0,0 +1,106 @@
+# Copyright 2012-2019, Andrey Kislyuk and argcomplete contributors.
+# Licensed under the Apache License. See https://github.com/kislyuk/argcomplete for more info.
+
+# Copy of __expand_tilde_by_ref from bash-completion
+__python_argcomplete_expand_tilde_by_ref () {
+    if [ "${!1:0:1}" = "~" ]; then
+        if [ "${!1}" != "${!1//\/}" ]; then
+            eval $1="${!1/%\/*}"/'${!1#*/}';
+        else
+            eval $1="${!1}";
+        fi;
+    fi
+}
+
+# Run something, muting output or redirecting it to the debug stream
+# depending on the value of _ARC_DEBUG.
+# If ARGCOMPLETE_USE_TEMPFILES is set, use tempfiles for IPC.
+__python_argcomplete_run() {
+    if [[ -z "${ARGCOMPLETE_USE_TEMPFILES-}" ]]; then
+        __python_argcomplete_run_inner "$@"
+        return
+    fi
+    local tmpfile="$(mktemp)"
+    _ARGCOMPLETE_STDOUT_FILENAME="$tmpfile" __python_argcomplete_run_inner "$@"
+    local code=$?
+    cat "$tmpfile"
+    rm "$tmpfile"
+    return $code
+}
+
+__python_argcomplete_run_inner() {
+    if [[ -z "${_ARC_DEBUG-}" ]]; then
+        "$@" 8>&1 9>&2 1>/dev/null 2>&1
+    else
+        "$@" 8>&1 9>&2 1>&9 2>&1
+    fi
+}
+
+# Scan the beginning of an executable file ($1) for a regexp ($2). By default,
+# scan for the magic string indicating that the executable supports the
+# argcomplete completion protocol. By default, scan the first kilobyte;
+# if $3 is set to -n, scan until the first line break up to a kilobyte.
+__python_argcomplete_scan_head() {
+    read -s -r ${3:--N} 1024 < "$1"
+    [[ "$REPLY" =~ ${2:-PYTHON_ARGCOMPLETE_OK} ]]
+}
+
+__python_argcomplete_scan_head_noerr() {
+    __python_argcomplete_scan_head "$@" 2>/dev/null
+}
+
+_python_argcomplete_global() {
+    local executable=$1
+    __python_argcomplete_expand_tilde_by_ref executable
+
+    local ARGCOMPLETE=0
+    if [[ "$executable" == python* ]] || [[ "$executable" == pypy* ]]; then
+        if [[ "${COMP_WORDS[1]}" == -m ]]; then
+            if __python_argcomplete_run "$executable" -m argcomplete._check_module "${COMP_WORDS[2]}"; then
+                ARGCOMPLETE=3
+            else
+                return
+            fi
+        elif [[ -f "${COMP_WORDS[1]}" ]] && __python_argcomplete_scan_head_noerr "${COMP_WORDS[1]}"; then
+            local ARGCOMPLETE=2
+        else
+            return
+        fi
+    elif type -P "$executable" >/dev/null 2>&1; then
+        local SCRIPT_NAME=$(type -P "$executable")
+        if (type -t pyenv && [[ "$SCRIPT_NAME" = $(pyenv root)/shims/* ]]) >/dev/null 2>&1; then
+            local SCRIPT_NAME=$(pyenv which "$executable")
+        fi
+        if __python_argcomplete_scan_head_noerr "$SCRIPT_NAME"; then
+            local ARGCOMPLETE=1
+        elif __python_argcomplete_scan_head_noerr "$SCRIPT_NAME" '^#!(.*)$' -n && [[ "${BASH_REMATCH[1]}" =~ ^.*(python|pypy)[0-9\.]*$ ]]; then
+            local interpreter="$BASH_REMATCH"
+            if (__python_argcomplete_scan_head_noerr "$SCRIPT_NAME" "(PBR Generated)|(EASY-INSTALL-(SCRIPT|ENTRY-SCRIPT|DEV-SCRIPT))" \
+                && "$interpreter" "$(type -P python-argcomplete-check-easy-install-script)" "$SCRIPT_NAME") >/dev/null 2>&1; then
+                local ARGCOMPLETE=1
+            elif __python_argcomplete_run "$interpreter" -m argcomplete._check_console_script "$SCRIPT_NAME"; then
+                local ARGCOMPLETE=1
+            fi
+        fi
+    fi
+
+    if [[ $ARGCOMPLETE != 0 ]]; then
+        local IFS=$(echo -e '\v')
+        COMPREPLY=( $(_ARGCOMPLETE_IFS="$IFS" \
+            COMP_LINE="$COMP_LINE" \
+            COMP_POINT="$COMP_POINT" \
+            COMP_TYPE="$COMP_TYPE" \
+            _ARGCOMPLETE_COMP_WORDBREAKS="$COMP_WORDBREAKS" \
+            _ARGCOMPLETE=$ARGCOMPLETE \
+            _ARGCOMPLETE_SUPPRESS_SPACE=1 \
+            __python_argcomplete_run "$executable" "${COMP_WORDS[@]:1:ARGCOMPLETE-1}") )
+        if [[ $? != 0 ]]; then
+            unset COMPREPLY
+        elif [[ "${COMPREPLY-}" =~ [=/:]$ ]]; then
+            compopt -o nospace
+        fi
+    else
+        type -t _completion_loader | grep -q 'function' && _completion_loader "$@"
+    fi
+}
+complete -o default -o bashdefault -D -F _python_argcomplete_global
diff --git a/contrib/python/argcomplete/py2/argcomplete/compat.py b/contrib/python/argcomplete/py2/argcomplete/compat.py
new file mode 100644
index 00000000000..36b1a6d2b68
--- /dev/null
+++ b/contrib/python/argcomplete/py2/argcomplete/compat.py
@@ -0,0 +1,25 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import locale
+import sys
+
+sys_encoding = locale.getpreferredencoding()
+
+USING_PYTHON2 = True if sys.version_info < (3, 0) else False
+
+if USING_PYTHON2:
+    str = unicode  # noqa
+else:
+    str = str
+
+
+def ensure_bytes(x, encoding=sys_encoding):
+    if not isinstance(x, bytes):
+        x = x.encode(encoding)
+    return x
+
+
+def ensure_str(x, encoding=sys_encoding):
+    if not isinstance(x, str):
+        x = x.decode(encoding)
+    return x
diff --git a/contrib/python/argcomplete/py2/argcomplete/completers.py b/contrib/python/argcomplete/py2/argcomplete/completers.py
new file mode 100644
index 00000000000..37520050248
--- /dev/null
+++ b/contrib/python/argcomplete/py2/argcomplete/completers.py
@@ -0,0 +1,108 @@
+# Copyright 2012-2019, Andrey Kislyuk and argcomplete contributors.
+# Licensed under the Apache License. See https://github.com/kislyuk/argcomplete for more info.
+
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import os
+import subprocess
+from .compat import str, sys_encoding
+
+def _call(*args, **kwargs):
+    try:
+        return subprocess.check_output(*args, **kwargs).decode(sys_encoding).splitlines()
+    except subprocess.CalledProcessError:
+        return []
+
+class ChoicesCompleter(object):
+    def __init__(self, choices):
+        self.choices = choices
+
+    def _convert(self, choice):
+        if isinstance(choice, bytes):
+            choice = choice.decode(sys_encoding)
+        if not isinstance(choice, str):
+            choice = str(choice)
+        return choice
+
+    def __call__(self, **kwargs):
+        return (self._convert(c) for c in self.choices)
+
+EnvironCompleter = ChoicesCompleter(os.environ)
+
+class FilesCompleter(object):
+    """
+    File completer class, optionally takes a list of allowed extensions
+    """
+
+    def __init__(self, allowednames=(), directories=True):
+        # Fix if someone passes in a string instead of a list
+        if isinstance(allowednames, (str, bytes)):
+            allowednames = [allowednames]
+
+        self.allowednames = [x.lstrip("*").lstrip(".") for x in allowednames]
+        self.directories = directories
+
+    def __call__(self, prefix, **kwargs):
+        completion = []
+        if self.allowednames:
+            if self.directories:
+                files = _call(["bash", "-c", "compgen -A directory -- '{p}'".format(p=prefix)])
+                completion += [f + "/" for f in files]
+            for x in self.allowednames:
+                completion += _call(["bash", "-c", "compgen -A file -X '!*.{0}' -- '{p}'".format(x, p=prefix)])
+        else:
+            completion += _call(["bash", "-c", "compgen -A file -- '{p}'".format(p=prefix)])
+            anticomp = _call(["bash", "-c", "compgen -A directory -- '{p}'".format(p=prefix)])
+            completion = list(set(completion) - set(anticomp))
+
+            if self.directories:
+                completion += [f + "/" for f in anticomp]
+        return completion
+
+class _FilteredFilesCompleter(object):
+    def __init__(self, predicate):
+        """
+        Create the completer
+
+        A predicate accepts as its only argument a candidate path and either
+        accepts it or rejects it.
+        """
+        assert predicate, "Expected a callable predicate"
+        self.predicate = predicate
+
+    def __call__(self, prefix, **kwargs):
+        """
+        Provide completions on prefix
+        """
+        target_dir = os.path.dirname(prefix)
+        try:
+            names = os.listdir(target_dir or ".")
+        except:
+            return  # empty iterator
+        incomplete_part = os.path.basename(prefix)
+        # Iterate on target_dir entries and filter on given predicate
+        for name in names:
+            if not name.startswith(incomplete_part):
+                continue
+            candidate = os.path.join(target_dir, name)
+            if not self.predicate(candidate):
+                continue
+            yield candidate + "/" if os.path.isdir(candidate) else candidate
+
+class DirectoriesCompleter(_FilteredFilesCompleter):
+    def __init__(self):
+        _FilteredFilesCompleter.__init__(self, predicate=os.path.isdir)
+
+class SuppressCompleter(object):
+    """
+    A completer used to suppress the completion of specific arguments
+    """
+
+    def __init__(self):
+        pass
+
+    def suppress(self):
+        """
+        Decide if the completion should be suppressed
+        """
+        return True
diff --git a/contrib/python/argcomplete/py2/argcomplete/my_argparse.py b/contrib/python/argcomplete/py2/argcomplete/my_argparse.py
new file mode 100644
index 00000000000..19bd24ce8d5
--- /dev/null
+++ b/contrib/python/argcomplete/py2/argcomplete/my_argparse.py
@@ -0,0 +1,331 @@
+# Copyright 2012-2019, Andrey Kislyuk and argcomplete contributors.
+# Licensed under the Apache License. See https://github.com/kislyuk/argcomplete for more info.
+
+from argparse import ArgumentParser, ArgumentError, SUPPRESS, _SubParsersAction
+from argparse import OPTIONAL, ZERO_OR_MORE, ONE_OR_MORE, REMAINDER, PARSER
+from argparse import _get_action_name, _
+
+_num_consumed_args = {}
+
+
+def action_is_satisfied(action):
+    ''' Returns False if the parse would raise an error if no more arguments are given to this action, True otherwise.
+    '''
+    num_consumed_args = _num_consumed_args.get(action, 0)
+
+    if action.nargs in [OPTIONAL, ZERO_OR_MORE, REMAINDER]:
+        return True
+    if action.nargs == ONE_OR_MORE:
+        return num_consumed_args >= 1
+    if action.nargs == PARSER:
+        # Not sure what this should be, but this previously always returned False
+        # so at least this won't break anything that wasn't already broken.
+        return False
+    if action.nargs is None:
+        return num_consumed_args == 1
+
+    assert isinstance(action.nargs, int), 'failed to handle a possible nargs value: %r' % action.nargs
+    return num_consumed_args == action.nargs
+
+
+def action_is_open(action):
+    ''' Returns True if action could consume more arguments (i.e., its pattern is open).
+    '''
+    num_consumed_args = _num_consumed_args.get(action, 0)
+
+    if action.nargs in [ZERO_OR_MORE, ONE_OR_MORE, PARSER, REMAINDER]:
+        return True
+    if action.nargs == OPTIONAL or action.nargs is None:
+        return num_consumed_args == 0
+
+    assert isinstance(action.nargs, int), 'failed to handle a possible nargs value: %r' % action.nargs
+    return num_consumed_args < action.nargs
+
+
+def action_is_greedy(action, isoptional=False):
+    ''' Returns True if action will necessarily consume the next argument.
+    isoptional indicates whether the argument is an optional (starts with -).
+    '''
+    num_consumed_args = _num_consumed_args.get(action, 0)
+
+    if action.option_strings:
+        if not isoptional and not action_is_satisfied(action):
+            return True
+        return action.nargs == REMAINDER
+    else:
+        return action.nargs == REMAINDER and num_consumed_args >= 1
+
+
+class IntrospectiveArgumentParser(ArgumentParser):
+    ''' The following is a verbatim copy of ArgumentParser._parse_known_args (Python 2.7.3),
+    except for the lines that contain the string "Added by argcomplete".
+    '''
+
+    def _parse_known_args(self, arg_strings, namespace):
+        _num_consumed_args.clear()  # Added by argcomplete
+        self._argcomplete_namespace = namespace
+        self.active_actions = []  # Added by argcomplete
+        # replace arg strings that are file references
+        if self.fromfile_prefix_chars is not None:
+            arg_strings = self._read_args_from_files(arg_strings)
+
+        # map all mutually exclusive arguments to the other arguments
+        # they can't occur with
+        action_conflicts = {}
+        self._action_conflicts = action_conflicts  # Added by argcomplete
+        for mutex_group in self._mutually_exclusive_groups:
+            group_actions = mutex_group._group_actions
+            for i, mutex_action in enumerate(mutex_group._group_actions):
+                conflicts = action_conflicts.setdefault(mutex_action, [])
+                conflicts.extend(group_actions[:i])
+                conflicts.extend(group_actions[i + 1:])
+
+        # find all option indices, and determine the arg_string_pattern
+        # which has an 'O' if there is an option at an index,
+        # an 'A' if there is an argument, or a '-' if there is a '--'
+        option_string_indices = {}
+        arg_string_pattern_parts = []
+        arg_strings_iter = iter(arg_strings)
+        for i, arg_string in enumerate(arg_strings_iter):
+
+            # all args after -- are non-options
+            if arg_string == '--':
+                arg_string_pattern_parts.append('-')
+                for arg_string in arg_strings_iter:
+                    arg_string_pattern_parts.append('A')
+
+            # otherwise, add the arg to the arg strings
+            # and note the index if it was an option
+            else:
+                option_tuple = self._parse_optional(arg_string)
+                if option_tuple is None:
+                    pattern = 'A'
+                else:
+                    option_string_indices[i] = option_tuple
+                    pattern = 'O'
+                arg_string_pattern_parts.append(pattern)
+
+        # join the pieces together to form the pattern
+        arg_strings_pattern = ''.join(arg_string_pattern_parts)
+
+        # converts arg strings to the appropriate and then takes the action
+        seen_actions = set()
+        seen_non_default_actions = set()
+        self._seen_non_default_actions = seen_non_default_actions  # Added by argcomplete
+
+        def take_action(action, argument_strings, option_string=None):
+            seen_actions.add(action)
+            argument_values = self._get_values(action, argument_strings)
+
+            # error if this argument is not allowed with other previously
+            # seen arguments, assuming that actions that use the default
+            # value don't really count as "present"
+            if argument_values is not action.default:
+                seen_non_default_actions.add(action)
+                for conflict_action in action_conflicts.get(action, []):
+                    if conflict_action in seen_non_default_actions:
+                        msg = _('not allowed with argument %s')
+                        action_name = _get_action_name(conflict_action)
+                        raise ArgumentError(action, msg % action_name)
+
+            # take the action if we didn't receive a SUPPRESS value
+            # (e.g. from a default)
+            if argument_values is not SUPPRESS \
+                    or isinstance(action, _SubParsersAction):
+                try:
+                    action(self, namespace, argument_values, option_string)
+                except:
+                    # Begin added by argcomplete
+                    # When a subparser action is taken and fails due to incomplete arguments, it does not merge the
+                    # contents of its parsed namespace into the parent namespace. Do that here to allow completers to
+                    # access the partially parsed arguments for the subparser.
+                    if isinstance(action, _SubParsersAction):
+                        subnamespace = action._name_parser_map[argument_values[0]]._argcomplete_namespace
+                        for key, value in vars(subnamespace).items():
+                            setattr(namespace, key, value)
+                    # End added by argcomplete
+                    raise
+
+        # function to convert arg_strings into an optional action
+        def consume_optional(start_index):
+
+            # get the optional identified at this index
+            option_tuple = option_string_indices[start_index]
+            action, option_string, explicit_arg = option_tuple
+
+            # identify additional optionals in the same arg string
+            # (e.g. -xyz is the same as -x -y -z if no args are required)
+            match_argument = self._match_argument
+            action_tuples = []
+            while True:
+
+                # if we found no optional action, skip it
+                if action is None:
+                    extras.append(arg_strings[start_index])
+                    return start_index + 1
+
+                # if there is an explicit argument, try to match the
+                # optional's string arguments to only this
+                if explicit_arg is not None:
+                    arg_count = match_argument(action, 'A')
+
+                    # if the action is a single-dash option and takes no
+                    # arguments, try to parse more single-dash options out
+                    # of the tail of the option string
+                    chars = self.prefix_chars
+                    if arg_count == 0 and option_string[1] not in chars:
+                        action_tuples.append((action, [], option_string))
+                        char = option_string[0]
+                        option_string = char + explicit_arg[0]
+                        new_explicit_arg = explicit_arg[1:] or None
+                        optionals_map = self._option_string_actions
+                        if option_string in optionals_map:
+                            action = optionals_map[option_string]
+                            explicit_arg = new_explicit_arg
+                        else:
+                            msg = _('ignored explicit argument %r')
+                            raise ArgumentError(action, msg % explicit_arg)
+
+                    # if the action expect exactly one argument, we've
+                    # successfully matched the option; exit the loop
+                    elif arg_count == 1:
+                        stop = start_index + 1
+                        args = [explicit_arg]
+                        action_tuples.append((action, args, option_string))
+                        break
+
+                    # error if a double-dash option did not use the
+                    # explicit argument
+                    else:
+                        msg = _('ignored explicit argument %r')
+                        raise ArgumentError(action, msg % explicit_arg)
+
+                # if there is no explicit argument, try to match the
+                # optional's string arguments with the following strings
+                # if successful, exit the loop
+                else:
+                    start = start_index + 1
+                    selected_patterns = arg_strings_pattern[start:]
+                    self.active_actions = [action]  # Added by argcomplete
+                    _num_consumed_args[action] = 0  # Added by argcomplete
+                    arg_count = match_argument(action, selected_patterns)
+                    stop = start + arg_count
+                    args = arg_strings[start:stop]
+
+                    # Begin added by argcomplete
+                    # If the pattern is not open (e.g. no + at the end), remove the action from active actions (since
+                    # it wouldn't be able to consume any more args)
+                    _num_consumed_args[action] = len(args)
+                    if not action_is_open(action):
+                        self.active_actions.remove(action)
+                    # End added by argcomplete
+
+                    action_tuples.append((action, args, option_string))
+                    break
+
+            # add the Optional to the list and return the index at which
+            # the Optional's string args stopped
+            assert action_tuples
+            for action, args, option_string in action_tuples:
+                take_action(action, args, option_string)
+            return stop
+
+        # the list of Positionals left to be parsed; this is modified
+        # by consume_positionals()
+        positionals = self._get_positional_actions()
+
+        # function to convert arg_strings into positional actions
+        def consume_positionals(start_index):
+            # match as many Positionals as possible
+            match_partial = self._match_arguments_partial
+            selected_pattern = arg_strings_pattern[start_index:]
+            arg_counts = match_partial(positionals, selected_pattern)
+
+            # slice off the appropriate arg strings for each Positional
+            # and add the Positional and its args to the list
+            for action, arg_count in zip(positionals, arg_counts):  # Added by argcomplete
+                self.active_actions.append(action)  # Added by argcomplete
+            for action, arg_count in zip(positionals, arg_counts):
+                args = arg_strings[start_index: start_index + arg_count]
+                start_index += arg_count
+                _num_consumed_args[action] = len(args)   # Added by argcomplete
+                take_action(action, args)
+
+            # slice off the Positionals that we just parsed and return the
+            # index at which the Positionals' string args stopped
+            positionals[:] = positionals[len(arg_counts):]
+            return start_index
+
+        # consume Positionals and Optionals alternately, until we have
+        # passed the last option string
+        extras = []
+        start_index = 0
+        if option_string_indices:
+            max_option_string_index = max(option_string_indices)
+        else:
+            max_option_string_index = -1
+        while start_index <= max_option_string_index:
+
+            # consume any Positionals preceding the next option
+            next_option_string_index = min([
+                index
+                for index in option_string_indices
+                if index >= start_index])
+            if start_index != next_option_string_index:
+                positionals_end_index = consume_positionals(start_index)
+
+                # only try to parse the next optional if we didn't consume
+                # the option string during the positionals parsing
+                if positionals_end_index > start_index:
+                    start_index = positionals_end_index
+                    continue
+                else:
+                    start_index = positionals_end_index
+
+            # if we consumed all the positionals we could and we're not
+            # at the index of an option string, there were extra arguments
+            if start_index not in option_string_indices:
+                strings = arg_strings[start_index:next_option_string_index]
+                extras.extend(strings)
+                start_index = next_option_string_index
+
+            # consume the next optional and any arguments for it
+            start_index = consume_optional(start_index)
+
+        # consume any positionals following the last Optional
+        stop_index = consume_positionals(start_index)
+
+        # if we didn't consume all the argument strings, there were extras
+        extras.extend(arg_strings[stop_index:])
+
+        # if we didn't use all the Positional objects, there were too few
+        # arg strings supplied.
+
+        if positionals:
+            self.active_actions.append(positionals[0])  # Added by argcomplete
+            self.error(_('too few arguments'))
+
+        # make sure all required actions were present
+        for action in self._actions:
+            if action.required:
+                if action not in seen_actions:
+                    name = _get_action_name(action)
+                    self.error(_('argument %s is required') % name)
+
+        # make sure all required groups had one option present
+        for group in self._mutually_exclusive_groups:
+            if group.required:
+                for action in group._group_actions:
+                    if action in seen_non_default_actions:
+                        break
+
+                # if no actions were used, report the error
+                else:
+                    names = [_get_action_name(action)
+                             for action in group._group_actions
+                             if action.help is not SUPPRESS]
+                    msg = _('one of the arguments %s is required')
+                    self.error(msg % ' '.join(names))
+
+        # return the updated namespace and the extra arguments
+        return namespace, extras
diff --git a/contrib/python/argcomplete/py2/argcomplete/my_shlex.py b/contrib/python/argcomplete/py2/argcomplete/my_shlex.py
new file mode 100644
index 00000000000..9cf26e47175
--- /dev/null
+++ b/contrib/python/argcomplete/py2/argcomplete/my_shlex.py
@@ -0,0 +1,328 @@
+# -*- coding: utf-8 -*-
+
+# This copy of shlex.py from Python 3.6 is distributed with argcomplete.
+# It contains only the shlex class, with modifications as noted.
+
+"""A lexical analyzer class for simple shell-like syntaxes."""
+
+# Module and documentation by Eric S. Raymond, 21 Dec 1998
+# Input stacking and error message cleanup added by ESR, March 2000
+# push_source() and pop_source() made explicit by ESR, January 2001.
+# Posix compliance, split(), string arguments, and
+# iterator interface by Gustavo Niemeyer, April 2003.
+# changes to tokenize more like Posix shells by Vinay Sajip, July 2016.
+
+import os
+import sys
+from collections import deque
+
+# Modified by argcomplete: 2/3 compatibility
+# Note: cStringIO is not compatible with Unicode
+try:
+    from StringIO import StringIO
+except ImportError:
+    from io import StringIO
+
+# Modified by argcomplete: 2/3 compatibility
+try:
+    basestring
+except NameError:
+    basestring = str
+
+class shlex:
+    "A lexical analyzer class for simple shell-like syntaxes."
+    def __init__(self, instream=None, infile=None, posix=False,
+                 punctuation_chars=False):
+        # Modified by argcomplete: 2/3 compatibility
+        if isinstance(instream, basestring):
+            instream = StringIO(instream)
+        if instream is not None:
+            self.instream = instream
+            self.infile = infile
+        else:
+            self.instream = sys.stdin
+            self.infile = None
+        self.posix = posix
+        if posix:
+            self.eof = None
+        else:
+            self.eof = ''
+        self.commenters = '#'
+        self.wordchars = ('abcdfeghijklmnopqrstuvwxyz'
+                          'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_')
+        # Modified by argcomplete: 2/3 compatibility
+        # if self.posix:
+        #     self.wordchars += ('ßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ'
+        #                        'ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ')
+        self.whitespace = ' \t\r\n'
+        self.whitespace_split = False
+        self.quotes = '\'"'
+        self.escape = '\\'
+        self.escapedquotes = '"'
+        self.state = ' '
+        self.pushback = deque()
+        self.lineno = 1
+        self.debug = 0
+        self.token = ''
+        self.filestack = deque()
+        self.source = None
+        if not punctuation_chars:
+            punctuation_chars = ''
+        elif punctuation_chars is True:
+            punctuation_chars = '();<>|&'
+        self.punctuation_chars = punctuation_chars
+        if punctuation_chars:
+            # _pushback_chars is a push back queue used by lookahead logic
+            self._pushback_chars = deque()
+            # these chars added because allowed in file names, args, wildcards
+            self.wordchars += '~-./*?='
+            #remove any punctuation chars from wordchars
+            t = self.wordchars.maketrans(dict.fromkeys(punctuation_chars))
+            self.wordchars = self.wordchars.translate(t)
+
+        # Modified by argcomplete: Record last wordbreak position
+        self.last_wordbreak_pos = None
+        self.wordbreaks = ''
+
+    def push_token(self, tok):
+        "Push a token onto the stack popped by the get_token method"
+        if self.debug >= 1:
+            print("shlex: pushing token " + repr(tok))
+        self.pushback.appendleft(tok)
+
+    def push_source(self, newstream, newfile=None):
+        "Push an input source onto the lexer's input source stack."
+        # Modified by argcomplete: 2/3 compatibility
+        if isinstance(newstream, basestring):
+            newstream = StringIO(newstream)
+        self.filestack.appendleft((self.infile, self.instream, self.lineno))
+        self.infile = newfile
+        self.instream = newstream
+        self.lineno = 1
+        if self.debug:
+            if newfile is not None:
+                print('shlex: pushing to file %s' % (self.infile,))
+            else:
+                print('shlex: pushing to stream %s' % (self.instream,))
+
+    def pop_source(self):
+        "Pop the input source stack."
+        self.instream.close()
+        (self.infile, self.instream, self.lineno) = self.filestack.popleft()
+        if self.debug:
+            print('shlex: popping to %s, line %d' \
+                  % (self.instream, self.lineno))
+        self.state = ' '
+
+    def get_token(self):
+        "Get a token from the input stream (or from stack if it's nonempty)"
+        if self.pushback:
+            tok = self.pushback.popleft()
+            if self.debug >= 1:
+                print("shlex: popping token " + repr(tok))
+            return tok
+        # No pushback.  Get a token.
+        raw = self.read_token()
+        # Handle inclusions
+        if self.source is not None:
+            while raw == self.source:
+                spec = self.sourcehook(self.read_token())
+                if spec:
+                    (newfile, newstream) = spec
+                    self.push_source(newstream, newfile)
+                raw = self.get_token()
+        # Maybe we got EOF instead?
+        while raw == self.eof:
+            if not self.filestack:
+                return self.eof
+            else:
+                self.pop_source()
+                raw = self.get_token()
+        # Neither inclusion nor EOF
+        if self.debug >= 1:
+            if raw != self.eof:
+                print("shlex: token=" + repr(raw))
+            else:
+                print("shlex: token=EOF")
+        return raw
+
+    def read_token(self):
+        quoted = False
+        escapedstate = ' '
+        while True:
+            if self.punctuation_chars and self._pushback_chars:
+                nextchar = self._pushback_chars.pop()
+            else:
+                nextchar = self.instream.read(1)
+            if nextchar == '\n':
+                self.lineno += 1
+            if self.debug >= 3:
+                print("shlex: in state %r I see character: %r" % (self.state,
+                                                                  nextchar))
+            if self.state is None:
+                self.token = ''        # past end of file
+                break
+            elif self.state == ' ':
+                if not nextchar:
+                    self.state = None  # end of file
+                    break
+                elif nextchar in self.whitespace:
+                    if self.debug >= 2:
+                        print("shlex: I see whitespace in whitespace state")
+                    if self.token or (self.posix and quoted):
+                        break   # emit current token
+                    else:
+                        continue
+                elif nextchar in self.commenters:
+                    self.instream.readline()
+                    self.lineno += 1
+                elif self.posix and nextchar in self.escape:
+                    escapedstate = 'a'
+                    self.state = nextchar
+                elif nextchar in self.wordchars:
+                    self.token = nextchar
+                    self.state = 'a'
+                elif nextchar in self.punctuation_chars:
+                    self.token = nextchar
+                    self.state = 'c'
+                elif nextchar in self.quotes:
+                    if not self.posix:
+                        self.token = nextchar
+                    self.state = nextchar
+                elif self.whitespace_split:
+                    self.token = nextchar
+                    self.state = 'a'
+                else:
+                    self.token = nextchar
+                    if self.token or (self.posix and quoted):
+                        break   # emit current token
+                    else:
+                        continue
+            elif self.state in self.quotes:
+                quoted = True
+                if not nextchar:      # end of file
+                    if self.debug >= 2:
+                        print("shlex: I see EOF in quotes state")
+                    # XXX what error should be raised here?
+                    raise ValueError("No closing quotation")
+                if nextchar == self.state:
+                    if not self.posix:
+                        self.token += nextchar
+                        self.state = ' '
+                        break
+                    else:
+                        self.state = 'a'
+                elif (self.posix and nextchar in self.escape and self.state
+                      in self.escapedquotes):
+                    escapedstate = self.state
+                    self.state = nextchar
+                else:
+                    self.token += nextchar
+            elif self.state in self.escape:
+                if not nextchar:      # end of file
+                    if self.debug >= 2:
+                        print("shlex: I see EOF in escape state")
+                    # XXX what error should be raised here?
+                    raise ValueError("No escaped character")
+                # In posix shells, only the quote itself or the escape
+                # character may be escaped within quotes.
+                if (escapedstate in self.quotes and
+                        nextchar != self.state and nextchar != escapedstate):
+                    self.token += self.state
+                self.token += nextchar
+                self.state = escapedstate
+            elif self.state in ('a', 'c'):
+                if not nextchar:
+                    self.state = None   # end of file
+                    break
+                elif nextchar in self.whitespace:
+                    if self.debug >= 2:
+                        print("shlex: I see whitespace in word state")
+                    self.state = ' '
+                    if self.token or (self.posix and quoted):
+                        break   # emit current token
+                    else:
+                        continue
+                elif nextchar in self.commenters:
+                    self.instream.readline()
+                    self.lineno += 1
+                    if self.posix:
+                        self.state = ' '
+                        if self.token or (self.posix and quoted):
+                            break   # emit current token
+                        else:
+                            continue
+                elif self.posix and nextchar in self.quotes:
+                    self.state = nextchar
+                elif self.posix and nextchar in self.escape:
+                    escapedstate = 'a'
+                    self.state = nextchar
+                elif self.state == 'c':
+                    if nextchar in self.punctuation_chars:
+                        self.token += nextchar
+                    else:
+                        if nextchar not in self.whitespace:
+                            self._pushback_chars.append(nextchar)
+                        self.state = ' '
+                        break
+                elif (nextchar in self.wordchars or nextchar in self.quotes
+                      or self.whitespace_split):
+                    self.token += nextchar
+                    # Modified by argcomplete: Record last wordbreak position
+                    if nextchar in self.wordbreaks:
+                        self.last_wordbreak_pos = len(self.token) - 1
+                else:
+                    if self.punctuation_chars:
+                        self._pushback_chars.append(nextchar)
+                    else:
+                        self.pushback.appendleft(nextchar)
+                    if self.debug >= 2:
+                        print("shlex: I see punctuation in word state")
+                    self.state = ' '
+                    if self.token or (self.posix and quoted):
+                        break   # emit current token
+                    else:
+                        continue
+        result = self.token
+        self.token = ''
+        if self.posix and not quoted and result == '':
+            result = None
+        if self.debug > 1:
+            if result:
+                print("shlex: raw token=" + repr(result))
+            else:
+                print("shlex: raw token=EOF")
+        # Modified by argcomplete: Record last wordbreak position
+        if self.state == ' ':
+            self.last_wordbreak_pos = None
+        return result
+
+    def sourcehook(self, newfile):
+        "Hook called on a filename to be sourced."
+        if newfile[0] == '"':
+            newfile = newfile[1:-1]
+        # This implements cpp-like semantics for relative-path inclusion.
+        # Modified by argcomplete: 2/3 compatibility
+        if isinstance(self.infile, basestring) and not os.path.isabs(newfile):
+            newfile = os.path.join(os.path.dirname(self.infile), newfile)
+        return (newfile, open(newfile, "r"))
+
+    def error_leader(self, infile=None, lineno=None):
+        "Emit a C-compiler-like, Emacs-friendly error-message leader."
+        if infile is None:
+            infile = self.infile
+        if lineno is None:
+            lineno = self.lineno
+        return "\"%s\", line %d: " % (infile, lineno)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        token = self.get_token()
+        if token == self.eof:
+            raise StopIteration
+        return token
+
+    # Modified by argcomplete: 2/3 compatibility
+    next = __next__
diff --git a/contrib/python/argcomplete/py2/argcomplete/shell_integration.py b/contrib/python/argcomplete/py2/argcomplete/shell_integration.py
new file mode 100644
index 00000000000..f068ff9eda6
--- /dev/null
+++ b/contrib/python/argcomplete/py2/argcomplete/shell_integration.py
@@ -0,0 +1,121 @@
+#!/usr/bin/env python
+
+try:
+    from shlex import quote
+except ImportError:
+    from pipes import quote
+
+bashcode = r'''
+# Run something, muting output or redirecting it to the debug stream
+# depending on the value of _ARC_DEBUG.
+# If ARGCOMPLETE_USE_TEMPFILES is set, use tempfiles for IPC.
+__python_argcomplete_run() {
+    if [[ -z "${ARGCOMPLETE_USE_TEMPFILES-}" ]]; then
+        __python_argcomplete_run_inner "$@"
+        return
+    fi
+    local tmpfile="$(mktemp)"
+    _ARGCOMPLETE_STDOUT_FILENAME="$tmpfile" __python_argcomplete_run_inner "$@"
+    local code=$?
+    cat "$tmpfile"
+    rm "$tmpfile"
+    return $code
+}
+
+__python_argcomplete_run_inner() {
+    if [[ -z "${_ARC_DEBUG-}" ]]; then
+        "$@" 8>&1 9>&2 1>/dev/null 2>&1
+    else
+        "$@" 8>&1 9>&2 1>&9 2>&1
+    fi
+}
+
+_python_argcomplete%(function_suffix)s() {
+    local IFS=$'\013'
+    local SUPPRESS_SPACE=0
+    if compopt +o nospace 2> /dev/null; then
+        SUPPRESS_SPACE=1
+    fi
+    COMPREPLY=( $(IFS="$IFS" \
+                  COMP_LINE="$COMP_LINE" \
+                  COMP_POINT="$COMP_POINT" \
+                  COMP_TYPE="$COMP_TYPE" \
+                  _ARGCOMPLETE_COMP_WORDBREAKS="$COMP_WORDBREAKS" \
+                  _ARGCOMPLETE=1 \
+                  _ARGCOMPLETE_SUPPRESS_SPACE=$SUPPRESS_SPACE \
+                  __python_argcomplete_run "%(argcomplete_script)s") )
+    if [[ $? != 0 ]]; then
+        unset COMPREPLY
+    elif [[ $SUPPRESS_SPACE == 1 ]] && [[ "${COMPREPLY-}" =~ [=/:]$ ]]; then
+        compopt -o nospace
+    fi
+}
+complete %(complete_opts)s -F _python_argcomplete%(function_suffix)s %(executables)s
+'''
+
+tcshcode = '''\
+complete "%(executable)s" 'p@*@`python-argcomplete-tcsh "%(argcomplete_script)s"`@' ;
+'''
+
+fishcode = r'''
+function __fish_%(executable)s_complete
+    set -x _ARGCOMPLETE 1
+    set -x _ARGCOMPLETE_DFS \t
+    set -x _ARGCOMPLETE_IFS \n
+    set -x _ARGCOMPLETE_SUPPRESS_SPACE 1
+    set -x _ARGCOMPLETE_SHELL fish
+    set -x COMP_LINE (commandline -p)
+    set -x COMP_POINT (string length (commandline -cp))
+    set -x COMP_TYPE
+    if set -q _ARC_DEBUG
+        %(argcomplete_script)s 8>&1 9>&2 1>&9 2>&1
+    else
+        %(argcomplete_script)s 8>&1 9>&2 1>/dev/null 2>&1
+    end
+end
+complete -c %(executable)s -f -a '(__fish_%(executable)s_complete)'
+'''
+
+shell_codes = {'bash': bashcode, 'tcsh': tcshcode, 'fish': fishcode}
+
+
+def shellcode(executables, use_defaults=True, shell='bash', complete_arguments=None, argcomplete_script=None):
+    '''
+    Provide the shell code required to register a python executable for use with the argcomplete module.
+
+    :param list(str) executables: Executables to be completed (when invoked exactly with this name)
+    :param bool use_defaults: Whether to fallback to readline's default completion when no matches are generated.
+    :param str shell: Name of the shell to output code for (bash or tcsh)
+    :param complete_arguments: Arguments to call complete with
+    :type complete_arguments: list(str) or None
+    :param argcomplete_script: Script to call complete with, if not the executable to complete.
+        If supplied, will be used to complete *all* passed executables.
+    :type argcomplete_script: str or None
+    '''
+
+    if complete_arguments is None:
+        complete_options = '-o nospace -o default -o bashdefault' if use_defaults else '-o nospace -o bashdefault'
+    else:
+        complete_options = " ".join(complete_arguments)
+
+    if shell == 'bash':
+        quoted_executables = [quote(i) for i in executables]
+        executables_list = " ".join(quoted_executables)
+        script = argcomplete_script
+        if script:
+            function_suffix = '_' + script
+        else:
+            script = '$1'
+            function_suffix = ''
+        code = bashcode % dict(complete_opts=complete_options, executables=executables_list,
+                               argcomplete_script=script, function_suffix=function_suffix)
+    else:
+        code = ""
+        for executable in executables:
+            script = argcomplete_script
+            # If no script was specified, default to the executable being completed.
+            if not script:
+                script = executable
+            code += shell_codes.get(shell, '') % dict(executable=executable, argcomplete_script=script)
+
+    return code
diff --git a/contrib/python/argcomplete/py2/ya.make b/contrib/python/argcomplete/py2/ya.make
new file mode 100644
index 00000000000..2900c4d98c8
--- /dev/null
+++ b/contrib/python/argcomplete/py2/ya.make
@@ -0,0 +1,36 @@
+# Generated by devtools/yamaker (pypi).
+
+PY2_LIBRARY()
+
+SUBSCRIBER(g:python-contrib)
+
+VERSION(1.12.3)
+
+LICENSE(Apache-2.0)
+
+PEERDIR(
+    contrib/python/importlib-metadata
+)
+
+NO_LINT()
+
+PY_SRCS(
+    TOP_LEVEL
+    argcomplete/__init__.py
+    argcomplete/_check_console_script.py
+    argcomplete/_check_module.py
+    argcomplete/compat.py
+    argcomplete/completers.py
+    argcomplete/my_argparse.py
+    argcomplete/my_shlex.py
+    argcomplete/shell_integration.py
+)
+
+RESOURCE_FILES(
+    PREFIX contrib/python/argcomplete/py2/
+    .dist-info/METADATA
+    .dist-info/top_level.txt
+    argcomplete/bash_completion.d/python-argcomplete
+)
+
+END()
-- 
cgit v1.3