Try to fix Pytest error on Python 3.13

.github/workflows/test.yml

@@ -1,98 +1,98
 name: Run tests
 
 on:
   push:
     branches:
       - main
       - '*.x'
   pull_request:
   # Run weekly on Monday at 1:23 UTC
   schedule:
   - cron:  '23 1 * * 1'
   workflow_dispatch:
 
 
 jobs:
   test:
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, windows-latest]
         python-version: ["3.10", "3.11", "3.12"]
         deps: [test_extra]
         # Test all on ubuntu, test ends on macos
         include:
           - os: macos-latest
             python-version: "3.10"
             deps: test_extra
           - os: macos-latest
             python-version: "3.11"
             deps: test_extra
           # Tests minimal dependencies set
           - os: ubuntu-latest
             python-version: "3.11"
             deps: test
           # Tests latest development Python version
           - os: ubuntu-latest
             python-version: "3.13-dev"
             deps: test
           # Installing optional dependencies stuff takes ages on PyPy
           - os: ubuntu-latest
             python-version: "pypy-3.10"
             deps: test
           - os: windows-latest
             python-version: "pypy-3.10"
             deps: test
           - os: macos-latest
             python-version: "pypy-3.10"
             deps: test
 
     steps:
     - uses: actions/checkout@v3
     - name: Set up Python ${{ matrix.python-version }}
       uses: actions/setup-python@v4
       with:
         python-version: ${{ matrix.python-version }}
         cache: pip
         cache-dependency-path: |
           setup.cfg
     - name: Install latex
       if: runner.os == 'Linux' && matrix.deps == 'test_extra'
       run: echo "disable latex for now, issues in mirros" #sudo apt-get -yq -o Acquire::Retries=3 --no-install-suggests --no-install-recommends install texlive dvipng
     - name: Install and update Python dependencies (binary only)
       if: ${{ ! contains( matrix.python-version, 'dev' ) }}
       run: |
         python -m pip install --only-binary ':all:' --upgrade pip setuptools wheel build
         python -m pip install --only-binary ':all:' --no-binary curio --upgrade -e .[${{ matrix.deps }}]
         python -m pip install --only-binary ':all:' --upgrade check-manifest pytest-cov  pytest-json-report
     - name: Install and update Python dependencies (dev?)
       if: ${{ contains( matrix.python-version, 'dev' ) }}
       run: |
         python -m pip install --pre --upgrade pip setuptools wheel build
         python -m pip install --pre --extra-index-url https://pypi.anaconda.org/scientific-python-nightly-wheels/simple --no-binary curio --upgrade -e .[${{ matrix.deps }}]
         python -m pip install --pre --extra-index-url https://pypi.anaconda.org/scientific-python-nightly-wheels/simple --upgrade check-manifest pytest-cov  pytest-json-report
     - name: Try building with Python build
       if: runner.os != 'Windows'  # setup.py does not support sdist on Windows
       run: |
         python -m build
         shasum -a 256 dist/*
     - name: Check manifest
       if: runner.os != 'Windows'  # setup.py does not support sdist on Windows
       run: check-manifest
     - name: pytest
       env:
         COLUMNS: 120
       run: |
-        pytest --color=yes -raXxs ${{ startsWith(matrix.python-version, 'pypy') && ' ' || '--cov --cov-report=xml' }} --json-report --json-report-file=./report-${{ matrix.python-version }}-${{runner.os}}.json
+        pytest --color=yes -raXxs ${{ startsWith(matrix.python-version, 'pypy') && ' ' || '--cov --cov-report=xml' }} --json-report --json-report-file=./report-${{ matrix.python-version }}-${{runner.os}}.json --maxfail=15
     - uses: actions/upload-artifact@v3
       with:
           name: upload pytest timing reports as json
           path: |
             ./report-*.json
 
     - name: Upload coverage to Codecov
       uses: codecov/codecov-action@v3
       with:
          name: Test
          files: /home/runner/work/ipython/ipython/coverage.xml

IPython/testing/plugin/pytest_ipdoctest.py

@@ -1,859 +1,863
 # Based on Pytest doctest.py
 # Original license:
 # The MIT License (MIT)
 #
 # Copyright (c) 2004-2021 Holger Krekel and others
 """Discover and run ipdoctests in modules and test files."""
-import builtins
 import bdb
+import builtins
 import inspect
 import os
 import platform
 import sys
 import traceback
 import types
 import warnings
 from contextlib import contextmanager
 from pathlib import Path
-from typing import Any
-from typing import Callable
-from typing import Dict
-from typing import Generator
-from typing import Iterable
-from typing import List
-from typing import Optional
-from typing import Pattern
-from typing import Sequence
-from typing import Tuple
-from typing import Type
-from typing import TYPE_CHECKING
-from typing import Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Generator,
+    Iterable,
+    List,
+    Optional,
+    Pattern,
+    Sequence,
+    Tuple,
+    Type,
+    Union,
+)
 
 import pytest
 from _pytest import outcomes
-from _pytest._code.code import ExceptionInfo
-from _pytest._code.code import ReprFileLocation
-from _pytest._code.code import TerminalRepr
+from _pytest._code.code import ExceptionInfo, ReprFileLocation, TerminalRepr
 from _pytest._io import TerminalWriter
 from _pytest.compat import safe_getattr
 from _pytest.config import Config
 from _pytest.config.argparsing import Parser
 from _pytest.fixtures import FixtureRequest
 from _pytest.nodes import Collector
 from _pytest.outcomes import OutcomeException
-from _pytest.pathlib import fnmatch_ex
-from _pytest.pathlib import import_path
+from _pytest.pathlib import fnmatch_ex, import_path
 from _pytest.python_api import approx
 from _pytest.warning_types import PytestWarning
 
 if TYPE_CHECKING:
     import doctest
 
+    from .ipdoctest import IPDoctestOutputChecker
+
 DOCTEST_REPORT_CHOICE_NONE = "none"
 DOCTEST_REPORT_CHOICE_CDIFF = "cdiff"
 DOCTEST_REPORT_CHOICE_NDIFF = "ndiff"
 DOCTEST_REPORT_CHOICE_UDIFF = "udiff"
 DOCTEST_REPORT_CHOICE_ONLY_FIRST_FAILURE = "only_first_failure"
 
 DOCTEST_REPORT_CHOICES = (
     DOCTEST_REPORT_CHOICE_NONE,
     DOCTEST_REPORT_CHOICE_CDIFF,
     DOCTEST_REPORT_CHOICE_NDIFF,
     DOCTEST_REPORT_CHOICE_UDIFF,
     DOCTEST_REPORT_CHOICE_ONLY_FIRST_FAILURE,
 )
 
 # Lazy definition of runner class
 RUNNER_CLASS = None
 # Lazy definition of output checker class
 CHECKER_CLASS: Optional[Type["IPDoctestOutputChecker"]] = None
 
 
 def pytest_addoption(parser: Parser) -> None:
     parser.addini(
         "ipdoctest_optionflags",
         "option flags for ipdoctests",
         type="args",
         default=["ELLIPSIS"],
     )
     parser.addini(
         "ipdoctest_encoding", "encoding used for ipdoctest files", default="utf-8"
     )
     group = parser.getgroup("collect")
     group.addoption(
         "--ipdoctest-modules",
         action="store_true",
         default=False,
         help="run ipdoctests in all .py modules",
         dest="ipdoctestmodules",
     )
     group.addoption(
         "--ipdoctest-report",
         type=str.lower,
         default="udiff",
         help="choose another output format for diffs on ipdoctest failure",
         choices=DOCTEST_REPORT_CHOICES,
         dest="ipdoctestreport",
     )
     group.addoption(
         "--ipdoctest-glob",
         action="append",
         default=[],
         metavar="pat",
         help="ipdoctests file matching pattern, default: test*.txt",
         dest="ipdoctestglob",
     )
     group.addoption(
         "--ipdoctest-ignore-import-errors",
         action="store_true",
         default=False,
         help="ignore ipdoctest ImportErrors",
         dest="ipdoctest_ignore_import_errors",
     )
     group.addoption(
         "--ipdoctest-continue-on-failure",
         action="store_true",
         default=False,
         help="for a given ipdoctest, continue to run after the first failure",
         dest="ipdoctest_continue_on_failure",
     )
 
 
 def pytest_unconfigure() -> None:
     global RUNNER_CLASS
 
     RUNNER_CLASS = None
 
 
 def pytest_collect_file(
     file_path: Path,
     parent: Collector,
 ) -> Optional[Union["IPDoctestModule", "IPDoctestTextfile"]]:
     config = parent.config
     if file_path.suffix == ".py":
         if config.option.ipdoctestmodules and not any(
             (_is_setup_py(file_path), _is_main_py(file_path))
         ):
             mod: IPDoctestModule = IPDoctestModule.from_parent(parent, path=file_path)
             return mod
     elif _is_ipdoctest(config, file_path, parent):
         txt: IPDoctestTextfile = IPDoctestTextfile.from_parent(parent, path=file_path)
         return txt
     return None
 
 
 if int(pytest.__version__.split(".")[0]) < 7:
     _collect_file = pytest_collect_file
 
     def pytest_collect_file(
         path,
         parent: Collector,
     ) -> Optional[Union["IPDoctestModule", "IPDoctestTextfile"]]:
         return _collect_file(Path(path), parent)
 
     _import_path = import_path
 
     def import_path(path, root):
         import py.path
 
         return _import_path(py.path.local(path))
 
 
 def _is_setup_py(path: Path) -> bool:
     if path.name != "setup.py":
         return False
     contents = path.read_bytes()
     return b"setuptools" in contents or b"distutils" in contents
 
 
 def _is_ipdoctest(config: Config, path: Path, parent: Collector) -> bool:
     if path.suffix in (".txt", ".rst") and parent.session.isinitpath(path):
         return True
     globs = config.getoption("ipdoctestglob") or ["test*.txt"]
     return any(fnmatch_ex(glob, path) for glob in globs)
 
 
 def _is_main_py(path: Path) -> bool:
     return path.name == "__main__.py"
 
 
 class ReprFailDoctest(TerminalRepr):
     def __init__(
         self, reprlocation_lines: Sequence[Tuple[ReprFileLocation, Sequence[str]]]
     ) -> None:
         self.reprlocation_lines = reprlocation_lines
 
     def toterminal(self, tw: TerminalWriter) -> None:
         for reprlocation, lines in self.reprlocation_lines:
             for line in lines:
                 tw.line(line)
             reprlocation.toterminal(tw)
 
 
 class MultipleDoctestFailures(Exception):
     def __init__(self, failures: Sequence["doctest.DocTestFailure"]) -> None:
         super().__init__()
         self.failures = failures
 
 
 def _init_runner_class() -> Type["IPDocTestRunner"]:
     import doctest
     from .ipdoctest import IPDocTestRunner
 
     class PytestDoctestRunner(IPDocTestRunner):
         """Runner to collect failures.
 
         Note that the out variable in this case is a list instead of a
         stdout-like object.
         """
 
         def __init__(
             self,
             checker: Optional["IPDoctestOutputChecker"] = None,
             verbose: Optional[bool] = None,
             optionflags: int = 0,
             continue_on_failure: bool = True,
         ) -> None:
             super().__init__(checker=checker, verbose=verbose, optionflags=optionflags)
             self.continue_on_failure = continue_on_failure
 
         def report_failure(
             self,
             out,
             test: "doctest.DocTest",
             example: "doctest.Example",
             got: str,
         ) -> None:
             failure = doctest.DocTestFailure(test, example, got)
             if self.continue_on_failure:
                 out.append(failure)
             else:
                 raise failure
 
         def report_unexpected_exception(
             self,
             out,
             test: "doctest.DocTest",
             example: "doctest.Example",
             exc_info: Tuple[Type[BaseException], BaseException, types.TracebackType],
         ) -> None:
             if isinstance(exc_info[1], OutcomeException):
                 raise exc_info[1]
             if isinstance(exc_info[1], bdb.BdbQuit):
                 outcomes.exit("Quitting debugger")
             failure = doctest.UnexpectedException(test, example, exc_info)
             if self.continue_on_failure:
                 out.append(failure)
             else:
                 raise failure
 
     return PytestDoctestRunner
 
 
 def _get_runner(
     checker: Optional["IPDoctestOutputChecker"] = None,
     verbose: Optional[bool] = None,
     optionflags: int = 0,
     continue_on_failure: bool = True,
 ) -> "IPDocTestRunner":
     # We need this in order to do a lazy import on doctest
     global RUNNER_CLASS
     if RUNNER_CLASS is None:
         RUNNER_CLASS = _init_runner_class()
     # Type ignored because the continue_on_failure argument is only defined on
     # PytestDoctestRunner, which is lazily defined so can't be used as a type.
     return RUNNER_CLASS(  # type: ignore
         checker=checker,
         verbose=verbose,
         optionflags=optionflags,
         continue_on_failure=continue_on_failure,
     )
 
 
 class IPDoctestItem(pytest.Item):
+    _user_ns_orig: Dict[str, Any]
+
     def __init__(
         self,
         name: str,
         parent: "Union[IPDoctestTextfile, IPDoctestModule]",
         runner: Optional["IPDocTestRunner"] = None,
         dtest: Optional["doctest.DocTest"] = None,
     ) -> None:
         super().__init__(name, parent)
         self.runner = runner
         self.dtest = dtest
         self.obj = None
         self.fixture_request: Optional[FixtureRequest] = None
+        self._user_ns_orig = {}
 
     @classmethod
     def from_parent(  # type: ignore
         cls,
         parent: "Union[IPDoctestTextfile, IPDoctestModule]",
         *,
         name: str,
         runner: "IPDocTestRunner",
         dtest: "doctest.DocTest",
     ):
         # incompatible signature due to imposed limits on subclass
         """The public named constructor."""
         return super().from_parent(name=name, parent=parent, runner=runner, dtest=dtest)
 
     def setup(self) -> None:
         if self.dtest is not None:
             self.fixture_request = _setup_fixtures(self)
             globs = dict(getfixture=self.fixture_request.getfixturevalue)
             for name, value in self.fixture_request.getfixturevalue(
                 "ipdoctest_namespace"
             ).items():
                 globs[name] = value
             self.dtest.globs.update(globs)
 
             from .ipdoctest import IPExample
 
             if isinstance(self.dtest.examples[0], IPExample):
                 # for IPython examples *only*, we swap the globals with the ipython
                 # namespace, after updating it with the globals (which doctest
                 # fills with the necessary info from the module being tested).
                 self._user_ns_orig = {}
                 self._user_ns_orig.update(_ip.user_ns)
                 _ip.user_ns.update(self.dtest.globs)
                 # We must remove the _ key in the namespace, so that Python's
                 # doctest code sets it naturally
                 _ip.user_ns.pop("_", None)
                 _ip.user_ns["__builtins__"] = builtins
                 self.dtest.globs = _ip.user_ns
 
     def teardown(self) -> None:
         from .ipdoctest import IPExample
 
         # Undo the test.globs reassignment we made
         if isinstance(self.dtest.examples[0], IPExample):
             self.dtest.globs = {}
             _ip.user_ns.clear()
             _ip.user_ns.update(self._user_ns_orig)
             del self._user_ns_orig
 
         self.dtest.globs.clear()
 
     def runtest(self) -> None:
         assert self.dtest is not None
         assert self.runner is not None
         _check_all_skipped(self.dtest)
         self._disable_output_capturing_for_darwin()
         failures: List["doctest.DocTestFailure"] = []
 
         # exec(compile(..., "single", ...), ...) puts result in builtins._
         had_underscore_value = hasattr(builtins, "_")
         underscore_original_value = getattr(builtins, "_", None)
 
         # Save our current directory and switch out to the one where the
         # test was originally created, in case another doctest did a
         # directory change.  We'll restore this in the finally clause.
         curdir = os.getcwd()
         os.chdir(self.fspath.dirname)
         try:
             # Type ignored because we change the type of `out` from what
             # ipdoctest expects.
             self.runner.run(self.dtest, out=failures, clear_globs=False)  # type: ignore[arg-type]
         finally:
             os.chdir(curdir)
             if had_underscore_value:
                 setattr(builtins, "_", underscore_original_value)
             elif hasattr(builtins, "_"):
                 delattr(builtins, "_")
 
         if failures:
             raise MultipleDoctestFailures(failures)
 
     def _disable_output_capturing_for_darwin(self) -> None:
         """Disable output capturing. Otherwise, stdout is lost to ipdoctest (pytest#985)."""
         if platform.system() != "Darwin":
             return
         capman = self.config.pluginmanager.getplugin("capturemanager")
         if capman:
             capman.suspend_global_capture(in_=True)
             out, err = capman.read_global_capture()
             sys.stdout.write(out)
             sys.stderr.write(err)
 
     # TODO: Type ignored -- breaks Liskov Substitution.
     def repr_failure(  # type: ignore[override]
         self,
         excinfo: ExceptionInfo[BaseException],
     ) -> Union[str, TerminalRepr]:
         import doctest
 
         failures: Optional[
             Sequence[Union[doctest.DocTestFailure, doctest.UnexpectedException]]
         ] = None
         if isinstance(
             excinfo.value, (doctest.DocTestFailure, doctest.UnexpectedException)
         ):
             failures = [excinfo.value]
         elif isinstance(excinfo.value, MultipleDoctestFailures):
             failures = excinfo.value.failures
 
         if failures is None:
             return super().repr_failure(excinfo)
 
         reprlocation_lines = []
         for failure in failures:
             example = failure.example
             test = failure.test
             filename = test.filename
             if test.lineno is None:
                 lineno = None
             else:
                 lineno = test.lineno + example.lineno + 1
             message = type(failure).__name__
             # TODO: ReprFileLocation doesn't expect a None lineno.
             reprlocation = ReprFileLocation(filename, lineno, message)  # type: ignore[arg-type]
             checker = _get_checker()
             report_choice = _get_report_choice(self.config.getoption("ipdoctestreport"))
             if lineno is not None:
                 assert failure.test.docstring is not None
                 lines = failure.test.docstring.splitlines(False)
                 # add line numbers to the left of the error message
                 assert test.lineno is not None
                 lines = [
                     "%03d %s" % (i + test.lineno + 1, x) for (i, x) in enumerate(lines)
                 ]
                 # trim docstring error lines to 10
                 lines = lines[max(example.lineno - 9, 0) : example.lineno + 1]
             else:
                 lines = [
                     "EXAMPLE LOCATION UNKNOWN, not showing all tests of that example"
                 ]
                 indent = ">>>"
                 for line in example.source.splitlines():
                     lines.append(f"??? {indent} {line}")
                     indent = "..."
             if isinstance(failure, doctest.DocTestFailure):
                 lines += checker.output_difference(
                     example, failure.got, report_choice
                 ).split("\n")
             else:
                 inner_excinfo = ExceptionInfo.from_exc_info(failure.exc_info)
                 lines += ["UNEXPECTED EXCEPTION: %s" % repr(inner_excinfo.value)]
                 lines += [
                     x.strip("\n") for x in traceback.format_exception(*failure.exc_info)
                 ]
             reprlocation_lines.append((reprlocation, lines))
         return ReprFailDoctest(reprlocation_lines)
 
     def reportinfo(self) -> Tuple[Union["os.PathLike[str]", str], Optional[int], str]:
         assert self.dtest is not None
         return self.path, self.dtest.lineno, "[ipdoctest] %s" % self.name
 
     if int(pytest.__version__.split(".")[0]) < 7:
 
         @property
         def path(self) -> Path:
             return Path(self.fspath)
 
 
 def _get_flag_lookup() -> Dict[str, int]:
     import doctest
 
     return dict(
         DONT_ACCEPT_TRUE_FOR_1=doctest.DONT_ACCEPT_TRUE_FOR_1,
         DONT_ACCEPT_BLANKLINE=doctest.DONT_ACCEPT_BLANKLINE,
         NORMALIZE_WHITESPACE=doctest.NORMALIZE_WHITESPACE,
         ELLIPSIS=doctest.ELLIPSIS,
         IGNORE_EXCEPTION_DETAIL=doctest.IGNORE_EXCEPTION_DETAIL,
         COMPARISON_FLAGS=doctest.COMPARISON_FLAGS,
         ALLOW_UNICODE=_get_allow_unicode_flag(),
         ALLOW_BYTES=_get_allow_bytes_flag(),
         NUMBER=_get_number_flag(),
     )
 
 
 def get_optionflags(parent):
     optionflags_str = parent.config.getini("ipdoctest_optionflags")
     flag_lookup_table = _get_flag_lookup()
     flag_acc = 0
     for flag in optionflags_str:
         flag_acc |= flag_lookup_table[flag]
     return flag_acc
 
 
 def _get_continue_on_failure(config):
     continue_on_failure = config.getvalue("ipdoctest_continue_on_failure")
     if continue_on_failure:
         # We need to turn off this if we use pdb since we should stop at
         # the first failure.
         if config.getvalue("usepdb"):
             continue_on_failure = False
     return continue_on_failure
 
 
 class IPDoctestTextfile(pytest.Module):
     obj = None
 
     def collect(self) -> Iterable[IPDoctestItem]:
         import doctest
         from .ipdoctest import IPDocTestParser
 
         # Inspired by doctest.testfile; ideally we would use it directly,
         # but it doesn't support passing a custom checker.
         encoding = self.config.getini("ipdoctest_encoding")
         text = self.path.read_text(encoding)
         filename = str(self.path)
         name = self.path.name
         globs = {"__name__": "__main__"}
 
         optionflags = get_optionflags(self)
 
         runner = _get_runner(
             verbose=False,
             optionflags=optionflags,
             checker=_get_checker(),
             continue_on_failure=_get_continue_on_failure(self.config),
         )
 
         parser = IPDocTestParser()
         test = parser.get_doctest(text, globs, name, filename, 0)
         if test.examples:
             yield IPDoctestItem.from_parent(
                 self, name=test.name, runner=runner, dtest=test
             )
 
     if int(pytest.__version__.split(".")[0]) < 7:
 
         @property
         def path(self) -> Path:
             return Path(self.fspath)
 
         @classmethod
         def from_parent(
             cls,
             parent,
             *,
             fspath=None,
             path: Optional[Path] = None,
             **kw,
         ):
             if path is not None:
                 import py.path
 
                 fspath = py.path.local(path)
             return super().from_parent(parent=parent, fspath=fspath, **kw)
 
 
 def _check_all_skipped(test: "doctest.DocTest") -> None:
     """Raise pytest.skip() if all examples in the given DocTest have the SKIP
     option set."""
     import doctest
 
     all_skipped = all(x.options.get(doctest.SKIP, False) for x in test.examples)
     if all_skipped:
         pytest.skip("all docstests skipped by +SKIP option")
 
 
 def _is_mocked(obj: object) -> bool:
     """Return if an object is possibly a mock object by checking the
     existence of a highly improbable attribute."""
     return (
         safe_getattr(obj, "pytest_mock_example_attribute_that_shouldnt_exist", None)
         is not None
     )
 
 
 @contextmanager
 def _patch_unwrap_mock_aware() -> Generator[None, None, None]:
     """Context manager which replaces ``inspect.unwrap`` with a version
     that's aware of mock objects and doesn't recurse into them."""
     real_unwrap = inspect.unwrap
 
     def _mock_aware_unwrap(
         func: Callable[..., Any], *, stop: Optional[Callable[[Any], Any]] = None
     ) -> Any:
         try:
             if stop is None or stop is _is_mocked:
                 return real_unwrap(func, stop=_is_mocked)
             _stop = stop
             return real_unwrap(func, stop=lambda obj: _is_mocked(obj) or _stop(func))
         except Exception as e:
             warnings.warn(
                 "Got %r when unwrapping %r.  This is usually caused "
                 "by a violation of Python's object protocol; see e.g. "
                 "https://github.com/pytest-dev/pytest/issues/5080" % (e, func),
                 PytestWarning,
             )
             raise
 
     inspect.unwrap = _mock_aware_unwrap
     try:
         yield
     finally:
         inspect.unwrap = real_unwrap
 
 
 class IPDoctestModule(pytest.Module):
     def collect(self) -> Iterable[IPDoctestItem]:
         import doctest
         from .ipdoctest import DocTestFinder, IPDocTestParser
 
         class MockAwareDocTestFinder(DocTestFinder):
             """A hackish ipdoctest finder that overrides stdlib internals to fix a stdlib bug.
 
             https://github.com/pytest-dev/pytest/issues/3456
             https://bugs.python.org/issue25532
             """
 
             def _find_lineno(self, obj, source_lines):
                 """Doctest code does not take into account `@property`, this
                 is a hackish way to fix it. https://bugs.python.org/issue17446
 
                 Wrapped Doctests will need to be unwrapped so the correct
                 line number is returned. This will be reported upstream. #8796
                 """
                 if isinstance(obj, property):
                     obj = getattr(obj, "fget", obj)
 
                 if hasattr(obj, "__wrapped__"):
                     # Get the main obj in case of it being wrapped
                     obj = inspect.unwrap(obj)
 
                 # Type ignored because this is a private function.
                 return super()._find_lineno(  # type:ignore[misc]
                     obj,
                     source_lines,
                 )
 
             def _find(
                 self, tests, obj, name, module, source_lines, globs, seen
             ) -> None:
                 if _is_mocked(obj):
                     return
                 with _patch_unwrap_mock_aware():
                     # Type ignored because this is a private function.
                     super()._find(  # type:ignore[misc]
                         tests, obj, name, module, source_lines, globs, seen
                     )
 
         if self.path.name == "conftest.py":
             if int(pytest.__version__.split(".")[0]) < 7:
                 module = self.config.pluginmanager._importconftest(
                     self.path,
                     self.config.getoption("importmode"),
                 )
             else:
                 module = self.config.pluginmanager._importconftest(
                     self.path,
                     self.config.getoption("importmode"),
                     rootpath=self.config.rootpath,
                 )
         else:
             try:
                 module = import_path(self.path, root=self.config.rootpath)
             except ImportError:
                 if self.config.getvalue("ipdoctest_ignore_import_errors"):
                     pytest.skip("unable to import module %r" % self.path)
                 else:
                     raise
         # Uses internal doctest module parsing mechanism.
         finder = MockAwareDocTestFinder(parser=IPDocTestParser())
         optionflags = get_optionflags(self)
         runner = _get_runner(
             verbose=False,
             optionflags=optionflags,
             checker=_get_checker(),
             continue_on_failure=_get_continue_on_failure(self.config),
         )
 
         for test in finder.find(module, module.__name__):
             if test.examples:  # skip empty ipdoctests
                 yield IPDoctestItem.from_parent(
                     self, name=test.name, runner=runner, dtest=test
                 )
 
     if int(pytest.__version__.split(".")[0]) < 7:
 
         @property
         def path(self) -> Path:
             return Path(self.fspath)
 
         @classmethod
         def from_parent(
             cls,
             parent,
             *,
             fspath=None,
             path: Optional[Path] = None,
             **kw,
         ):
             if path is not None:
                 import py.path
 
                 fspath = py.path.local(path)
             return super().from_parent(parent=parent, fspath=fspath, **kw)
 
 
 def _setup_fixtures(doctest_item: IPDoctestItem) -> FixtureRequest:
     """Used by IPDoctestTextfile and IPDoctestItem to setup fixture information."""
 
     def func() -> None:
         pass
 
     doctest_item.funcargs = {}  # type: ignore[attr-defined]
     fm = doctest_item.session._fixturemanager
     doctest_item._fixtureinfo = fm.getfixtureinfo(  # type: ignore[attr-defined]
         node=doctest_item, func=func, cls=None, funcargs=False
     )
     fixture_request = FixtureRequest(doctest_item, _ispytest=True)
     fixture_request._fillfixtures()
     return fixture_request
 
 
 def _init_checker_class() -> Type["IPDoctestOutputChecker"]:
     import doctest
     import re
     from .ipdoctest import IPDoctestOutputChecker
 
     class LiteralsOutputChecker(IPDoctestOutputChecker):
         # Based on doctest_nose_plugin.py from the nltk project
         # (https://github.com/nltk/nltk) and on the "numtest" doctest extension
         # by Sebastien Boisgerault (https://github.com/boisgera/numtest).
 
         _unicode_literal_re = re.compile(r"(\W|^)[uU]([rR]?[\'\"])", re.UNICODE)
         _bytes_literal_re = re.compile(r"(\W|^)[bB]([rR]?[\'\"])", re.UNICODE)
         _number_re = re.compile(
             r"""
             (?P<number>
               (?P<mantissa>
                 (?P<integer1> [+-]?\d*)\.(?P<fraction>\d+)
                 |
                 (?P<integer2> [+-]?\d+)\.
               )
               (?:
                 [Ee]
                 (?P<exponent1> [+-]?\d+)
               )?
               |
               (?P<integer3> [+-]?\d+)
               (?:
                 [Ee]
                 (?P<exponent2> [+-]?\d+)
               )
             )
             """,
             re.VERBOSE,
         )
 
         def check_output(self, want: str, got: str, optionflags: int) -> bool:
             if super().check_output(want, got, optionflags):
                 return True
 
             allow_unicode = optionflags & _get_allow_unicode_flag()
             allow_bytes = optionflags & _get_allow_bytes_flag()
             allow_number = optionflags & _get_number_flag()
 
             if not allow_unicode and not allow_bytes and not allow_number:
                 return False
 
             def remove_prefixes(regex: Pattern[str], txt: str) -> str:
                 return re.sub(regex, r"\1\2", txt)
 
             if allow_unicode:
                 want = remove_prefixes(self._unicode_literal_re, want)
                 got = remove_prefixes(self._unicode_literal_re, got)
 
             if allow_bytes:
                 want = remove_prefixes(self._bytes_literal_re, want)
                 got = remove_prefixes(self._bytes_literal_re, got)
 
             if allow_number:
                 got = self._remove_unwanted_precision(want, got)
 
             return super().check_output(want, got, optionflags)
 
         def _remove_unwanted_precision(self, want: str, got: str) -> str:
             wants = list(self._number_re.finditer(want))
             gots = list(self._number_re.finditer(got))
             if len(wants) != len(gots):
                 return got
             offset = 0
             for w, g in zip(wants, gots):
                 fraction: Optional[str] = w.group("fraction")
                 exponent: Optional[str] = w.group("exponent1")
                 if exponent is None:
                     exponent = w.group("exponent2")
                 precision = 0 if fraction is None else len(fraction)
                 if exponent is not None:
                     precision -= int(exponent)
                 if float(w.group()) == approx(float(g.group()), abs=10**-precision):
                     # They're close enough. Replace the text we actually
                     # got with the text we want, so that it will match when we
                     # check the string literally.
                     got = (
                         got[: g.start() + offset] + w.group() + got[g.end() + offset :]
                     )
                     offset += w.end() - w.start() - (g.end() - g.start())
             return got
 
     return LiteralsOutputChecker
 
 
 def _get_checker() -> "IPDoctestOutputChecker":
     """Return a IPDoctestOutputChecker subclass that supports some
     additional options:
 
     * ALLOW_UNICODE and ALLOW_BYTES options to ignore u'' and b''
       prefixes (respectively) in string literals. Useful when the same
       ipdoctest should run in Python 2 and Python 3.
 
     * NUMBER to ignore floating-point differences smaller than the
       precision of the literal number in the ipdoctest.
 
     An inner class is used to avoid importing "ipdoctest" at the module
     level.
     """
     global CHECKER_CLASS
     if CHECKER_CLASS is None:
         CHECKER_CLASS = _init_checker_class()
     return CHECKER_CLASS()
 
 
 def _get_allow_unicode_flag() -> int:
     """Register and return the ALLOW_UNICODE flag."""
     import doctest
 
     return doctest.register_optionflag("ALLOW_UNICODE")
 
 
 def _get_allow_bytes_flag() -> int:
     """Register and return the ALLOW_BYTES flag."""
     import doctest
 
     return doctest.register_optionflag("ALLOW_BYTES")
 
 
 def _get_number_flag() -> int:
     """Register and return the NUMBER flag."""
     import doctest
 
     return doctest.register_optionflag("NUMBER")
 
 
 def _get_report_choice(key: str) -> int:
     """Return the actual `ipdoctest` module flag value.
 
     We want to do it as late as possible to avoid importing `ipdoctest` and all
     its dependencies when parsing options, as it adds overhead and breaks tests.
     """
     import doctest
 
     return {
         DOCTEST_REPORT_CHOICE_UDIFF: doctest.REPORT_UDIFF,
         DOCTEST_REPORT_CHOICE_CDIFF: doctest.REPORT_CDIFF,
         DOCTEST_REPORT_CHOICE_NDIFF: doctest.REPORT_NDIFF,
         DOCTEST_REPORT_CHOICE_ONLY_FIRST_FAILURE: doctest.REPORT_ONLY_FIRST_FAILURE,
         DOCTEST_REPORT_CHOICE_NONE: 0,
     }[key]
 
 
 @pytest.fixture(scope="session")
 def ipdoctest_namespace() -> Dict[str, Any]:
     """Fixture that returns a :py:class:`dict` that will be injected into the
     namespace of ipdoctests."""
     return dict()

setup.cfg

@@ -1,116 +1,116
 [metadata]
 name = ipython
 version = attr: IPython.core.release.__version__
 url = https://ipython.org
 description = IPython: Productive Interactive Computing
 long_description_content_type = text/x-rst
 long_description = file: long_description.rst
 license_file = LICENSE
 project_urls =
     Documentation = https://ipython.readthedocs.io/
     Funding = https://numfocus.org/
     Source = https://github.com/ipython/ipython
     Tracker = https://github.com/ipython/ipython/issues
 keywords = Interactive, Interpreter, Shell, Embedding
 platforms = Linux, Mac OSX, Windows
 classifiers =
     Framework :: IPython
     Framework :: Jupyter
     Intended Audience :: Developers
     Intended Audience :: Science/Research
     License :: OSI Approved :: BSD License
     Programming Language :: Python
     Programming Language :: Python :: 3
     Programming Language :: Python :: 3 :: Only
     Topic :: System :: Shells
 
 [options]
 packages = find:
 python_requires = >=3.10
 zip_safe = False
 install_requires =
     colorama; sys_platform == "win32"
     decorator
     exceptiongroup; python_version<'3.11'
     jedi>=0.16
     matplotlib-inline
     pexpect>4.3; sys_platform != "win32"
     prompt_toolkit>=3.0.41,<3.1.0
     pygments>=2.4.0
     stack_data
     traitlets>=5
     typing_extensions ; python_version<'3.10'
 
 [options.extras_require]
 black =
     black
 doc =
     ipykernel
     setuptools>=18.5
     sphinx>=1.3
     sphinx-rtd-theme
     docrepr
     matplotlib
     stack_data
-    pytest
+    pytest<8
     typing_extensions
     exceptiongroup
     %(test)s
 kernel =
     ipykernel
 nbconvert =
     nbconvert
 nbformat =
     nbformat
 notebook =
     ipywidgets
     notebook
 parallel =
     ipyparallel
 qtconsole =
     qtconsole
 terminal =
 test =
     pytest
     pytest-asyncio<0.22
     testpath
     pickleshare
 test_extra =
     %(test)s
     curio
     matplotlib!=3.2.0
     nbformat
     numpy>=1.23
     pandas
     trio
 all =
     %(black)s
     %(doc)s
     %(kernel)s
     %(nbconvert)s
     %(nbformat)s
     %(notebook)s
     %(parallel)s
     %(qtconsole)s
     %(terminal)s
     %(test_extra)s
     %(test)s
 
 [options.packages.find]
 exclude =
     setupext
 
 [options.package_data]
 IPython = py.typed
 IPython.core = profile/README*
 IPython.core.tests = *.png, *.jpg, daft_extension/*.py
 IPython.lib.tests = *.wav
 IPython.testing.plugin = *.txt
 
 [velin]
 ignore_patterns =
    IPython/core/tests
    IPython/testing
 
 [tool.black]
 exclude = 'timing\.py'