From 55d6186440ee44706333ceda86e8ec4750b66cf4 Mon Sep 17 00:00:00 2001
From: Marc <161899161+mdesco-crgl@users.noreply.github.com>
Date: Wed, 6 May 2026 17:18:37 +0000
Subject: [PATCH 1/6] Update pip to 26.1

---
 pyproject.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index faddf81..97b709e 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -19,7 +19,7 @@ dependencies = [
   "blessings>=1.6",
   "build>=1.3",
   # For envs that don't actually have pip - we use some of its tooling atm.
-  "pip>=25.1",
+  "pip>=26.1",
   "releases>=1.6",
   "semantic_version>=2.4,<2.7",
   "tabulate>=0.7.5",

From a115a88b3d68ee6b661029db2bb4b370052f0d68 Mon Sep 17 00:00:00 2001
From: Marc <161899161+mdesco-crgl@users.noreply.github.com>
Date: Wed, 6 May 2026 17:47:06 +0000
Subject: [PATCH 2/6] drop support for python 3.9

---
 .gitignore     | 3 +++
 pyproject.toml | 3 +--
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/.gitignore b/.gitignore
index 679dfaf..bfb618f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,3 +6,6 @@ docs/_build
 coverage.xml
 _build
 uv.lock
+*.egg-info
+__pycache__/*
+*.pyc
diff --git a/pyproject.toml b/pyproject.toml
index 97b709e..123c35d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "invocations"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 version = "4.1.0"
 description = "Common/best-practice Invoke tasks and collections"
 readme = "README.rst"
@@ -40,7 +40,6 @@ classifiers = [
   "Programming Language :: Python",
   "Programming Language :: Python :: 3",
   "Programming Language :: Python :: 3 :: Only",
-  "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",

From b24186fbbd0d62fddcedc6d03a542300d64c7f7e Mon Sep 17 00:00:00 2001
From: Marc <161899161+mdesco-crgl@users.noreply.github.com>
Date: Wed, 6 May 2026 18:30:28 +0000
Subject: [PATCH 3/6] fix packaging/release tests

attempt to fix autodoc

revert autodoc to be at most compatible with python 3.10
---
 invocations/autodoc.py                        | 132 ++++++-----
 .../packaging/semantic_version_monkey.py      |   1 -
 invocations/packaging/vendorize.py            |   1 +
 pyproject.toml                                |   2 +-
 pytest.ini                                    |   3 +
 tests/autodoc/_support/conf.py                |  14 +-
 tests/autodoc/_support/docs/api.rst           |   1 +
 tests/autodoc/base.py                         |  27 ++-
 tests/conftest.py                             |  96 +-------
 tests/packaging/release.py                    | 207 +++++++++++++-----
 10 files changed, 274 insertions(+), 210 deletions(-)

diff --git a/invocations/autodoc.py b/invocations/autodoc.py
index fbff267..98b7ada 100644
--- a/invocations/autodoc.py
+++ b/invocations/autodoc.py
@@ -6,76 +6,100 @@
 allows Sphinx's `autodoc`_ functionality to see and document
 Invoke tasks and similar Invoke objects.
 
-.. note::
-    This functionality is mostly useful for redistributable/reusable tasks
-    which have been defined as importable members of some Python package or
-    module, as opposed to "local-only" tasks that live in a single project's
-    ``tasks.py``.
-
-    However, it will work for any tasks that Sphinx autodoc can import, so in a
-    pinch you could for example tweak ``sys.path`` in your Sphinx ``conf.py``
-    to get it loading up a "local" tasks file for import.
-
 To use:
+- Add ``"invocations.autodoc"`` to your Sphinx ``conf.py``'s ``extensions``.
+- Use ``.. automodule:: myproject.tasks`` with ``:members:``.
+"""
 
-- Add ``"invocations.autodoc"`` to your Sphinx ``conf.py``'s ``extensions``
-  list.
-- Use Sphinx autodoc's ``automodule`` directive normally, aiming it at your
-  tasks module(s), e.g. ``.. automodule:: myproject.tasks`` in some ``.rst``
-  document of your choosing.
-
-    - As noted above, this only works for modules that are importable, like any
-      other Sphinx autodoc use case.
-    - Unless you want to opt-in which module members get documented, use
-      ``:members:`` or add ``"members": True`` to your ``conf.py``'s
-      ``autodoc_default_options``.
-    - By default, only tasks with docstrings will be picked up, unless you also
-      give the ``:undoc-members:`` flag or add ``:undoc-members:`` / add
-      ``"undoc-members": True`` to ``autodoc_default_options``.
-    - Please see the `autodoc`_ docs for details on these settings and more!
-
-- Build your docs, and you should see your tasks showing up as documented
-  functions in the result.
+import inspect
+from sphinx.ext import autodoc
 
+# Compatibility layer for signature stringification
+try:
+    from sphinx.util import inspect as sphinx_inspect
 
-.. _autodoc: http://www.sphinx-doc.org/en/master/ext/autodoc.html
-"""
+    stringify = sphinx_inspect.stringify_signature
+except (ImportError, AttributeError):
+    try:
+        stringify = autodoc.stringify_signature
+    except AttributeError:
 
-import inspect
+        def stringify(x):
+            return str(x)
 
-from invoke import Task
 
-# For sane mock patching. Meh.
-from sphinx.ext import autodoc
+class TaskDocumenter(autodoc.ModuleLevelDocumenter):
+    """
+    Custom autodoc documenter for Invoke Task objects.
 
+    Inherits from ModuleLevelDocumenter to ensure tasks are discovered in
+    modules without triggering DataDocumenter's ':value:' header logic,
+    which causes errors in standard function directives.
+    """
 
-class TaskDocumenter(
-    autodoc.DocstringSignatureMixin, autodoc.ModuleLevelDocumenter
-):
     objtype = "task"
     directivetype = "function"
+    priority = 50
 
     @classmethod
     def can_document_member(cls, member, membername, isattr, parent):
-        return isinstance(member, Task)
-
-    def format_args(self):
-        function = self.object.body
-        # TODO: consider extending (or adding a sibling to) Task.argspec so it
-        # preserves more of the full argspec tuple.
-        # TODO: whether to preserve the initial context argument is an open
-        # question. For now, it will appear, but only pending invoke#170 -
-        # after which point "call tasks as raw functions" may be less common.
-        # TODO: also, it may become moot-ish if we turn this all into emission
-        # of custom domain objects and/or make the CLI arguments the focus
-        return autodoc.stringify_signature(inspect.signature(function))
-
-    def document_members(self, all_members=False):
-        # Neuter this so superclass bits don't introspect & spit out autodoc
-        # directives for task attributes. Most of that's not useful.
-        pass
+        from invoke import Task
+
+        # Identify Invoke tasks by their characteristic attributes or class type
+        return (
+            isinstance(member, Task)
+            or hasattr(member, "body")
+            and hasattr(member, "argspec")
+        )
+
+    def import_object(self, **kwargs):
+        # Import the Task instance, then store the wrapped function for inspection
+        success = super().import_object(**kwargs)
+        if success and hasattr(self.object, "body"):
+            self.wrapped_function = self.object.body
+        return success
+
+    def get_object_members(self, want_all):
+        # Tasks are atomic; they have no child members to document
+        return False, []
+
+    def format_args(self, **kwargs):
+        try:
+            sig = inspect.signature(self.object.body)
+            return stringify(sig)
+        except Exception:
+            return None
+
+    def format_signature(self, **kwargs):
+        # Extract signature from the wrapped function body
+        try:
+            sig = inspect.signature(self.wrapped_function)
+            return stringify(sig)
+        except Exception:
+            return ""
+
+    def add_directive_header(self, sig):
+        # Write the standard header (.. py:function:: name(args))
+        # Note: 3.10+ adds :value: which is incompatible with py:function
+        super().add_directive_header(sig)
+
+    def add_content(self, more_content, no_docstring=False):
+        # Manually inject the docstring from the wrapped function
+        sourcename = self.get_sourcename()
+        docstring = inspect.getdoc(self.wrapped_function)
+
+        if docstring:
+            for line in docstring.splitlines():
+                self.add_line(line, sourcename)
+
+        # Call parent with no_docstring=True to avoid redundant lookup attempts
+        try:
+            super().add_content(more_content, no_docstring=True)
+        except TypeError:
+            super().add_content(more_content)
 
 
 def setup(app):
     app.setup_extension("sphinx.ext.autodoc")
     app.add_autodocumenter(TaskDocumenter)
+    return {"version": "1.0", "parallel_read_safe": True}
diff --git a/invocations/packaging/semantic_version_monkey.py b/invocations/packaging/semantic_version_monkey.py
index 0713c99..a052ab9 100644
--- a/invocations/packaging/semantic_version_monkey.py
+++ b/invocations/packaging/semantic_version_monkey.py
@@ -5,7 +5,6 @@
 or distributing our own fork.
 """
 
-
 from semantic_version import Version
 
 
diff --git a/invocations/packaging/vendorize.py b/invocations/packaging/vendorize.py
index b3468c4..fe3464b 100644
--- a/invocations/packaging/vendorize.py
+++ b/invocations/packaging/vendorize.py
@@ -1,6 +1,7 @@
 """
 Tasks for importing external code into a vendor subdirectory.
 """
+
 from os import chdir
 from pathlib import Path
 from shutil import copy, copytree, rmtree
diff --git a/pyproject.toml b/pyproject.toml
index 123c35d..028bf30 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -75,7 +75,7 @@ dev = [
   # Oldest version that works on Python >3.11
   "watchdog==1.0.2",
   "coverage==4.4.2",
-  "icecream==2.1.3",
+  "icecream==2.2.0",
   # Formatting
   "black==22.12.0",
   # Linting
diff --git a/pytest.ini b/pytest.ini
index f51e190..1e6103b 100644
--- a/pytest.ini
+++ b/pytest.ini
@@ -1,3 +1,6 @@
 [pytest]
 testpaths = tests
 python_files = *
+pythonpath = .
+
+addopts = "-ra --capture=sys"
\ No newline at end of file
diff --git a/tests/autodoc/_support/conf.py b/tests/autodoc/_support/conf.py
index a33252e..52fb773 100644
--- a/tests/autodoc/_support/conf.py
+++ b/tests/autodoc/_support/conf.py
@@ -1,10 +1,16 @@
-from os.path import dirname
 import sys
+from os.path import dirname, abspath, join
 
+# Basic path setup
+support = abspath(dirname(__file__))
+repo_root = abspath(join(support, "..", "..", ".."))
 
-# Add local support dir to path so tasks modules may be imported by autodoc
-sys.path.insert(0, dirname(__file__))
+if repo_root not in sys.path:
+    sys.path.insert(0, repo_root)
+if support not in sys.path:
+    sys.path.insert(0, support)
 
 master_doc = "index"
 extensions = ["invocations.autodoc"]
-autodoc_default_options = dict(members=True)
+autodoc_default_options = {"members": True}
+project = "Invocations"
diff --git a/tests/autodoc/_support/docs/api.rst b/tests/autodoc/_support/docs/api.rst
index 96e9b9c..c15ead3 100644
--- a/tests/autodoc/_support/docs/api.rst
+++ b/tests/autodoc/_support/docs/api.rst
@@ -3,3 +3,4 @@ API
 ===
 
 .. automodule:: mytasks
+    :members:
\ No newline at end of file
diff --git a/tests/autodoc/base.py b/tests/autodoc/base.py
index efe340c..0979e26 100644
--- a/tests/autodoc/base.py
+++ b/tests/autodoc/base.py
@@ -1,7 +1,7 @@
 from os.path import join, dirname
 import re
 import shutil
-
+import pytest
 from unittest.mock import Mock
 
 from invoke import Context
@@ -16,10 +16,19 @@ def _build():
     support = join(dirname(__file__), "_support")
     docs = join(support, "docs")
     build = join(support, "_build")
-    command = "sphinx-build -c {} -W {} {}".format(support, docs, build)
-    with c.cd(support):
-        # Turn off stdin mirroring to avoid irritating pytest.
-        c.run(command, in_stream=False)
+    # Add -E to force fresh build and -v for verbosity
+    command = "sphinx-build -v -E -c {} -W {} {}".format(support, docs, build)
+
+    print("\n--- SPHINX BUILD LOG ---")
+    # Use warn=True so pytest doesn't crash here, allowing us to see the output
+    result = c.run(command, in_stream=False, warn=True)
+
+    if result.failed:
+        # This will print to your terminal during 'uv run pytest -s'
+        print(result.stdout)
+        print(result.stderr)
+        raise RuntimeError("Sphinx build failed! check logs above.")
+
     return build
 
 
@@ -60,10 +69,18 @@ def undocumented_members_do_not_appear_by_default(self):
         # This really just tests basic Sphinx/autodoc stuff for now...meh
         assert "undocumented" not in self.api_docs
 
+    @pytest.mark.xfail(
+        reason="Autodoc TaskDocumenter only works for python 3.10",
+        strict=False,
+    )
     def base_case_of_no_argument_docstringed_task(self):
         for sentinel in ("base_case", "smallest possible task"):
             assert sentinel in self.api_docs
 
+    @pytest.mark.xfail(
+        reason="Autodoc TaskDocumenter only works for python 3.10",
+        strict=False,
+    )
     def simple_case_of_single_argument_task(self):
         # TODO: OK we really need something that scales better soon re:
         # viewing the output as a non-HTML string / something that is not
diff --git a/tests/conftest.py b/tests/conftest.py
index 663d938..82dd52b 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,6 +1,3 @@
-from pathlib import Path
-from unittest.mock import patch, Mock, MagicMock, call
-
 from pytest import fixture
 from invoke import MockContext
 
@@ -12,94 +9,7 @@
 
 @fixture
 def ctx():
-    # TODO: this would be a nice convenience in MockContext itself, though most
-    # uses of it really just want responses-style "assert if expected calls did
-    # not happen" behavior
-    MockContext.run_command = property(lambda self: self.run.call_args[0][0])
-    return MockContext(run=True)
-
-
-class Mocks:
-    pass
-
-
-# For use in packaging.release.publish tests
-@fixture
-def fakepub(mocker):
-    mocks = Mocks()
-    mocks.rmtree = mocker.patch("invocations.util.rmtree")
-    mocks.twine_check = mocker.patch(
-        "invocations.packaging.release.twine_check", return_value=False
-    )
-    mocks.upload = mocker.patch("invocations.packaging.release.upload")
-    mocks.build = mocker.patch("invocations.packaging.release.build")
-    mocks.test_install = mocker.patch(
-        "invocations.packaging.release.test_install"
-    )
-    mocks.mkdtemp = mocker.patch("invocations.util.mkdtemp")
-    mocks.mkdtemp.return_value = "tmpdir"
     c = MockContext(run=True)
-    yield c, mocks
-
-
-# For use in packaging.release.test_install tests
-@fixture
-def install():
-    with patch("invocations.packaging.release.pip_version", "lmao"), patch(
-        "invocations.util.rmtree", Mock("rmtree")
-    ), patch(
-        "invocations.packaging.release._find_package", lambda c: "foo"
-    ), patch(
-        "venv.EnvBuilder"
-    ) as builder, patch(
-        "invocations.util.mkdtemp"
-    ) as mkdtemp, patch(
-        "invocations.packaging.release.get_archives"
-    ) as get_archives, patch(
-        "invocations.packaging.release.Path"
-    ) as fakePath:
-        # Setup & run
-        c = MockContext(run=True, repeat=True)
-        mkdtemp.return_value = "tmpdir"
-        get_archives.return_value = ["foo.tgz", "foo.whl"]
-
-        # I hate this but don't see a cleaner way to mock out a nested
-        # 'exists()' w/o breaking everything else, or using a real tmpdir.
-        def set_exists(value):
-            def fakediv(self, arg):
-                root = Path(mkdtemp.return_value)
-                bindir = root / "bin"
-                if arg == "bin":
-                    return bindir
-                elif arg == "pip":
-                    return bindir / "pip"
-                elif arg == "python":
-                    return bindir / "python"
-                elif arg == "py.typed":
-                    path = Path("foo") / "py.typed"
-                    ret = MagicMock(wraps=path)
-                    ret.exists.return_value = value
-                    return ret
-
-            fakePath.return_value.__truediv__ = fakediv
-
-        c.set_exists = set_exists  # so caller can run it
-        c.set_exists(False)  # default
-        yield c
-        # Create factory
-        builder.assert_called_once_with(with_pip=True)
-        # Used helper to get artifacts
-        get_archives.assert_called_once_with("whatever")
-        # venv factory ran twice in some temp dir
-        builder.return_value.create.assert_has_calls(
-            [call("tmpdir"), call("tmpdir")]
-        )
-        pip_base = "tmpdir/bin/pip install --disable-pip-version-check"
-        for wanted in (
-            # Pip installed to same version as running interpreter's pip
-            call("tmpdir/bin/pip install pip==lmao"),
-            # Archives installed into venv
-            call("{} foo.tgz".format(pip_base)),
-            call("{} foo.whl".format(pip_base)),
-        ):
-            assert wanted in c.run.mock_calls
+    # Patch the INSTANCE, not the CLASS
+    type(c).run_command = property(lambda self: self.run.call_args[0][0])
+    return c
diff --git a/tests/packaging/release.py b/tests/packaging/release.py
index e54dd21..7dcfd56 100644
--- a/tests/packaging/release.py
+++ b/tests/packaging/release.py
@@ -3,13 +3,14 @@
 from pathlib import Path
 import re
 import sys
+from unittest.mock import patch, Mock, MagicMock, call
+
 
 from invoke.vendor.lexicon import Lexicon
 from invoke import MockContext, Result, Config, Exit
 from docutils.utils import Reporter
-from unittest.mock import patch, call
 import pytest
-from pytest import skip
+from pytest import skip, fixture
 from pytest_relaxed import trap, raises
 
 from invocations.packaging.semantic_version_monkey import Version
@@ -35,6 +36,100 @@
 )
 
 
+class Mocks:
+    pass
+
+
+# For use in packaging.release.publish tests
+@fixture
+def _fakepub(mocker):
+    mocks = Mocks()
+    mocks.rmtree = mocker.patch("invocations.util.rmtree")
+    mocks.twine_check = mocker.patch(
+        "invocations.packaging.release.twine_check", return_value=False
+    )
+    mocks.upload = mocker.patch("invocations.packaging.release.upload")
+    mocks.build = mocker.patch("invocations.packaging.release.build")
+    mocks.test_install = mocker.patch(
+        "invocations.packaging.release.test_install"
+    )
+    mocks.mkdtemp = mocker.patch("invocations.util.mkdtemp")
+    mocks.mkdtemp.return_value = "tmpdir"
+    c = MockContext(run=True)
+    yield c, mocks
+
+
+# For use in packaging.release.test_install tests
+@fixture
+def _install():
+    with (
+        patch("invocations.packaging.release.pip_version", "lmao"),
+        patch("invocations.util.rmtree", Mock("rmtree")),
+        patch("invocations.packaging.release._find_package", lambda c: "foo"),
+        patch("venv.EnvBuilder") as builder,
+        patch("invocations.util.mkdtemp") as mkdtemp,
+        patch("invocations.packaging.release.get_archives") as get_archives,
+        patch("invocations.packaging.release.Path") as fakePath,
+    ):
+        # Setup & run
+        c = MockContext(run=True, repeat=True)
+        mkdtemp.return_value = "tmpdir"
+        get_archives.return_value = ["foo.tgz", "foo.whl"]
+
+        # I hate this but don't see a cleaner way to mock out a nested
+        # 'exists()' w/o breaking everything else, or using a real tmpdir.
+        def set_exists(value):
+            def fakediv(self, arg):
+                root = Path(mkdtemp.return_value)
+                bindir = root / "bin"
+                if arg == "bin":
+                    return bindir
+                elif arg == "pip":
+                    return bindir / "pip"
+                elif arg == "python":
+                    return bindir / "python"
+                elif arg == "py.typed":
+                    path = Path("foo") / "py.typed"
+                    ret = MagicMock(wraps=path)
+                    ret.exists.return_value = value
+                    return ret
+
+            fakePath.return_value.__truediv__ = fakediv
+
+        c.set_exists = set_exists  # so caller can run it
+        c.set_exists(False)  # default
+        yield c
+        # Create factory
+        builder.assert_called_once_with(with_pip=True)
+        # Used helper to get artifacts
+        get_archives.assert_called_once_with("whatever")
+        # venv factory ran twice in some temp dir
+        builder.return_value.create.assert_has_calls(
+            [call("tmpdir"), call("tmpdir")]
+        )
+        pip_base = "tmpdir/bin/pip install --disable-pip-version-check"
+        for wanted in (
+            # Pip installed to same version as running interpreter's pip
+            call("tmpdir/bin/pip install pip==lmao"),
+            # Archives installed into venv
+            call("{} foo.tgz".format(pip_base)),
+            call("{} foo.whl".format(pip_base)),
+        ):
+            assert wanted in c.run.mock_calls
+
+
+def _strip_ansi(text):
+    # 1. Strips CSI sequences (colors, etc): \x1b[ ... m
+    # 2. Strips character set sequences (like yours): \x1b( ...
+    ansi_escape = re.compile(
+        r"""
+        \x1b[\[()][0-9;]*[a-zA-Z]
+    """,
+        re.VERBOSE,
+    )
+    return ansi_escape.sub("", text)
+
+
 class release_line_:
     def assumes_bugfix_if_release_branch(self):
         c = MockContext(run=Result("2.7"))
@@ -189,6 +284,7 @@ def next_minor_of_feature_release(self):
 # NOTE: needs to not shadow any real imported module name!
 FAKE_PACKAGE = "fakey_mcfakerson_not_real_in_any_way"
 
+
 # NOTE: can't easily slap this on the test class itself due to using inner
 # classes. If we can get the inner classes to not only copy attributes but also
 # decorators (seems unlikely?), we could organize more "naturally".
@@ -543,7 +639,6 @@ def _run_prepare(c, mute=True, **kwargs):
 
 
 class prepare_:
-
     # NOTE: mostly testing the base case of 'everything needs updating',
     # all the permutations are tested elsewhere.
     _branch = "1.1"
@@ -767,28 +862,36 @@ class component_state_enums_contain_human_readable_values:
     class changelog:
         def okay(self):
             expected = "\x1b[32m\u2714 no unreleased issues\x1b(B\x1b[m"
-            assert Changelog.OKAY.value == expected
+            assert _strip_ansi(Changelog.OKAY.value) == _strip_ansi(expected)
 
         def needs_release(self):
             expected = "\x1b[31m\u2718 needs :release: entry\x1b(B\x1b[m"
-            assert Changelog.NEEDS_RELEASE.value == expected
+            assert _strip_ansi(Changelog.NEEDS_RELEASE.value) == _strip_ansi(
+                expected
+            )
 
     class version_file:
         def okay(self):
             expected = "\x1b[32m\u2714 version up to date\x1b(B\x1b[m"
-            assert VersionFile.OKAY.value == expected
+            assert _strip_ansi(VersionFile.OKAY.value) == _strip_ansi(expected)
 
         def needs_bump(self):
             expected = "\x1b[31m\u2718 needs version bump\x1b(B\x1b[m"
-            assert VersionFile.NEEDS_BUMP.value == expected
+            assert _strip_ansi(VersionFile.NEEDS_BUMP.value) == _strip_ansi(
+                expected
+            )
 
     class tag:
         def okay(self):
-            assert Tag.OKAY.value == "\x1b[32m\u2714 all set\x1b(B\x1b[m"
+            assert _strip_ansi(Tag.OKAY.value) == _strip_ansi(
+                "\x1b[32m\u2714 all set\x1b(B\x1b[m"
+            )
 
         def needs_cutting(self):
             expected = "\x1b[31m\u2718 needs cutting\x1b(B\x1b[m"
-            assert Tag.NEEDS_CUTTING.value == expected
+            assert _strip_ansi(Tag.NEEDS_CUTTING.value) == _strip_ansi(
+                expected
+            )
 
 
 @contextmanager
@@ -1011,8 +1114,8 @@ class _Kaboom(Exception):
 
 class publish_:
     class base_case:
-        def does_all_the_things(self, fakepub):
-            c, mocks = fakepub
+        def does_all_the_things(self, _fakepub):
+            c, mocks = _fakepub
             # Execution
             publish(c)
             # Unhides stdout
@@ -1033,14 +1136,14 @@ def does_all_the_things(self, fakepub):
             # Tmpdir cleaned up
             mocks.rmtree.assert_called_once_with("tmpdir")
 
-        def cleans_up_on_error(self, fakepub):
-            c, mocks = fakepub
+        def cleans_up_on_error(self, _fakepub):
+            c, mocks = _fakepub
             mocks.build.side_effect = _Kaboom
             with pytest.raises(_Kaboom):
                 publish(MockContext(run=True))
             mocks.rmtree.assert_called_once_with(mocks.mkdtemp.return_value)
 
-        def monkeypatches_readme_renderer(self, fakepub):
+        def monkeypatches_readme_renderer(self, _fakepub):
             # Happens at module load time but is just a data structure change
             import readme_renderer.rst
 
@@ -1054,105 +1157,105 @@ def monkeypatches_readme_renderer(self, fakepub):
             )
 
     class index:
-        def passed_to_upload(self, fakepub):
-            c, mocks = fakepub
+        def passed_to_upload(self, _fakepub):
+            c, mocks = _fakepub
             publish(c, index="dev")
             assert mocks.upload.call_args[1]["index"] == "dev"
 
-        def honors_config(self, fakepub):
-            c, mocks = fakepub
+        def honors_config(self, _fakepub):
+            c, mocks = _fakepub
             c.config.packaging = dict(index="prod")
             publish(c)
             assert mocks.upload.call_args[1]["index"] == "prod"
 
-        def kwarg_beats_config(self, fakepub):
-            c, mocks = fakepub
+        def kwarg_beats_config(self, _fakepub):
+            c, mocks = _fakepub
             c.config.packaging = dict(index="prod")
             publish(c, index="dev")
             assert mocks.upload.call_args[1]["index"] == "dev"
 
     class sign:
-        def passed_to_upload(self, fakepub):
-            c, mocks = fakepub
+        def passed_to_upload(self, _fakepub):
+            c, mocks = _fakepub
             publish(c, sign=True)
             assert mocks.upload.call_args[1]["sign"] is True
 
-        def honors_config(self, fakepub):
-            c, mocks = fakepub
+        def honors_config(self, _fakepub):
+            c, mocks = _fakepub
             c.config.packaging = dict(sign=True)
             publish(c)
             assert mocks.upload.call_args[1]["sign"] is True
 
-        def kwarg_beats_config(self, fakepub):
-            c, mocks = fakepub
+        def kwarg_beats_config(self, _fakepub):
+            c, mocks = _fakepub
             c.config.packaging = dict(sign=False)
             publish(c, sign=True)
             assert mocks.upload.call_args[1]["sign"] is True
 
     class sdist:
-        def defaults_True_and_passed_to_build(self, fakepub):
-            c, mocks = fakepub
+        def defaults_True_and_passed_to_build(self, _fakepub):
+            c, mocks = _fakepub
             publish(c)
             assert mocks.build.call_args[1]["sdist"] is True
 
-        def may_be_overridden(self, fakepub):
-            c, mocks = fakepub
+        def may_be_overridden(self, _fakepub):
+            c, mocks = _fakepub
             publish(c, sdist=False)
             assert mocks.build.call_args[1]["sdist"] is False
 
     class wheel:
-        def defaults_True_and_passed_to_build(self, fakepub):
-            c, mocks = fakepub
+        def defaults_True_and_passed_to_build(self, _fakepub):
+            c, mocks = _fakepub
             publish(c)
             assert mocks.build.call_args[1]["wheel"] is True
 
-        def may_be_overridden(self, fakepub):
-            c, mocks = fakepub
+        def may_be_overridden(self, _fakepub):
+            c, mocks = _fakepub
             publish(c, wheel=False)
             assert mocks.build.call_args[1]["wheel"] is False
 
-    def directory_affects_tmpdir(self, fakepub):
-        c, mocks = fakepub
+    def directory_affects_tmpdir(self, _fakepub):
+        c, mocks = _fakepub
         publish(c, directory="explicit")
         assert not mocks.mkdtemp.called
         assert mocks.build.call_args[1]["directory"] == "explicit"
 
     class dry_run:
-        def causes_tmpdir_cleanup_to_be_skipped(self, fakepub):
-            c, mocks = fakepub
+        def causes_tmpdir_cleanup_to_be_skipped(self, _fakepub):
+            c, mocks = _fakepub
             publish(c, dry_run=True)
             assert not mocks.rmtree.called
 
-        def causes_tmpdir_cleanup_to_be_skipped_on_exception(self, fakepub):
-            c, mocks = fakepub
+        def causes_tmpdir_cleanup_to_be_skipped_on_exception(self, _fakepub):
+            c, mocks = _fakepub
             mocks.build.side_effect = _Kaboom
             with pytest.raises(_Kaboom):
                 publish(c, dry_run=True)
             assert not mocks.rmtree.called
 
-        def passed_to_upload(self, fakepub):
-            c, mocks = fakepub
+        def passed_to_upload(self, _fakepub):
+            c, mocks = _fakepub
             publish(c, dry_run=True)
             assert mocks.upload.call_args[1]["dry_run"] is True
 
 
 class test_install_:
-    def installs_all_archives_in_fresh_venv_with_matching_pip(self, install):
-        c = install
+    def installs_all_archives_in_fresh_venv_with_matching_pip(self, _install):
+        c = _install
         # Basic test, uses guts of fixture
         install_test_task(c, directory="whatever")
         # Import attempt was made
         c.run.assert_any_call("tmpdir/bin/python -c 'import foo'")
 
-    def skips_import_test_when_asked_to(self, install):
-        c = install
+    def skips_import_test_when_asked_to(self, _install):
+        c = _install
         install_test_task(c, directory="whatever", skip_import=True)
         # No import attempt
         for unwanted in (call("tmpdir/bin/python -c 'import foo'"),):
             assert unwanted not in c.run.mock_calls
 
-    def does_mypy_import_when_py_typed_present(self, install):
-        c = install
+    def does_mypy_import_when_py_typed_present(self, _install):
+        c = _install
         # Mock out the pathlib exists call as positive (default is negative)
         c.set_exists(True)
         install_test_task(c, directory="whatever")
@@ -1162,8 +1265,8 @@ def does_mypy_import_when_py_typed_present(self, install):
         # all these mocks, jeez
         c.run.assert_any_call("cd tmpdir && tmpdir/bin/mypy -c 'import foo'")
 
-    def skips_mypy_import_when_no_py_typed(self, install):
-        c = install
+    def skips_mypy_import_when_no_py_typed(self, _install):
+        c = _install
         # Mock out the pathlib exists call as explicitly false, why not
         c.set_exists(False)
         install_test_task(c, directory="whatever")
@@ -1174,8 +1277,8 @@ def skips_mypy_import_when_no_py_typed(self, install):
         ):
             assert unwanted not in c.run.mock_calls
 
-    def skips_mypy_import_when_skipping_regular_import(self, install):
-        c = install
+    def skips_mypy_import_when_skipping_regular_import(self, _install):
+        c = _install
         c.set_exists(True)
         install_test_task(c, directory="whatever", skip_import=True)
         # Mypy NOT installed or executed

From 9ae5f28125b6292a27b140b8b727463a8a78db42 Mon Sep 17 00:00:00 2001
From: Marc <161899161+mdesco-crgl@users.noreply.github.com>
Date: Wed, 6 May 2026 20:14:39 +0000
Subject: [PATCH 4/6] add ruff to dev dependencies

---
 pyproject.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pyproject.toml b/pyproject.toml
index 028bf30..f238449 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -80,6 +80,7 @@ dev = [
   "black==22.12.0",
   # Linting
   "flake8~=7.3.0",
+  "ruff~=0.15"
 ]
 
 [tool.ruff]

From 05e6721cc1ea6d29102366186f0dc96a6715dc43 Mon Sep 17 00:00:00 2001
From: Marc <161899161+mdesco-crgl@users.noreply.github.com>
Date: Wed, 6 May 2026 20:32:59 +0000
Subject: [PATCH 5/6] fix nitpicky docs

---
 docs/conf.py                     |  4 ++--
 invocations/autodoc.py           |  5 +++--
 invocations/ci.py                |  5 +++--
 invocations/packaging/release.py | 12 ++++++++++++
 invocations/pytest.py            |  2 ++
 5 files changed, 22 insertions(+), 6 deletions(-)

diff --git a/docs/conf.py b/docs/conf.py
index b0199d9..55c6ed7 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -63,6 +63,6 @@
     inv_target = "http://docs.pyinvoke.org/en/latest/"
 # Put them all together, + Python core
 intersphinx_mapping = {
-    "python": ("http://docs.python.org/", None),
-    "invoke": (inv_target, None),
+    "python": ("https://docs.python.org/3/", None),
+    "invoke": ("https://docs.pyinvoke.org/en/stable/", None),
 }
diff --git a/invocations/autodoc.py b/invocations/autodoc.py
index 98b7ada..b40a796 100644
--- a/invocations/autodoc.py
+++ b/invocations/autodoc.py
@@ -45,7 +45,7 @@ class TaskDocumenter(autodoc.ModuleLevelDocumenter):
     def can_document_member(cls, member, membername, isattr, parent):
         from invoke import Task
 
-        # Identify Invoke tasks by their characteristic attributes or class type
+        # Identify Invoke tasks by their characteristic attributes or type
         return (
             isinstance(member, Task)
             or hasattr(member, "body")
@@ -53,7 +53,8 @@ def can_document_member(cls, member, membername, isattr, parent):
         )
 
     def import_object(self, **kwargs):
-        # Import the Task instance, then store the wrapped function for inspection
+        # Import the Task instance,
+        # then store the wrapped function for inspection
         success = super().import_object(**kwargs)
         if success and hasattr(self.object, "body"):
             self.wrapped_function = self.object.body
diff --git a/invocations/ci.py b/invocations/ci.py
index 56234a5..12b6dd6 100644
--- a/invocations/ci.py
+++ b/invocations/ci.py
@@ -56,9 +56,10 @@ def sudo_run(c, command):
     """
     Run some command under CI-oriented sudo subshell/virtualenv.
 
-    :param str command:
-        Command string to run, e.g. ``inv coverage``, ``inv integration``, etc.
+    :param str command: Command string to run,
+        e.g. ``inv coverage``, ``inv integration``, etc.
         (Does not necessarily need to be an Invoke task, but...)
+
     """
     # NOTE: due to circle sudoers config, circleci user can't do "sudo -u" w/o
     # password prompt. However, 'sudo su' seems to work just as well...
diff --git a/invocations/packaging/release.py b/invocations/packaging/release.py
index b35b132..1889490 100644
--- a/invocations/packaging/release.py
+++ b/invocations/packaging/release.py
@@ -287,8 +287,10 @@ def all_(c, dry_run=False):
     .. versionchanged:: 2.1
         Expanded functionality to run ``publish`` and ``push`` as well as
         ``prepare``.
+
     .. versionchanged:: 2.1
         Added the ``dry_run`` flag.
+
     """
     prepare(c, dry_run=dry_run)
     publish(c, dry_run=dry_run)
@@ -309,8 +311,10 @@ def prepare(c, dry_run=False):
 
     .. versionchanged:: 2.1
         Added the ``dry_run`` parameter.
+
     .. versionchanged:: 2.1
         Generate annotated git tags instead of lightweight ones.
+
     """
     # Print dry-run/status/actions-to-take data & grab programmatic result
     # TODO: maybe expand the enum-based stuff to have values that split up
@@ -607,16 +611,21 @@ def build(
     .. versionchanged:: 2.0
         ``clean`` now defaults to False instead of True, cleans both dist and
         build dirs when True, and honors configuration.
+
     .. versionchanged:: 2.0
         ``wheel`` now defaults to True instead of False.
+
     .. versionchanged:: 4.0
         Switched to using ``pypa/build`` and made related changes to args
         (eg, ``directory`` now only controls dist output location).
+
     .. versionchanged:: 4.1
         Added the ``opts`` argument.
+
     .. versionchanged:: 4.1
         Updated ``--clean`` to additionally remove any ``build/`` directories
         within the source root.
+
     """
     # Config hooks
     config = c.config.get("packaging", {})
@@ -715,6 +724,7 @@ def publish(
 
         Defaults to a temporary directory which is cleaned up after the run
         finishes.
+
     """
     # Don't hide by default, this step likes to be verbose most of the time.
     c.config.run.hide = False
@@ -774,6 +784,7 @@ def test_install(c, directory, verbose=False, skip_import=False):
     :param bool skip_import:
         If True, don't try importing the installed module or checking it for
         type hints.
+
     """
     # TODO: wants contextmanager or similar for only altering a setting within
     # a given scope or block - this may pollute subsequent subroutine calls
@@ -852,6 +863,7 @@ def upload(c, directory, index=None, sign=False, dry_run=False):
 
         This also prevents cleanup of the temporary build/dist directories, so
         you can examine the build artifacts.
+
     """
     archives = get_archives(directory)
     # Sign each archive in turn
diff --git a/invocations/pytest.py b/invocations/pytest.py
index dc30f3a..aa09885 100644
--- a/invocations/pytest.py
+++ b/invocations/pytest.py
@@ -59,6 +59,7 @@ def test(
         will be given. Default: ``True``.
 
         .. versionadded:: 2.0
+
     """
     # TODO: really need better tooling around these patterns
     # TODO: especially the problem of wanting to be configurable, but
@@ -152,6 +153,7 @@ def coverage(
 
     .. versionchanged:: 2.4
         Added the ``additional_testers`` argument.
+
     """
     my_opts = "--cov --no-cov-on-fail --cov-report={}".format(report)
     if opts:

From ee6448d5578c5d7ca37878098ac6ce6acd6868fd Mon Sep 17 00:00:00 2001
From: mdesco-crgl <mdescoteaux@crgl.ca>
Date: Wed, 26 Aug 2026 18:13:02 -0700
Subject: [PATCH 6/6] Pin Sphinx below 9 and drop the workarounds it forced

Sphinx 9 retired the class-based Documenter API that invocations.autodoc
extends. Registered documenters no longer take part in automodule member
dispatch, so tasks stop appearing in the output, and the nitpick docs build
fails on an unresolvable DocumenterBridge reference.

Cap the requirement at sphinx<9, then revert the changes that worked around
the breakage: the autodoc.py rewrite, the xfail markers on the autodoc tests,
the ANSI stripping in the release tests, and the docstring churn.

The 6 release colorization tests fail only under bare pytest, which has no
pty. CI runs them through 'inv test', which sets --capture=sys and a pty.
---
 docs/changelog.rst                            |   6 +
 docs/conf.py                                  |   4 +-
 invocations/autodoc.py                        | 133 +++++------
 invocations/ci.py                             |   5 +-
 invocations/packaging/release.py              |  12 -
 .../packaging/semantic_version_monkey.py      |   1 +
 invocations/packaging/vendorize.py            |   1 -
 invocations/pytest.py                         |   2 -
 pyproject.toml                                |   3 +
 pytest.ini                                    |   3 -
 tests/autodoc/_support/conf.py                |  14 +-
 tests/autodoc/_support/docs/api.rst           |   1 -
 tests/autodoc/base.py                         |  27 +--
 tests/conftest.py                             |  96 +++++++-
 tests/packaging/release.py                    | 207 +++++-------------
 15 files changed, 222 insertions(+), 293 deletions(-)

diff --git a/docs/changelog.rst b/docs/changelog.rst
index 276ad5c..3a9ba8f 100644
--- a/docs/changelog.rst
+++ b/docs/changelog.rst
@@ -2,6 +2,12 @@
 Changelog
 =========
 
+- :support:`45` Require ``pip>=26.1``, which fixes several CVEs reported
+  against older pip releases. pip 26.1 needs Python 3.10, so Python 3.9 is no
+  longer supported.
+- :support:`-` Require ``sphinx<9``. Sphinx 9 retired the class-based
+  ``Documenter`` API that ``invocations.autodoc`` extends, so tasks stop
+  showing up in ``automodule`` output when it is installed.
 - :feature:`-` Updated the ``--clean`` flag in ``packaging.release.build`` to
   clean any ``build/`` directories in the source root, on top of the previous
   behavior of cleaning out ``dist/``. This helps prevent wacky state bleed
diff --git a/docs/conf.py b/docs/conf.py
index 55c6ed7..ac06560 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -60,9 +60,9 @@
     dirname(__file__), "..", "..", "invoke", "sites", "docs", "_build"
 )
 if not on_dev:
-    inv_target = "http://docs.pyinvoke.org/en/latest/"
+    inv_target = "https://docs.pyinvoke.org/en/latest/"
 # Put them all together, + Python core
 intersphinx_mapping = {
     "python": ("https://docs.python.org/3/", None),
-    "invoke": ("https://docs.pyinvoke.org/en/stable/", None),
+    "invoke": (inv_target, None),
 }
diff --git a/invocations/autodoc.py b/invocations/autodoc.py
index b40a796..fbff267 100644
--- a/invocations/autodoc.py
+++ b/invocations/autodoc.py
@@ -6,101 +6,76 @@
 allows Sphinx's `autodoc`_ functionality to see and document
 Invoke tasks and similar Invoke objects.
 
+.. note::
+    This functionality is mostly useful for redistributable/reusable tasks
+    which have been defined as importable members of some Python package or
+    module, as opposed to "local-only" tasks that live in a single project's
+    ``tasks.py``.
+
+    However, it will work for any tasks that Sphinx autodoc can import, so in a
+    pinch you could for example tweak ``sys.path`` in your Sphinx ``conf.py``
+    to get it loading up a "local" tasks file for import.
+
 To use:
-- Add ``"invocations.autodoc"`` to your Sphinx ``conf.py``'s ``extensions``.
-- Use ``.. automodule:: myproject.tasks`` with ``:members:``.
-"""
 
-import inspect
-from sphinx.ext import autodoc
+- Add ``"invocations.autodoc"`` to your Sphinx ``conf.py``'s ``extensions``
+  list.
+- Use Sphinx autodoc's ``automodule`` directive normally, aiming it at your
+  tasks module(s), e.g. ``.. automodule:: myproject.tasks`` in some ``.rst``
+  document of your choosing.
+
+    - As noted above, this only works for modules that are importable, like any
+      other Sphinx autodoc use case.
+    - Unless you want to opt-in which module members get documented, use
+      ``:members:`` or add ``"members": True`` to your ``conf.py``'s
+      ``autodoc_default_options``.
+    - By default, only tasks with docstrings will be picked up, unless you also
+      give the ``:undoc-members:`` flag or add ``:undoc-members:`` / add
+      ``"undoc-members": True`` to ``autodoc_default_options``.
+    - Please see the `autodoc`_ docs for details on these settings and more!
 
-# Compatibility layer for signature stringification
-try:
-    from sphinx.util import inspect as sphinx_inspect
+- Build your docs, and you should see your tasks showing up as documented
+  functions in the result.
 
-    stringify = sphinx_inspect.stringify_signature
-except (ImportError, AttributeError):
-    try:
-        stringify = autodoc.stringify_signature
-    except AttributeError:
 
-        def stringify(x):
-            return str(x)
+.. _autodoc: http://www.sphinx-doc.org/en/master/ext/autodoc.html
+"""
+
+import inspect
 
+from invoke import Task
 
-class TaskDocumenter(autodoc.ModuleLevelDocumenter):
-    """
-    Custom autodoc documenter for Invoke Task objects.
+# For sane mock patching. Meh.
+from sphinx.ext import autodoc
 
-    Inherits from ModuleLevelDocumenter to ensure tasks are discovered in
-    modules without triggering DataDocumenter's ':value:' header logic,
-    which causes errors in standard function directives.
-    """
 
+class TaskDocumenter(
+    autodoc.DocstringSignatureMixin, autodoc.ModuleLevelDocumenter
+):
     objtype = "task"
     directivetype = "function"
-    priority = 50
 
     @classmethod
     def can_document_member(cls, member, membername, isattr, parent):
-        from invoke import Task
-
-        # Identify Invoke tasks by their characteristic attributes or type
-        return (
-            isinstance(member, Task)
-            or hasattr(member, "body")
-            and hasattr(member, "argspec")
-        )
-
-    def import_object(self, **kwargs):
-        # Import the Task instance,
-        # then store the wrapped function for inspection
-        success = super().import_object(**kwargs)
-        if success and hasattr(self.object, "body"):
-            self.wrapped_function = self.object.body
-        return success
-
-    def get_object_members(self, want_all):
-        # Tasks are atomic; they have no child members to document
-        return False, []
-
-    def format_args(self, **kwargs):
-        try:
-            sig = inspect.signature(self.object.body)
-            return stringify(sig)
-        except Exception:
-            return None
-
-    def format_signature(self, **kwargs):
-        # Extract signature from the wrapped function body
-        try:
-            sig = inspect.signature(self.wrapped_function)
-            return stringify(sig)
-        except Exception:
-            return ""
-
-    def add_directive_header(self, sig):
-        # Write the standard header (.. py:function:: name(args))
-        # Note: 3.10+ adds :value: which is incompatible with py:function
-        super().add_directive_header(sig)
-
-    def add_content(self, more_content, no_docstring=False):
-        # Manually inject the docstring from the wrapped function
-        sourcename = self.get_sourcename()
-        docstring = inspect.getdoc(self.wrapped_function)
-
-        if docstring:
-            for line in docstring.splitlines():
-                self.add_line(line, sourcename)
-
-        # Call parent with no_docstring=True to avoid redundant lookup attempts
-        try:
-            super().add_content(more_content, no_docstring=True)
-        except TypeError:
-            super().add_content(more_content)
+        return isinstance(member, Task)
+
+    def format_args(self):
+        function = self.object.body
+        # TODO: consider extending (or adding a sibling to) Task.argspec so it
+        # preserves more of the full argspec tuple.
+        # TODO: whether to preserve the initial context argument is an open
+        # question. For now, it will appear, but only pending invoke#170 -
+        # after which point "call tasks as raw functions" may be less common.
+        # TODO: also, it may become moot-ish if we turn this all into emission
+        # of custom domain objects and/or make the CLI arguments the focus
+        return autodoc.stringify_signature(inspect.signature(function))
+
+    def document_members(self, all_members=False):
+        # Neuter this so superclass bits don't introspect & spit out autodoc
+        # directives for task attributes. Most of that's not useful.
+        pass
 
 
 def setup(app):
     app.setup_extension("sphinx.ext.autodoc")
     app.add_autodocumenter(TaskDocumenter)
-    return {"version": "1.0", "parallel_read_safe": True}
diff --git a/invocations/ci.py b/invocations/ci.py
index 12b6dd6..56234a5 100644
--- a/invocations/ci.py
+++ b/invocations/ci.py
@@ -56,10 +56,9 @@ def sudo_run(c, command):
     """
     Run some command under CI-oriented sudo subshell/virtualenv.
 
-    :param str command: Command string to run,
-        e.g. ``inv coverage``, ``inv integration``, etc.
+    :param str command:
+        Command string to run, e.g. ``inv coverage``, ``inv integration``, etc.
         (Does not necessarily need to be an Invoke task, but...)
-
     """
     # NOTE: due to circle sudoers config, circleci user can't do "sudo -u" w/o
     # password prompt. However, 'sudo su' seems to work just as well...
diff --git a/invocations/packaging/release.py b/invocations/packaging/release.py
index 1889490..b35b132 100644
--- a/invocations/packaging/release.py
+++ b/invocations/packaging/release.py
@@ -287,10 +287,8 @@ def all_(c, dry_run=False):
     .. versionchanged:: 2.1
         Expanded functionality to run ``publish`` and ``push`` as well as
         ``prepare``.
-
     .. versionchanged:: 2.1
         Added the ``dry_run`` flag.
-
     """
     prepare(c, dry_run=dry_run)
     publish(c, dry_run=dry_run)
@@ -311,10 +309,8 @@ def prepare(c, dry_run=False):
 
     .. versionchanged:: 2.1
         Added the ``dry_run`` parameter.
-
     .. versionchanged:: 2.1
         Generate annotated git tags instead of lightweight ones.
-
     """
     # Print dry-run/status/actions-to-take data & grab programmatic result
     # TODO: maybe expand the enum-based stuff to have values that split up
@@ -611,21 +607,16 @@ def build(
     .. versionchanged:: 2.0
         ``clean`` now defaults to False instead of True, cleans both dist and
         build dirs when True, and honors configuration.
-
     .. versionchanged:: 2.0
         ``wheel`` now defaults to True instead of False.
-
     .. versionchanged:: 4.0
         Switched to using ``pypa/build`` and made related changes to args
         (eg, ``directory`` now only controls dist output location).
-
     .. versionchanged:: 4.1
         Added the ``opts`` argument.
-
     .. versionchanged:: 4.1
         Updated ``--clean`` to additionally remove any ``build/`` directories
         within the source root.
-
     """
     # Config hooks
     config = c.config.get("packaging", {})
@@ -724,7 +715,6 @@ def publish(
 
         Defaults to a temporary directory which is cleaned up after the run
         finishes.
-
     """
     # Don't hide by default, this step likes to be verbose most of the time.
     c.config.run.hide = False
@@ -784,7 +774,6 @@ def test_install(c, directory, verbose=False, skip_import=False):
     :param bool skip_import:
         If True, don't try importing the installed module or checking it for
         type hints.
-
     """
     # TODO: wants contextmanager or similar for only altering a setting within
     # a given scope or block - this may pollute subsequent subroutine calls
@@ -863,7 +852,6 @@ def upload(c, directory, index=None, sign=False, dry_run=False):
 
         This also prevents cleanup of the temporary build/dist directories, so
         you can examine the build artifacts.
-
     """
     archives = get_archives(directory)
     # Sign each archive in turn
diff --git a/invocations/packaging/semantic_version_monkey.py b/invocations/packaging/semantic_version_monkey.py
index a052ab9..0713c99 100644
--- a/invocations/packaging/semantic_version_monkey.py
+++ b/invocations/packaging/semantic_version_monkey.py
@@ -5,6 +5,7 @@
 or distributing our own fork.
 """
 
+
 from semantic_version import Version
 
 
diff --git a/invocations/packaging/vendorize.py b/invocations/packaging/vendorize.py
index fe3464b..b3468c4 100644
--- a/invocations/packaging/vendorize.py
+++ b/invocations/packaging/vendorize.py
@@ -1,7 +1,6 @@
 """
 Tasks for importing external code into a vendor subdirectory.
 """
-
 from os import chdir
 from pathlib import Path
 from shutil import copy, copytree, rmtree
diff --git a/invocations/pytest.py b/invocations/pytest.py
index aa09885..dc30f3a 100644
--- a/invocations/pytest.py
+++ b/invocations/pytest.py
@@ -59,7 +59,6 @@ def test(
         will be given. Default: ``True``.
 
         .. versionadded:: 2.0
-
     """
     # TODO: really need better tooling around these patterns
     # TODO: especially the problem of wanting to be configurable, but
@@ -153,7 +152,6 @@ def coverage(
 
     .. versionchanged:: 2.4
         Added the ``additional_testers`` argument.
-
     """
     my_opts = "--cov --no-cov-on-fail --cov-report={}".format(report)
     if opts:
diff --git a/pyproject.toml b/pyproject.toml
index f238449..d0f7449 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -22,6 +22,9 @@ dependencies = [
   "pip>=26.1",
   "releases>=1.6",
   "semantic_version>=2.4,<2.7",
+  # Our autodoc extension subclasses Sphinx's class-based Documenter API,
+  # which Sphinx 9 retired for automodule member dispatch.
+  "sphinx<9",
   "tabulate>=0.7.5",
   "tqdm>=4.8.1",
   "twine>=1.15",
diff --git a/pytest.ini b/pytest.ini
index 1e6103b..f51e190 100644
--- a/pytest.ini
+++ b/pytest.ini
@@ -1,6 +1,3 @@
 [pytest]
 testpaths = tests
 python_files = *
-pythonpath = .
-
-addopts = "-ra --capture=sys"
\ No newline at end of file
diff --git a/tests/autodoc/_support/conf.py b/tests/autodoc/_support/conf.py
index 52fb773..a33252e 100644
--- a/tests/autodoc/_support/conf.py
+++ b/tests/autodoc/_support/conf.py
@@ -1,16 +1,10 @@
+from os.path import dirname
 import sys
-from os.path import dirname, abspath, join
 
-# Basic path setup
-support = abspath(dirname(__file__))
-repo_root = abspath(join(support, "..", "..", ".."))
 
-if repo_root not in sys.path:
-    sys.path.insert(0, repo_root)
-if support not in sys.path:
-    sys.path.insert(0, support)
+# Add local support dir to path so tasks modules may be imported by autodoc
+sys.path.insert(0, dirname(__file__))
 
 master_doc = "index"
 extensions = ["invocations.autodoc"]
-autodoc_default_options = {"members": True}
-project = "Invocations"
+autodoc_default_options = dict(members=True)
diff --git a/tests/autodoc/_support/docs/api.rst b/tests/autodoc/_support/docs/api.rst
index c15ead3..96e9b9c 100644
--- a/tests/autodoc/_support/docs/api.rst
+++ b/tests/autodoc/_support/docs/api.rst
@@ -3,4 +3,3 @@ API
 ===
 
 .. automodule:: mytasks
-    :members:
\ No newline at end of file
diff --git a/tests/autodoc/base.py b/tests/autodoc/base.py
index 0979e26..efe340c 100644
--- a/tests/autodoc/base.py
+++ b/tests/autodoc/base.py
@@ -1,7 +1,7 @@
 from os.path import join, dirname
 import re
 import shutil
-import pytest
+
 from unittest.mock import Mock
 
 from invoke import Context
@@ -16,19 +16,10 @@ def _build():
     support = join(dirname(__file__), "_support")
     docs = join(support, "docs")
     build = join(support, "_build")
-    # Add -E to force fresh build and -v for verbosity
-    command = "sphinx-build -v -E -c {} -W {} {}".format(support, docs, build)
-
-    print("\n--- SPHINX BUILD LOG ---")
-    # Use warn=True so pytest doesn't crash here, allowing us to see the output
-    result = c.run(command, in_stream=False, warn=True)
-
-    if result.failed:
-        # This will print to your terminal during 'uv run pytest -s'
-        print(result.stdout)
-        print(result.stderr)
-        raise RuntimeError("Sphinx build failed! check logs above.")
-
+    command = "sphinx-build -c {} -W {} {}".format(support, docs, build)
+    with c.cd(support):
+        # Turn off stdin mirroring to avoid irritating pytest.
+        c.run(command, in_stream=False)
     return build
 
 
@@ -69,18 +60,10 @@ def undocumented_members_do_not_appear_by_default(self):
         # This really just tests basic Sphinx/autodoc stuff for now...meh
         assert "undocumented" not in self.api_docs
 
-    @pytest.mark.xfail(
-        reason="Autodoc TaskDocumenter only works for python 3.10",
-        strict=False,
-    )
     def base_case_of_no_argument_docstringed_task(self):
         for sentinel in ("base_case", "smallest possible task"):
             assert sentinel in self.api_docs
 
-    @pytest.mark.xfail(
-        reason="Autodoc TaskDocumenter only works for python 3.10",
-        strict=False,
-    )
     def simple_case_of_single_argument_task(self):
         # TODO: OK we really need something that scales better soon re:
         # viewing the output as a non-HTML string / something that is not
diff --git a/tests/conftest.py b/tests/conftest.py
index 82dd52b..663d938 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,3 +1,6 @@
+from pathlib import Path
+from unittest.mock import patch, Mock, MagicMock, call
+
 from pytest import fixture
 from invoke import MockContext
 
@@ -9,7 +12,94 @@
 
 @fixture
 def ctx():
+    # TODO: this would be a nice convenience in MockContext itself, though most
+    # uses of it really just want responses-style "assert if expected calls did
+    # not happen" behavior
+    MockContext.run_command = property(lambda self: self.run.call_args[0][0])
+    return MockContext(run=True)
+
+
+class Mocks:
+    pass
+
+
+# For use in packaging.release.publish tests
+@fixture
+def fakepub(mocker):
+    mocks = Mocks()
+    mocks.rmtree = mocker.patch("invocations.util.rmtree")
+    mocks.twine_check = mocker.patch(
+        "invocations.packaging.release.twine_check", return_value=False
+    )
+    mocks.upload = mocker.patch("invocations.packaging.release.upload")
+    mocks.build = mocker.patch("invocations.packaging.release.build")
+    mocks.test_install = mocker.patch(
+        "invocations.packaging.release.test_install"
+    )
+    mocks.mkdtemp = mocker.patch("invocations.util.mkdtemp")
+    mocks.mkdtemp.return_value = "tmpdir"
     c = MockContext(run=True)
-    # Patch the INSTANCE, not the CLASS
-    type(c).run_command = property(lambda self: self.run.call_args[0][0])
-    return c
+    yield c, mocks
+
+
+# For use in packaging.release.test_install tests
+@fixture
+def install():
+    with patch("invocations.packaging.release.pip_version", "lmao"), patch(
+        "invocations.util.rmtree", Mock("rmtree")
+    ), patch(
+        "invocations.packaging.release._find_package", lambda c: "foo"
+    ), patch(
+        "venv.EnvBuilder"
+    ) as builder, patch(
+        "invocations.util.mkdtemp"
+    ) as mkdtemp, patch(
+        "invocations.packaging.release.get_archives"
+    ) as get_archives, patch(
+        "invocations.packaging.release.Path"
+    ) as fakePath:
+        # Setup & run
+        c = MockContext(run=True, repeat=True)
+        mkdtemp.return_value = "tmpdir"
+        get_archives.return_value = ["foo.tgz", "foo.whl"]
+
+        # I hate this but don't see a cleaner way to mock out a nested
+        # 'exists()' w/o breaking everything else, or using a real tmpdir.
+        def set_exists(value):
+            def fakediv(self, arg):
+                root = Path(mkdtemp.return_value)
+                bindir = root / "bin"
+                if arg == "bin":
+                    return bindir
+                elif arg == "pip":
+                    return bindir / "pip"
+                elif arg == "python":
+                    return bindir / "python"
+                elif arg == "py.typed":
+                    path = Path("foo") / "py.typed"
+                    ret = MagicMock(wraps=path)
+                    ret.exists.return_value = value
+                    return ret
+
+            fakePath.return_value.__truediv__ = fakediv
+
+        c.set_exists = set_exists  # so caller can run it
+        c.set_exists(False)  # default
+        yield c
+        # Create factory
+        builder.assert_called_once_with(with_pip=True)
+        # Used helper to get artifacts
+        get_archives.assert_called_once_with("whatever")
+        # venv factory ran twice in some temp dir
+        builder.return_value.create.assert_has_calls(
+            [call("tmpdir"), call("tmpdir")]
+        )
+        pip_base = "tmpdir/bin/pip install --disable-pip-version-check"
+        for wanted in (
+            # Pip installed to same version as running interpreter's pip
+            call("tmpdir/bin/pip install pip==lmao"),
+            # Archives installed into venv
+            call("{} foo.tgz".format(pip_base)),
+            call("{} foo.whl".format(pip_base)),
+        ):
+            assert wanted in c.run.mock_calls
diff --git a/tests/packaging/release.py b/tests/packaging/release.py
index 7dcfd56..e54dd21 100644
--- a/tests/packaging/release.py
+++ b/tests/packaging/release.py
@@ -3,14 +3,13 @@
 from pathlib import Path
 import re
 import sys
-from unittest.mock import patch, Mock, MagicMock, call
-
 
 from invoke.vendor.lexicon import Lexicon
 from invoke import MockContext, Result, Config, Exit
 from docutils.utils import Reporter
+from unittest.mock import patch, call
 import pytest
-from pytest import skip, fixture
+from pytest import skip
 from pytest_relaxed import trap, raises
 
 from invocations.packaging.semantic_version_monkey import Version
@@ -36,100 +35,6 @@
 )
 
 
-class Mocks:
-    pass
-
-
-# For use in packaging.release.publish tests
-@fixture
-def _fakepub(mocker):
-    mocks = Mocks()
-    mocks.rmtree = mocker.patch("invocations.util.rmtree")
-    mocks.twine_check = mocker.patch(
-        "invocations.packaging.release.twine_check", return_value=False
-    )
-    mocks.upload = mocker.patch("invocations.packaging.release.upload")
-    mocks.build = mocker.patch("invocations.packaging.release.build")
-    mocks.test_install = mocker.patch(
-        "invocations.packaging.release.test_install"
-    )
-    mocks.mkdtemp = mocker.patch("invocations.util.mkdtemp")
-    mocks.mkdtemp.return_value = "tmpdir"
-    c = MockContext(run=True)
-    yield c, mocks
-
-
-# For use in packaging.release.test_install tests
-@fixture
-def _install():
-    with (
-        patch("invocations.packaging.release.pip_version", "lmao"),
-        patch("invocations.util.rmtree", Mock("rmtree")),
-        patch("invocations.packaging.release._find_package", lambda c: "foo"),
-        patch("venv.EnvBuilder") as builder,
-        patch("invocations.util.mkdtemp") as mkdtemp,
-        patch("invocations.packaging.release.get_archives") as get_archives,
-        patch("invocations.packaging.release.Path") as fakePath,
-    ):
-        # Setup & run
-        c = MockContext(run=True, repeat=True)
-        mkdtemp.return_value = "tmpdir"
-        get_archives.return_value = ["foo.tgz", "foo.whl"]
-
-        # I hate this but don't see a cleaner way to mock out a nested
-        # 'exists()' w/o breaking everything else, or using a real tmpdir.
-        def set_exists(value):
-            def fakediv(self, arg):
-                root = Path(mkdtemp.return_value)
-                bindir = root / "bin"
-                if arg == "bin":
-                    return bindir
-                elif arg == "pip":
-                    return bindir / "pip"
-                elif arg == "python":
-                    return bindir / "python"
-                elif arg == "py.typed":
-                    path = Path("foo") / "py.typed"
-                    ret = MagicMock(wraps=path)
-                    ret.exists.return_value = value
-                    return ret
-
-            fakePath.return_value.__truediv__ = fakediv
-
-        c.set_exists = set_exists  # so caller can run it
-        c.set_exists(False)  # default
-        yield c
-        # Create factory
-        builder.assert_called_once_with(with_pip=True)
-        # Used helper to get artifacts
-        get_archives.assert_called_once_with("whatever")
-        # venv factory ran twice in some temp dir
-        builder.return_value.create.assert_has_calls(
-            [call("tmpdir"), call("tmpdir")]
-        )
-        pip_base = "tmpdir/bin/pip install --disable-pip-version-check"
-        for wanted in (
-            # Pip installed to same version as running interpreter's pip
-            call("tmpdir/bin/pip install pip==lmao"),
-            # Archives installed into venv
-            call("{} foo.tgz".format(pip_base)),
-            call("{} foo.whl".format(pip_base)),
-        ):
-            assert wanted in c.run.mock_calls
-
-
-def _strip_ansi(text):
-    # 1. Strips CSI sequences (colors, etc): \x1b[ ... m
-    # 2. Strips character set sequences (like yours): \x1b( ...
-    ansi_escape = re.compile(
-        r"""
-        \x1b[\[()][0-9;]*[a-zA-Z]
-    """,
-        re.VERBOSE,
-    )
-    return ansi_escape.sub("", text)
-
-
 class release_line_:
     def assumes_bugfix_if_release_branch(self):
         c = MockContext(run=Result("2.7"))
@@ -284,7 +189,6 @@ def next_minor_of_feature_release(self):
 # NOTE: needs to not shadow any real imported module name!
 FAKE_PACKAGE = "fakey_mcfakerson_not_real_in_any_way"
 
-
 # NOTE: can't easily slap this on the test class itself due to using inner
 # classes. If we can get the inner classes to not only copy attributes but also
 # decorators (seems unlikely?), we could organize more "naturally".
@@ -639,6 +543,7 @@ def _run_prepare(c, mute=True, **kwargs):
 
 
 class prepare_:
+
     # NOTE: mostly testing the base case of 'everything needs updating',
     # all the permutations are tested elsewhere.
     _branch = "1.1"
@@ -862,36 +767,28 @@ class component_state_enums_contain_human_readable_values:
     class changelog:
         def okay(self):
             expected = "\x1b[32m\u2714 no unreleased issues\x1b(B\x1b[m"
-            assert _strip_ansi(Changelog.OKAY.value) == _strip_ansi(expected)
+            assert Changelog.OKAY.value == expected
 
         def needs_release(self):
             expected = "\x1b[31m\u2718 needs :release: entry\x1b(B\x1b[m"
-            assert _strip_ansi(Changelog.NEEDS_RELEASE.value) == _strip_ansi(
-                expected
-            )
+            assert Changelog.NEEDS_RELEASE.value == expected
 
     class version_file:
         def okay(self):
             expected = "\x1b[32m\u2714 version up to date\x1b(B\x1b[m"
-            assert _strip_ansi(VersionFile.OKAY.value) == _strip_ansi(expected)
+            assert VersionFile.OKAY.value == expected
 
         def needs_bump(self):
             expected = "\x1b[31m\u2718 needs version bump\x1b(B\x1b[m"
-            assert _strip_ansi(VersionFile.NEEDS_BUMP.value) == _strip_ansi(
-                expected
-            )
+            assert VersionFile.NEEDS_BUMP.value == expected
 
     class tag:
         def okay(self):
-            assert _strip_ansi(Tag.OKAY.value) == _strip_ansi(
-                "\x1b[32m\u2714 all set\x1b(B\x1b[m"
-            )
+            assert Tag.OKAY.value == "\x1b[32m\u2714 all set\x1b(B\x1b[m"
 
         def needs_cutting(self):
             expected = "\x1b[31m\u2718 needs cutting\x1b(B\x1b[m"
-            assert _strip_ansi(Tag.NEEDS_CUTTING.value) == _strip_ansi(
-                expected
-            )
+            assert Tag.NEEDS_CUTTING.value == expected
 
 
 @contextmanager
@@ -1114,8 +1011,8 @@ class _Kaboom(Exception):
 
 class publish_:
     class base_case:
-        def does_all_the_things(self, _fakepub):
-            c, mocks = _fakepub
+        def does_all_the_things(self, fakepub):
+            c, mocks = fakepub
             # Execution
             publish(c)
             # Unhides stdout
@@ -1136,14 +1033,14 @@ def does_all_the_things(self, _fakepub):
             # Tmpdir cleaned up
             mocks.rmtree.assert_called_once_with("tmpdir")
 
-        def cleans_up_on_error(self, _fakepub):
-            c, mocks = _fakepub
+        def cleans_up_on_error(self, fakepub):
+            c, mocks = fakepub
             mocks.build.side_effect = _Kaboom
             with pytest.raises(_Kaboom):
                 publish(MockContext(run=True))
             mocks.rmtree.assert_called_once_with(mocks.mkdtemp.return_value)
 
-        def monkeypatches_readme_renderer(self, _fakepub):
+        def monkeypatches_readme_renderer(self, fakepub):
             # Happens at module load time but is just a data structure change
             import readme_renderer.rst
 
@@ -1157,105 +1054,105 @@ def monkeypatches_readme_renderer(self, _fakepub):
             )
 
     class index:
-        def passed_to_upload(self, _fakepub):
-            c, mocks = _fakepub
+        def passed_to_upload(self, fakepub):
+            c, mocks = fakepub
             publish(c, index="dev")
             assert mocks.upload.call_args[1]["index"] == "dev"
 
-        def honors_config(self, _fakepub):
-            c, mocks = _fakepub
+        def honors_config(self, fakepub):
+            c, mocks = fakepub
             c.config.packaging = dict(index="prod")
             publish(c)
             assert mocks.upload.call_args[1]["index"] == "prod"
 
-        def kwarg_beats_config(self, _fakepub):
-            c, mocks = _fakepub
+        def kwarg_beats_config(self, fakepub):
+            c, mocks = fakepub
             c.config.packaging = dict(index="prod")
             publish(c, index="dev")
             assert mocks.upload.call_args[1]["index"] == "dev"
 
     class sign:
-        def passed_to_upload(self, _fakepub):
-            c, mocks = _fakepub
+        def passed_to_upload(self, fakepub):
+            c, mocks = fakepub
             publish(c, sign=True)
             assert mocks.upload.call_args[1]["sign"] is True
 
-        def honors_config(self, _fakepub):
-            c, mocks = _fakepub
+        def honors_config(self, fakepub):
+            c, mocks = fakepub
             c.config.packaging = dict(sign=True)
             publish(c)
             assert mocks.upload.call_args[1]["sign"] is True
 
-        def kwarg_beats_config(self, _fakepub):
-            c, mocks = _fakepub
+        def kwarg_beats_config(self, fakepub):
+            c, mocks = fakepub
             c.config.packaging = dict(sign=False)
             publish(c, sign=True)
             assert mocks.upload.call_args[1]["sign"] is True
 
     class sdist:
-        def defaults_True_and_passed_to_build(self, _fakepub):
-            c, mocks = _fakepub
+        def defaults_True_and_passed_to_build(self, fakepub):
+            c, mocks = fakepub
             publish(c)
             assert mocks.build.call_args[1]["sdist"] is True
 
-        def may_be_overridden(self, _fakepub):
-            c, mocks = _fakepub
+        def may_be_overridden(self, fakepub):
+            c, mocks = fakepub
             publish(c, sdist=False)
             assert mocks.build.call_args[1]["sdist"] is False
 
     class wheel:
-        def defaults_True_and_passed_to_build(self, _fakepub):
-            c, mocks = _fakepub
+        def defaults_True_and_passed_to_build(self, fakepub):
+            c, mocks = fakepub
             publish(c)
             assert mocks.build.call_args[1]["wheel"] is True
 
-        def may_be_overridden(self, _fakepub):
-            c, mocks = _fakepub
+        def may_be_overridden(self, fakepub):
+            c, mocks = fakepub
             publish(c, wheel=False)
             assert mocks.build.call_args[1]["wheel"] is False
 
-    def directory_affects_tmpdir(self, _fakepub):
-        c, mocks = _fakepub
+    def directory_affects_tmpdir(self, fakepub):
+        c, mocks = fakepub
         publish(c, directory="explicit")
         assert not mocks.mkdtemp.called
         assert mocks.build.call_args[1]["directory"] == "explicit"
 
     class dry_run:
-        def causes_tmpdir_cleanup_to_be_skipped(self, _fakepub):
-            c, mocks = _fakepub
+        def causes_tmpdir_cleanup_to_be_skipped(self, fakepub):
+            c, mocks = fakepub
             publish(c, dry_run=True)
             assert not mocks.rmtree.called
 
-        def causes_tmpdir_cleanup_to_be_skipped_on_exception(self, _fakepub):
-            c, mocks = _fakepub
+        def causes_tmpdir_cleanup_to_be_skipped_on_exception(self, fakepub):
+            c, mocks = fakepub
             mocks.build.side_effect = _Kaboom
             with pytest.raises(_Kaboom):
                 publish(c, dry_run=True)
             assert not mocks.rmtree.called
 
-        def passed_to_upload(self, _fakepub):
-            c, mocks = _fakepub
+        def passed_to_upload(self, fakepub):
+            c, mocks = fakepub
             publish(c, dry_run=True)
             assert mocks.upload.call_args[1]["dry_run"] is True
 
 
 class test_install_:
-    def installs_all_archives_in_fresh_venv_with_matching_pip(self, _install):
-        c = _install
+    def installs_all_archives_in_fresh_venv_with_matching_pip(self, install):
+        c = install
         # Basic test, uses guts of fixture
         install_test_task(c, directory="whatever")
         # Import attempt was made
         c.run.assert_any_call("tmpdir/bin/python -c 'import foo'")
 
-    def skips_import_test_when_asked_to(self, _install):
-        c = _install
+    def skips_import_test_when_asked_to(self, install):
+        c = install
         install_test_task(c, directory="whatever", skip_import=True)
         # No import attempt
         for unwanted in (call("tmpdir/bin/python -c 'import foo'"),):
             assert unwanted not in c.run.mock_calls
 
-    def does_mypy_import_when_py_typed_present(self, _install):
-        c = _install
+    def does_mypy_import_when_py_typed_present(self, install):
+        c = install
         # Mock out the pathlib exists call as positive (default is negative)
         c.set_exists(True)
         install_test_task(c, directory="whatever")
@@ -1265,8 +1162,8 @@ def does_mypy_import_when_py_typed_present(self, _install):
         # all these mocks, jeez
         c.run.assert_any_call("cd tmpdir && tmpdir/bin/mypy -c 'import foo'")
 
-    def skips_mypy_import_when_no_py_typed(self, _install):
-        c = _install
+    def skips_mypy_import_when_no_py_typed(self, install):
+        c = install
         # Mock out the pathlib exists call as explicitly false, why not
         c.set_exists(False)
         install_test_task(c, directory="whatever")
@@ -1277,8 +1174,8 @@ def skips_mypy_import_when_no_py_typed(self, _install):
         ):
             assert unwanted not in c.run.mock_calls
 
-    def skips_mypy_import_when_skipping_regular_import(self, _install):
-        c = _install
+    def skips_mypy_import_when_skipping_regular_import(self, install):
+        c = install
         c.set_exists(True)
         install_test_task(c, directory="whatever", skip_import=True)
         # Mypy NOT installed or executed