Migrate from autoflake, black, isort, pyupgrade, flake8 and pydocstyle, to ruff

ruff is faster and handle everything we had prior.

isort configuration done based on the indication from
https://github.com/astral-sh/ruff/issues/4670, previousely based on
reorder-python-import (#11896)

flake8-docstrings was a wrapper around pydocstyle (now archived) that
explicitly asks to use ruff in https://github.com/PyCQA/pydocstyle/pull/658.

flake8-typing-import is useful mainly for project that support python 3.7
and the one useful check will be implemented in https://github.com/astral-sh/ruff/issues/2302

We need to keep blacken-doc because ruff does not handle detection
of python code inside .md and .rst. The direct link to the repo is
now used to avoid a redirection.

Manual fixes:
- Lines that became too long
- % formatting that was not done automatically
- type: ignore that were moved around
- noqa of hard to fix issues (UP031 generally)
- fmt: off and fmt: on that is not really identical
  between black and ruff
- autofix re-order in pre-commit from faster to slower

Co-authored-by: Ran Benita <ran@unusedvar.com>

src/_pytest/python_api.py

@@ -1,10 +1,10 @@
 # mypy: allow-untyped-defs
-import math
-import pprint
 from collections.abc import Collection
 from collections.abc import Sized
 from decimal import Decimal
+import math
 from numbers import Complex
+import pprint
 from types import TracebackType
 from typing import Any
 from typing import Callable
@@ -27,6 +27,7 @@ import _pytest._code
 from _pytest.compat import STRING_TYPES
 from _pytest.outcomes import fail
 
+
 if TYPE_CHECKING:
     from numpy import ndarray
 
@@ -238,9 +239,7 @@ class ApproxMapping(ApproxBase):
     with numeric values (the keys can be anything)."""
 
     def __repr__(self) -> str:
-        return "approx({!r})".format(
-            {k: self._approx_scalar(v) for k, v in self.expected.items()}
-        )
+        return f"approx({({k: self._approx_scalar(v) for k, v in self.expected.items()})!r})"
 
     def _repr_compare(self, other_side: Mapping[object, float]) -> List[str]:
         import math
@@ -315,9 +314,7 @@ class ApproxSequenceLike(ApproxBase):
         seq_type = type(self.expected)
         if seq_type not in (tuple, list):
             seq_type = list
-        return "approx({!r})".format(
-            seq_type(self._approx_scalar(x) for x in self.expected)
-        )
+        return f"approx({seq_type(self._approx_scalar(x) for x in self.expected)!r})"
 
     def _repr_compare(self, other_side: Sequence[float]) -> List[str]:
         import math
@@ -697,7 +694,6 @@ def approx(expected, rel=None, abs=None, nan_ok: bool = False) -> ApproxBase:
        ``approx`` falls back to strict equality for nonnumeric types instead
        of raising ``TypeError``.
     """
-
     # Delegate the comparison to a class that knows how to deal with the type
     # of the expected value (e.g. int, float, list, dict, numpy.array, etc).
     #
@@ -779,7 +775,8 @@ def raises(
     expected_exception: Union[Type[E], Tuple[Type[E], ...]],
     *,
     match: Optional[Union[str, Pattern[str]]] = ...,
-) -> "RaisesContext[E]": ...
+) -> "RaisesContext[E]":
+    ...
 
 
 @overload
@@ -788,7 +785,8 @@ def raises(  # noqa: F811
     func: Callable[..., Any],
     *args: Any,
     **kwargs: Any,
-) -> _pytest._code.ExceptionInfo[E]: ...
+) -> _pytest._code.ExceptionInfo[E]:
+    ...
 
 
 def raises(  # noqa: F811
@@ -837,10 +835,10 @@ def raises(  # noqa: F811
     The ``match`` argument searches the formatted exception string, which includes any
     `PEP-678 <https://peps.python.org/pep-0678/>`__ ``__notes__``:
 
-        >>> with pytest.raises(ValueError, match=r'had a note added'):  # doctest: +SKIP
-        ...    e = ValueError("value must be 42")
-        ...    e.add_note("had a note added")
-        ...    raise e
+        >>> with pytest.raises(ValueError, match=r"had a note added"):  # doctest: +SKIP
+        ...     e = ValueError("value must be 42")
+        ...     e.add_note("had a note added")
+        ...     raise e
 
     The context manager produces an :class:`ExceptionInfo` object which can be used to inspect the
     details of the captured exception::
@@ -855,7 +853,7 @@ def raises(  # noqa: F811
        Given that ``pytest.raises`` matches subclasses, be wary of using it to match :class:`Exception` like this::
 
            with pytest.raises(Exception):  # Careful, this will catch ANY exception raised.
-                some_function()
+               some_function()
 
        Because :class:`Exception` is the base class of almost all exceptions, it is easy for this to hide
        real bugs, where the user wrote this expecting a specific exception, but some other exception is being