argcomplete 3.6.2__tar.gz → 3.7.0__tar.gz

{argcomplete-3.6.2 → argcomplete-3.7.0}/.github/workflows/ci.yml

@@ -3,17 +3,17 @@ name: Python package
 on: [push, pull_request]
 
 jobs:
-  build:
+  ci:
     runs-on: ${{matrix.os}}
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-20.04, ubuntu-latest, macos-13, macos-latest]
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
+        os: [ubuntu-22.04, ubuntu-latest, macos-14, macos-latest]
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13", "3.14", "3.15"]
 
     steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-python@v4
+    - uses: actions/checkout@v7
+    - uses: actions/setup-python@v6
       with:
         python-version: ${{matrix.python-version}}
         allow-prereleases: true
@@ -31,15 +31,15 @@ jobs:
     - uses: codecov/codecov-action@v5
       if: ${{matrix.python-version == '3.12' && matrix.os == 'ubuntu-22.04'}}
   isort:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
       - uses: isort/isort-action@v1.1.0
   ruff:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: astral-sh/ruff-action@v1
-      - uses: astral-sh/ruff-action@v1
+      - uses: actions/checkout@v7
+      - uses: astral-sh/ruff-action@v4.0.0
+      - uses: astral-sh/ruff-action@v4.0.0
         with:
           args: "format --check"

{argcomplete-3.6.2 → argcomplete-3.7.0}/Changes.rst

@@ -1,3 +1,23 @@
+Changes for v3.7.0 (2026-06-30)
+===============================
+
+-  Escape glob and brace metacharacters in quote_completions (#552)
+-  Quote prefix passed to compgen in FilesCompleter (#551)
+-  Remove deprecated easy_install script detection
+-  Type hinting improvements
+
+Changes for v3.6.3 (2025-10-19)
+===============================
+
+- Make RE PCRE compatible. Fixes #539
+
+- Only execute Python interpreters (#536)
+
+- fish: set variable scope to local to avoid clobbering global or
+  universal variables (#534)
+
+- Documentation and help improvements
+
 Changes for v3.6.2 (2025-04-02)
 ===============================
 

{argcomplete-3.6.2 → argcomplete-3.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: argcomplete
-Version: 3.6.2
+Version: 3.7.0
 Summary: Bash tab completion for argparse
 Project-URL: Homepage, https://github.com/kislyuk/argcomplete
 Project-URL: Documentation, https://kislyuk.github.io/argcomplete
@@ -22,12 +22,12 @@ Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: POSIX
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Software Development
@@ -51,7 +51,7 @@ Argcomplete provides easy, extensible command line tab completion of arguments f
 
 It makes two assumptions:
 
-* You're using bash or zsh as your shell
+* You're using bash or zsh as your shell (limited support exists for other shells - see below)
 * 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

{argcomplete-3.6.2 → argcomplete-3.7.0}/README.rst

@@ -6,7 +6,7 @@ Argcomplete provides easy, extensible command line tab completion of arguments f
 
 It makes two assumptions:
 
-* You're using bash or zsh as your shell
+* You're using bash or zsh as your shell (limited support exists for other shells - see below)
 * 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

{argcomplete-3.6.2 → argcomplete-3.7.0}/argcomplete/bash_completion.d/_python-argcomplete

@@ -190,10 +190,8 @@ _python_argcomplete_global() {
                 interpreter=($interpreter)
             fi
 
-            if (__python_argcomplete_scan_head_noerr "$SCRIPT_NAME" easy_install \
-                && "${interpreter[@]}" "$(__python_argcomplete_which python-argcomplete-check-easy-install-script)" "$SCRIPT_NAME") >/dev/null 2>&1; then
-                ARGCOMPLETE=1
-            elif __python_argcomplete_run "${interpreter[@]}" -m argcomplete._check_console_script "$SCRIPT_NAME"; then
+            if ([[ "${interpreter[@]}" == *python* ]] || [[ "${interpreter[@]}" == *pypy* ]])\
+                && __python_argcomplete_run "${interpreter[@]}" -m argcomplete._check_console_script "$SCRIPT_NAME"; then
                 ARGCOMPLETE=1
             fi
         fi
@@ -215,7 +213,7 @@ _python_argcomplete_global() {
             if is-at-least 5.8; then
                 nosort=(-o nosort)
             fi
-            if [[ "${completions-}" =~ ([^\\]): && "${BASH_REMATCH[2]}" =~ [=/:] ]]; then
+            if [[ "${completions-}" =~ ([^\\\\]): && "${BASH_REMATCH[2]}" =~ [=/:] ]]; then
                 nospace=(-S '')
             fi
             _describe "$executable" completions "${nosort[@]}" "${nospace[@]}"

{argcomplete-3.6.2 → argcomplete-3.7.0}/argcomplete/completers.py

@@ -4,6 +4,7 @@
 import argparse
 import os
 import subprocess
+from shlex import quote
 
 
 def _call(*args, **kwargs):
@@ -64,20 +65,22 @@ class FilesCompleter(BaseCompleter):
                 # correctly in older versions and calling bind makes them available. For details, see
                 # https://savannah.gnu.org/support/index.php?111125
                 files = _call(
-                    ["bash", "-c", "bind; compgen -A directory -- '{p}'".format(p=prefix)], stderr=subprocess.DEVNULL
+                    ["bash", "-c", "bind; compgen -A directory -- {p}".format(p=quote(prefix))],
+                    stderr=subprocess.DEVNULL,
                 )
                 completion += [f + "/" for f in files]
             for x in self.allowednames:
                 completion += _call(
-                    ["bash", "-c", "bind; compgen -A file -X '!*.{0}' -- '{p}'".format(x, p=prefix)],
+                    ["bash", "-c", "bind; compgen -A file -X '!*.{0}' -- {p}".format(x, p=quote(prefix))],
                     stderr=subprocess.DEVNULL,
                 )
         else:
             completion += _call(
-                ["bash", "-c", "bind; compgen -A file -- '{p}'".format(p=prefix)], stderr=subprocess.DEVNULL
+                ["bash", "-c", "bind; compgen -A file -- {p}".format(p=quote(prefix))], stderr=subprocess.DEVNULL
             )
             anticomp = _call(
-                ["bash", "-c", "bind; compgen -A directory -- '{p}'".format(p=prefix)], stderr=subprocess.DEVNULL
+                ["bash", "-c", "bind; compgen -A directory -- {p}".format(p=quote(prefix))],
+                stderr=subprocess.DEVNULL,
             )
             completion = list(set(completion) - set(anticomp))
 

{argcomplete-3.6.2 → argcomplete-3.7.0}/argcomplete/finders.py

@@ -48,6 +48,7 @@ class CompletionFinder(object):
         append_space=None,
     ):
         self._parser = argument_parser
+        self._formatter = None
         self.always_complete_options = always_complete_options
         self.exclude = exclude
         if validator is None:
@@ -283,6 +284,15 @@ class CompletionFinder(object):
 
         return self.active_parsers
 
+    def _get_action_help(self, action):
+        if action.help is None:
+            return ""
+        if "%" not in action.help:
+            return action.help
+        if self._formatter is None:
+            self._formatter = self._parser.formatter_class(prog=self._parser.prog)
+        return self._formatter._expand_help(action)
+
     def _get_subparser_completions(self, parser, cword_prefix):
         aliases_by_parser: Dict[argparse.ArgumentParser, List[str]] = {}
         for key in parser.choices.keys():
@@ -292,7 +302,7 @@ class CompletionFinder(object):
         for action in parser._get_subactions():
             for alias in aliases_by_parser[parser.choices[action.dest]]:
                 if alias.startswith(cword_prefix):
-                    self._display_completions[alias] = action.help or ""
+                    self._display_completions[alias] = self._get_action_help(action)
 
         completions = [subcmd for subcmd in parser.choices.keys() if subcmd.startswith(cword_prefix)]
         return completions
@@ -313,7 +323,7 @@ class CompletionFinder(object):
             if action.option_strings:
                 for option_string in action.option_strings:
                     if option_string.startswith(cword_prefix):
-                        self._display_completions[option_string] = action.help or ""
+                        self._display_completions[option_string] = self._get_action_help(action)
 
         option_completions = []
         for action in parser._actions:
@@ -405,7 +415,7 @@ class CompletionFinder(object):
                             if self.validator(completion, cword_prefix):
                                 completions.append(completion)
                                 if isinstance(completer, ChoicesCompleter):
-                                    self._display_completions[completion] = active_action.help or ""
+                                    self._display_completions[completion] = self._get_action_help(active_action)
                                 else:
                                     self._display_completions[completion] = ""
                 else:
@@ -517,7 +527,7 @@ class CompletionFinder(object):
             # (extended to characters other than the colon).
             if last_wordbreak_pos is not None:
                 completions = [c[last_wordbreak_pos + 1 :] for c in completions]
-            special_chars += "();<>|&!`$* \t\n\"'"
+            special_chars += "();<>|&!`$*?[]{} \t\n\"'"
         elif cword_prequote == '"':
             special_chars += '"`$!'
 

{argcomplete-3.6.2 → argcomplete-3.7.0}/argcomplete/packages/_argparse.py

@@ -19,7 +19,13 @@ from argparse import (
     _SubParsersAction,
 )
 from gettext import gettext
-from typing import Dict, List, Set, Tuple
+from typing import Dict, List, Optional, Set, Tuple, Union, cast
+
+_OptionTuple = Union[
+    Tuple[Optional[Action], str, Optional[str]],
+    Tuple[Optional[Action], str, Optional[str], Optional[str]],
+]
+_OptionTupleEntry = Union[_OptionTuple, List[_OptionTuple]]
 
 _num_consumed_args: Dict[Action, int] = {}
 
@@ -97,7 +103,7 @@ class IntrospectiveArgumentParser(ArgumentParser):
         # 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 = {}
+        option_string_indices: Dict[int, _OptionTupleEntry] = {}
         arg_string_pattern_parts = []
         arg_strings_iter = iter(arg_strings)
         for i, arg_string in enumerate(arg_strings_iter):
@@ -114,7 +120,7 @@ class IntrospectiveArgumentParser(ArgumentParser):
                 if option_tuple is None:
                     pattern = 'A'
                 else:
-                    option_string_indices[i] = option_tuple
+                    option_string_indices[i] = cast(_OptionTupleEntry, option_tuple)
                     pattern = 'O'
                 arg_string_pattern_parts.append(pattern)
 
@@ -161,9 +167,11 @@ class IntrospectiveArgumentParser(ArgumentParser):
         # 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]
-            if isinstance(option_tuple, list):  # Python 3.12.7+
-                option_tuple = option_tuple[0]
+            raw_option_tuple = option_string_indices[start_index]
+            if isinstance(raw_option_tuple, list):  # Python 3.12.7+
+                option_tuple = raw_option_tuple[0]
+            else:
+                option_tuple = raw_option_tuple
             if len(option_tuple) == 3:
                 action, option_string, explicit_arg = option_tuple
             else:  # Python 3.11.9+, 3.12.3+, 3.13+
@@ -241,8 +249,8 @@ class IntrospectiveArgumentParser(ArgumentParser):
             # 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)
+            for optional_action, args, option_string in action_tuples:
+                take_action(optional_action, args, option_string)
             return stop
 
         # the list of Positionals left to be parsed; this is modified

{argcomplete-3.6.2 → argcomplete-3.7.0}/argcomplete/scripts/activate_global_python_argcomplete.py

@@ -79,7 +79,9 @@ def install_to_destination(dest):
         try:
             os.makedirs(destdir, exist_ok=True)
         except Exception as e:
-            parser.error(f"path {destdir} does not exist and could not be created: {e}")
+            parser.error(
+                f"path {destdir} does not exist and could not be created: {e}. Please run this command using sudo, or see --help for more options."
+            )
     try:
         print(f"Installing {activator} to {dest}...", file=sys.stderr)
         shutil.copy(activator, dest)

{argcomplete-3.6.2 → argcomplete-3.7.0}/argcomplete/shell_integration.py

@@ -47,7 +47,7 @@ _python_argcomplete%(function_suffix)s() {
         if is-at-least 5.8; then
             nosort=(-o nosort)
         fi
-        if [[ "${completions-}" =~ ([^\\]): && "${match[1]}" =~ [=/:] ]]; then
+        if [[ "${completions-}" =~ ([^\\\\]): && "${match[1]}" =~ [=/:] ]]; then
             nospace=(-S '')
         fi
         _describe "${words[1]}" completions "${nosort[@]}" "${nospace[@]}"
@@ -94,14 +94,14 @@ complete "%(executable)s" 'p@*@`python-argcomplete-tcsh "%(argcomplete_script)s"
 
 fishcode = r"""
 function __fish_%(function_name)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
+    set -lx _ARGCOMPLETE 1
+    set -lx _ARGCOMPLETE_DFS \t
+    set -lx _ARGCOMPLETE_IFS \n
+    set -lx _ARGCOMPLETE_SUPPRESS_SPACE 1
+    set -lx _ARGCOMPLETE_SHELL fish
+    set -lx COMP_LINE (commandline -p)
+    set -lx COMP_POINT (string length (commandline -cp))
+    set -lx COMP_TYPE
     if set -q _ARC_DEBUG
         %(argcomplete_script)s 8>&1 9>&2 1>&9 2>&1
     else

{argcomplete-3.6.2 → argcomplete-3.7.0}/contrib/README.rst

@@ -16,6 +16,14 @@ or create new completion file, e.g::
 
     register-python-argcomplete --shell fish my-awesome-script > ~/.config/fish/completions/my-awesome-script.fish
 
+If the script is called using a path, such as ``./my-awesome-script``, it must be registered using the absolute path to the script. ::
+
+    register-python-argcomplete --shell fish $(realpath ./my-awesome-script) > ~/.config/fish/completions/my-awesome-script.fish
+
+The completions using a path will not be automatically loaded since the command name does not match the file name. To load the completions, ``source`` them. ::
+
+    source ~/.config/fish/completions/my-awesome-script.fish
+
 Completion Description For Fish
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 By default help string is added as completion description.

{argcomplete-3.6.2 → argcomplete-3.7.0}/pyproject.toml

@@ -15,12 +15,12 @@ classifiers = [
   "Operating System :: POSIX",
   "Programming Language :: Python",
   "Programming Language :: Python :: 3",
-  "Programming Language :: Python :: 3.8",
   "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
   "Development Status :: 5 - Production/Stable",
@@ -32,7 +32,6 @@ classifiers = [
 
 [project.scripts]
 activate-global-python-argcomplete = "argcomplete.scripts.activate_global_python_argcomplete:main"
-python-argcomplete-check-easy-install-script = "argcomplete.scripts.python_argcomplete_check_easy_install_script:main"
 register-python-argcomplete = "argcomplete.scripts.register_python_argcomplete:main"
 
 [project.optional-dependencies]

{argcomplete-3.6.2 → argcomplete-3.7.0}/test/test.py

@@ -356,6 +356,15 @@ class TestArgcomplete(unittest.TestCase):
                 fp.write("test")
             self.assertEqual(set(fc("a")), set(["abcdefж/", "abcaha/", "abcxyz"]))
 
+    def test_file_completion_quotes_prefix(self):
+        with TempDir(prefix="test_dir_fc_quote", dir="."):
+            marker = "should_not_exist"
+            prefix = "'; touch {0}; echo '".format(marker)
+
+            self.assertFalse(os.path.exists(marker))
+            self.assertEqual(FilesCompleter()(prefix), [])
+            self.assertFalse(os.path.exists(marker))
+
     def test_filescompleter_filetype_integration(self):
         def make_parser():
             parser = ArgumentParser()
@@ -828,6 +837,7 @@ class TestArgcomplete(unittest.TestCase):
             parser.add_argument("-1", choices=["bar<$>baz"])
             parser.add_argument("-2", choices=[r"\* "])
             parser.add_argument("-3", choices=["\"'"])
+            parser.add_argument("-4", choices=["data?", "file[1]", "{x,--flag}"])
             return parser
 
         self.assertEqual(set(self.run_completer(make_parser(), "prog -1 ")), {r"bar\<\$\>baz "})
@@ -835,6 +845,10 @@ class TestArgcomplete(unittest.TestCase):
         self.assertEqual(set(self.run_completer(make_parser(), "prog -3 ")), {r"\"\' "})
         self.assertEqual(set(self.run_completer(make_parser(), 'prog -3 "')), {r"\"'"})
         self.assertEqual(set(self.run_completer(make_parser(), "prog -3 '")), {"\"'\\''"})
+        self.assertEqual(
+            set(self.run_completer(make_parser(), "prog -4 ")),
+            {r"data\?", r"file\[1\]", r"\{x,--flag\}"},
+        )
 
         self.assertEqual(set(self.run_completer(make_parser(), "prog -1 ", shell="tcsh")), {"bar<$>baz "})
         # The trailing space won't actually work correctly in tcsh.

argcomplete-3.6.2/argcomplete/scripts/python_argcomplete_check_easy_install_script.py

@@ -1,84 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright 2012-2023, Andrey Kislyuk and argcomplete contributors.
-# Licensed under the Apache License. See https://github.com/kislyuk/argcomplete for more info.
-
-"""
-This script is part of the Python argcomplete package (https://github.com/kislyuk/argcomplete).
-It is used to check if an EASY-INSTALL-SCRIPT wrapper redirects to a script that contains the string
-"PYTHON_ARGCOMPLETE_OK". If you have enabled global completion in argcomplete, the completion hook will run it every
-time you press <TAB> in your shell.
-
-Usage:
-    python-argcomplete-check-easy-install-script <input executable file>
-"""
-
-import sys
-
-# PEP 366
-__package__ = "argcomplete.scripts"
-
-
-def main():
-    if len(sys.argv) != 2:
-        sys.exit(__doc__)
-
-    sys.tracebacklimit = 0
-
-    with open(sys.argv[1]) as fh:
-        line1, head = fh.read(1024).split("\n", 1)[:2]
-        if line1.startswith("#") and ("py" in line1 or "Py" in line1):
-            import re
-
-            lines = head.split("\n", 12)
-            for line in lines:
-                if line.startswith("# EASY-INSTALL-SCRIPT"):
-                    import pkg_resources  # type: ignore
-
-                    re_match = re.match("# EASY-INSTALL-SCRIPT: '(.+)','(.+)'", line)
-                    assert re_match is not None
-                    dist, script = re_match.groups()
-                    if "PYTHON_ARGCOMPLETE_OK" in pkg_resources.get_distribution(dist).get_metadata(
-                        "scripts/" + script
-                    ):
-                        return 0
-                elif line.startswith("# EASY-INSTALL-ENTRY-SCRIPT"):
-                    re_match = re.match("# EASY-INSTALL-ENTRY-SCRIPT: '(.+)','(.+)','(.+)'", line)
-                    assert re_match is not None
-                    dist, group, name = re_match.groups()
-                    import pkgutil
-
-                    import pkg_resources  # type: ignore
-
-                    entry_point_info = pkg_resources.get_distribution(dist).get_entry_info(group, name)
-                    assert entry_point_info is not None
-                    module_name = entry_point_info.module_name
-                    with open(pkgutil.get_loader(module_name).get_filename()) as mod_fh:  # type: ignore
-                        if "PYTHON_ARGCOMPLETE_OK" in mod_fh.read(1024):
-                            return 0
-                elif line.startswith("# EASY-INSTALL-DEV-SCRIPT"):
-                    for line2 in lines:
-                        if line2.startswith("__file__"):
-                            re_match = re.match("__file__ = '(.+)'", line2)
-                            assert re_match is not None
-                            filename = re_match.group(1)
-                            with open(filename) as mod_fh:
-                                if "PYTHON_ARGCOMPLETE_OK" in mod_fh.read(1024):
-                                    return 0
-                elif line.startswith("# PBR Generated"):
-                    re_match = re.search("from (.*) import", head)
-                    assert re_match is not None
-                    module = re_match.groups()[0]
-                    import pkgutil
-
-                    import pkg_resources  # type: ignore
-
-                    with open(pkgutil.get_loader(module).get_filename()) as mod_fh:  # type: ignore
-                        if "PYTHON_ARGCOMPLETE_OK" in mod_fh.read(1024):
-                            return 0
-
-    return 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())