Restore pre-commit to working order

Author: smurfix

Makefile

@@ -10,4 +10,3 @@ else
 	@echo "Please use 'python setup.py'."
 	@exit 1
 endif
-

src/asyncclick/core.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import anyio
 import collections.abc as cabc
 import enum
 import errno
@@ -10,17 +9,19 @@
 import typing as t
 from collections import abc
 from collections import Counter
-from contextlib import asynccontextmanager
 from contextlib import AbstractContextManager
-from contextlib import contextmanager
+from contextlib import asynccontextmanager
 from contextlib import AsyncExitStack
+from contextlib import contextmanager
 from functools import update_wrapper
 from gettext import gettext as _
 from gettext import ngettext
 from inspect import iscoroutine
 from itertools import repeat
 from types import TracebackType
 
+import anyio
+
 from . import types
 from ._utils import FLAG_NEEDS_VALUE
 from ._utils import UNSET
@@ -48,6 +49,8 @@
 from .utils import PacifyFlushWrapper
 
 if t.TYPE_CHECKING:
+    from collections.abc import Awaitable
+
     from .shell_completion import CompletionItem
 
 F = t.TypeVar("F", bound="t.Callable[..., t.Any]")
@@ -455,7 +458,7 @@ def protected_args(self) -> list[str]:
         )
         return self._protected_args
 
-    async def to_info_dict(self) -> t.Dict[str, t.Any]:
+    async def to_info_dict(self) -> dict[str, t.Any]:
         """Gather information that could be useful for a tool generating
         user-facing documentation. This traverses the entire CLI
         structure.
@@ -490,7 +493,9 @@ async def __aexit__(
         self._depth -= 1
         exit_result: bool | None = None
         if self._depth == 0:
-            exit_result = await self._aclose_with_exception_info(exc_type, exc_value, tb)
+            exit_result = await self._aclose_with_exception_info(
+                exc_type, exc_value, tb
+            )
         pop_context()
         return exit_result
 
@@ -603,7 +608,9 @@ def cli(ctx):
         """
         return self._exit_stack.enter_context(context_manager)
 
-    def with_async_resource(self, context_manager: t.AsyncContextManager[V]) -> "t.Awaitable[V]":
+    def with_async_resource(
+        self, context_manager: t.AsyncContextManager[V]
+    ) -> t.Awaitable[V]:
         """Register a resource as if it were used in an ``async with``
         statement. The resource will be cleaned up when the context is
         popped.
@@ -642,11 +649,13 @@ def call_on_close(self, f: t.Callable[..., t.Any]) -> t.Callable[..., t.Any]:
 
         :param f: The function to execute on teardown.
         """
+
         async def _f():
             res = f()
             if iscoroutine(res):
                 res = await res
             return res
+
         return self._exit_stack.push_async_callback(_f)
 
     async def aclose(self) -> None:
@@ -669,7 +678,9 @@ async def _aclose_with_exception_info(
 
         :return: Whatever ``exit_stack.__exit__()`` returns.
         """
-        exit_result = await t.cast(t.AsyncContextManager[t.Any], self._exit_stack).__aexit__(exc_type, exc_value, tb)
+        exit_result = await t.cast(
+            t.AsyncContextManager[t.Any], self._exit_stack
+        ).__aexit__(exc_type, exc_value, tb)
         # In case the context is reused, create a new exit stack.
         self._exit_stack = AsyncExitStack()
 
@@ -796,14 +807,24 @@ def _make_sub_context(self, command: Command) -> Context:
 
     @t.overload
     async def invoke(
-        self, callback: t.Callable[..., V|Awaitable[V]], /, *args: t.Any, **kwargs: t.Any
+        self,
+        callback: t.Callable[..., V | Awaitable[V]],
+        /,
+        *args: t.Any,
+        **kwargs: t.Any,
     ) -> V: ...
 
     @t.overload
-    async def invoke(self, callback: Command, /, *args: t.Any, **kwargs: t.Any) -> t.Any: ...
+    async def invoke(
+        self, callback: Command, /, *args: t.Any, **kwargs: t.Any
+    ) -> t.Any: ...
 
     async def invoke(
-        self, callback: Command | t.Callable[..., V|Awaitable[V]], /, *args: t.Any, **kwargs: t.Any
+        self,
+        callback: Command | t.Callable[..., V | Awaitable[V]],
+        /,
+        *args: t.Any,
+        **kwargs: t.Any,
     ) -> t.Any | V:
         """Invokes a command callback in exactly the way it expects.  There
         are two ways to invoke this method:
@@ -1497,7 +1518,13 @@ async def _main_shell_completion(
         rv = await shell_complete(self, ctx_args, prog_name, complete_var, instruction)
         sys.exit(rv)
 
-    def __call__(self, *args: t.Any, _anyio_backend: t.Optional[str] = None, _anyio_backend_options: t.Dict[str, t.Any] = {}, **kwargs: t.Any) -> t.Any:
+    def __call__(
+        self,
+        *args: t.Any,
+        _anyio_backend: str | None = None,
+        _anyio_backend_options: dict[str, t.Any] | None = None,
+        **kwargs: t.Any,
+    ) -> t.Any:
         """Calling the command runs it in a new :mod:`anyio` event loop.
 
         If you are already inside an async event loop, call
@@ -1511,14 +1538,19 @@ def __call__(self, *args: t.Any, _anyio_backend: t.Optional[str] = None, _anyio_
 
         """
         main = self.main
-        opts:t.Dict[str, t.Any] = {}
+        opts: dict[str, t.Any] = {}
         if _anyio_backend:
             opts["backend"] = _anyio_backend
         if _anyio_backend_options:
             opts["backend_options"] = _anyio_backend_options
         return anyio.run(self._main, main, args, kwargs, **opts)
 
-    async def _main(self, main:t.Callable[..., t.Awaitable[V]], args: t.List[t.Any], kwargs: t.Dict[str, t.Any]) -> V:
+    async def _main(
+        self,
+        main: t.Callable[..., t.Awaitable[V]],
+        args: list[t.Any],
+        kwargs: dict[str, t.Any],
+    ) -> V:
         return await main(*args, **kwargs)
 
 

src/asyncclick/decorators.py

@@ -73,7 +73,9 @@ def new_func(ctx, *args, **kwargs):
                    remembered on the context if it's not there yet.
     """
 
-    def decorator(f: t.Callable[te.Concatenate[T, P], R]) -> t.Callable[P, t.Coroutine[t.Any, t.Any, R]]:
+    def decorator(
+        f: t.Callable[te.Concatenate[T, P], R],
+    ) -> t.Callable[P, t.Coroutine[t.Any, t.Any, R]]:
         def new_func(*args: P.args, **kwargs: P.kwargs) -> R:
             ctx = get_current_context()
 
@@ -112,7 +114,9 @@ def pass_meta_key(
     .. versionadded:: 8.0
     """
 
-    def decorator(f: t.Callable[te.Concatenate[T, P], R]) -> t.Callable[P, t.Coroutine[t.Any, t.Any, R]]:
+    def decorator(
+        f: t.Callable[te.Concatenate[T, P], R],
+    ) -> t.Callable[P, t.Coroutine[t.Any, t.Any, R]]:
         def new_func(*args: P.args, **kwargs: P.kwargs) -> t.Coroutine[t.Any, t.Any, R]:
             ctx = get_current_context()
             obj = ctx.meta[key]

src/asyncclick/shell_completion.py

@@ -268,7 +268,9 @@ def get_completion_args(self) -> tuple[list[str], str]:
         """
         raise NotImplementedError
 
-    async def get_completions(self, args: list[str], incomplete: str) -> list[CompletionItem]:
+    async def get_completions(
+        self, args: list[str], incomplete: str
+    ) -> list[CompletionItem]:
         """Determine the context and last complete command or parameter
         from the complete args. Call that object's ``shell_complete``
         method to get the completions for the incomplete value.

src/asyncclick/termui.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import anyio
 import collections.abc as cabc
 import inspect
 import io
@@ -11,6 +10,8 @@
 from gettext import gettext as _
 from inspect import iscoroutine
 
+import anyio
+
 from ._compat import isatty
 from ._compat import strip_ansi
 from .exceptions import Abort
@@ -23,6 +24,8 @@
 from .utils import LazyFile
 
 if t.TYPE_CHECKING:
+    from collections.abc import Awaitable
+
     from ._termui_impl import ProgressBar
 
 V = t.TypeVar("V")
@@ -165,9 +168,11 @@ def prompt_func(text: str) -> str:
             raise Abort() from None
 
     if blocking:
+
         async def run_prompt_func(text: str) -> str:
             return prompt_func(text)
     else:
+
         def run_prompt_func(text: str) -> Awaitable[str]:
             return anyio.to_thread.run_sync(prompt_func, text)
 

src/asyncclick/testing.py

@@ -21,6 +21,7 @@
 
     from .core import Command
 
+
 class EchoingStdin:
     def __init__(self, input: t.BinaryIO, output: t.BinaryIO) -> None:
         self._input = input
@@ -503,7 +504,9 @@ async def invoke(
                 prog_name = self.get_default_prog_name(cli)
 
             try:
-                return_value = await cli.main(args=args or (), prog_name=prog_name, **extra)
+                return_value = await cli.main(
+                    args=args or (), prog_name=prog_name, **extra
+                )
             except SystemExit as e:
                 exc_info = sys.exc_info()
                 e_code = t.cast("int | t.Any | None", e.code)

tests/conftest.py

@@ -1,32 +1,39 @@
-import pytest
-import anyio
-from functools import partial
 from threading import Thread
 
+import anyio
+import pytest
+
 from asyncclick.testing import CliRunner
 
+
 class SyncCliRunner(CliRunner):
-    def invoke(self,*a,_sync=False,**k):
+    def invoke(self, *a, _sync=False, **k):
         fn = super().invoke
         if _sync:
-            return fn(*a,**k)
+            return fn(*a, **k)
 
         # anyio now protects against nested calls, so we use a thread
         result = None
+
         def f():
-            nonlocal result,fn
+            nonlocal result, fn
+
             async def r():
-                return await fn(*a,**k)
-            result = anyio.run(r) ## , backend="trio")
-        t=Thread(target=f, name="TEST")
+                return await fn(*a, **k)
+
+            result = anyio.run(r)  ## , backend="trio")
+
+        t = Thread(target=f, name="TEST")
         t.start()
         t.join()
         return result
 
+
 @pytest.fixture(scope="function")
 def runner(request):
     return SyncCliRunner()
 
+
 @pytest.fixture(scope="function")
 def arunner(request):
     return CliRunner()

tests/test_arguments.py

@@ -8,6 +8,7 @@
 
 PY2 = False  # churn
 
+
 @pytest.mark.anyio
 async def test_nargs_star(arunner):
     @click.command()
@@ -16,8 +17,8 @@ async def test_nargs_star(arunner):
     def copy(src, dst):
         click.echo(f"src={'|'.join(src)}")
         click.echo(f"dst={dst}")
-        sys.stdin=sys.__stdin__
-        sys.stdout=sys.__stdout__
+        sys.stdin = sys.__stdin__
+        sys.stdout = sys.__stdout__
 
     result = await arunner.invoke(copy, ["foo.txt", "bar.txt", "dir"])
     if result.exception:

tests/test_context.py

@@ -1,7 +1,7 @@
-from contextlib import asynccontextmanager
+import logging
 from contextlib import AbstractContextManager
+from contextlib import asynccontextmanager
 from contextlib import contextmanager
-import logging
 from types import TracebackType
 
 import pytest

tests/test_custom_classes.py

@@ -1,7 +1,7 @@
-import asyncclick as click
-
 import pytest
 
+import asyncclick as click
+
 
 @pytest.mark.anyio
 async def test_command_context_class():