Try to fix Pytest error on Python 3.13 (#14287)

.github/workflows/test.yml

@@ -1,98 +1,98 b''
 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
+        python -m pip install --only-binary ':all:' --upgrade check-manifest pytest-cov  pytest-json-report 'pytest<8'
     - 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/ipunittest.py

@@ -1,178 +1,186 b''
 """Experimental code for cleaner support of IPython syntax with unittest.
 
 In IPython up until 0.10, we've used very hacked up nose machinery for running
 tests with IPython special syntax, and this has proved to be extremely slow.
 This module provides decorators to try a different approach, stemming from a
 conversation Brian and I (FP) had about this problem Sept/09.
 
 The goal is to be able to easily write simple functions that can be seen by
 unittest as tests, and ultimately for these to support doctests with full
 IPython syntax.  Nose already offers this based on naming conventions and our
 hackish plugins, but we are seeking to move away from nose dependencies if
 possible.
 
 This module follows a different approach, based on decorators.
 
 - A decorator called @ipdoctest can mark any function as having a docstring
   that should be viewed as a doctest, but after syntax conversion.
 
 Authors
 -------
 
 - Fernando Perez <[e-mail]>
 """
 
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2009-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Stdlib
 import re
+import sys
 import unittest
 from doctest import DocTestFinder, DocTestRunner, TestResults
 from IPython.terminal.interactiveshell import InteractiveShell
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 def count_failures(runner):
     """Count number of failures in a doctest runner.
 
     Code modeled after the summarize() method in doctest.
     """
-    return [TestResults(f, t) for f, t in runner._name2ft.values() if f > 0 ]
+    if sys.version_info < (3, 13):
+        return [TestResults(f, t) for f, t in runner._name2ft.values() if f > 0]
+    else:
+        return [
+            TestResults(failure, try_)
+            for failure, try_, skip in runner._stats.values()
+            if failure > 0
+        ]
 
 
 class IPython2PythonConverter(object):
     """Convert IPython 'syntax' to valid Python.
 
     Eventually this code may grow to be the full IPython syntax conversion
     implementation, but for now it only does prompt conversion."""
     
     def __init__(self):
         self.rps1 = re.compile(r'In\ \[\d+\]: ')
         self.rps2 = re.compile(r'\ \ \ \.\.\.+: ')
         self.rout = re.compile(r'Out\[\d+\]: \s*?\n?')
         self.pyps1 = '>>> '
         self.pyps2 = '... '
         self.rpyps1 = re.compile (r'(\s*%s)(.*)$' % self.pyps1)
         self.rpyps2 = re.compile (r'(\s*%s)(.*)$' % self.pyps2)
 
     def __call__(self, ds):
         """Convert IPython prompts to python ones in a string."""
         from . import globalipapp
 
         pyps1 = '>>> '
         pyps2 = '... '
         pyout = ''
 
         dnew = ds
         dnew = self.rps1.sub(pyps1, dnew)
         dnew = self.rps2.sub(pyps2, dnew)
         dnew = self.rout.sub(pyout, dnew)
         ip = InteractiveShell.instance()
 
         # Convert input IPython source into valid Python.
         out = []
         newline = out.append
         for line in dnew.splitlines():
 
             mps1 = self.rpyps1.match(line)
             if mps1 is not None:
                 prompt, text = mps1.groups()
                 newline(prompt+ip.prefilter(text, False))
                 continue
 
             mps2 = self.rpyps2.match(line)
             if mps2 is not None:
                 prompt, text = mps2.groups()
                 newline(prompt+ip.prefilter(text, True))
                 continue
             
             newline(line)
         newline('')  # ensure a closing newline, needed by doctest
         #print "PYSRC:", '\n'.join(out)  # dbg
         return '\n'.join(out)
 
     #return dnew
 
 
 class Doc2UnitTester(object):
     """Class whose instances act as a decorator for docstring testing.
 
     In practice we're only likely to need one instance ever, made below (though
     no attempt is made at turning it into a singleton, there is no need for
     that).
     """
     def __init__(self, verbose=False):
         """New decorator.
 
         Parameters
         ----------
 
         verbose : boolean, optional (False)
           Passed to the doctest finder and runner to control verbosity.
         """
         self.verbose = verbose
         # We can reuse the same finder for all instances
         self.finder = DocTestFinder(verbose=verbose, recurse=False)
 
     def __call__(self, func):
         """Use as a decorator: doctest a function's docstring as a unittest.
         
         This version runs normal doctests, but the idea is to make it later run
         ipython syntax instead."""
 
         # Capture the enclosing instance with a different name, so the new
         # class below can see it without confusion regarding its own 'self'
         # that will point to the test instance at runtime
         d2u = self
 
         # Rewrite the function's docstring to have python syntax
         if func.__doc__ is not None:
             func.__doc__ = ip2py(func.__doc__)
 
         # Now, create a tester object that is a real unittest instance, so
         # normal unittest machinery (or Nose, or Trial) can find it.
         class Tester(unittest.TestCase):
             def test(self):
                 # Make a new runner per function to be tested
                 runner = DocTestRunner(verbose=d2u.verbose)
                 for the_test in d2u.finder.find(func, func.__name__):
                     runner.run(the_test)
                 failed = count_failures(runner)
                 if failed:
                     # Since we only looked at a single function's docstring,
                     # failed should contain at most one item.  More than that
                     # is a case we can't handle and should error out on
                     if len(failed) > 1:
                         err = "Invalid number of test results: %s" % failed
                         raise ValueError(err)
                     # Report a normal failure.
                     self.fail('failed doctests: %s' % str(failed[0]))
                     
         # Rename it so test reports have the original signature.
         Tester.__name__ = func.__name__
         return Tester
 
 
 def ipdocstring(func):
     """Change the function docstring via ip2py.
     """
     if func.__doc__ is not None:
         func.__doc__ = ip2py(func.__doc__)
     return func
 
         
 # Make an instance of the classes for public use
 ipdoctest = Doc2UnitTester()
 ip2py = IPython2PythonConverter()

IPython/testing/plugin/pytest_ipdoctest.py

@@ -1,859 +1,863 b''
 # 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()

IPython/testing/tests/test_decorators.py

@@ -1,166 +1,168 b''
 """Tests for the decorators we've created for IPython.
 """
 
 # Module imports
 # Std lib
 import inspect
 import sys
 
 # Our own
 from IPython.testing import decorators as dec
 from IPython.testing.skipdoctest import skip_doctest
+from IPython.utils.text import dedent
 
 #-----------------------------------------------------------------------------
 # Utilities
 
 # Note: copied from OInspect, kept here so the testing stuff doesn't create
 # circular dependencies and is easier to reuse.
 def getargspec(obj):
     """Get the names and default values of a function's arguments.
 
     A tuple of four things is returned: (args, varargs, varkw, defaults).
     'args' is a list of the argument names (it may contain nested lists).
     'varargs' and 'varkw' are the names of the * and ** arguments or None.
     'defaults' is an n-tuple of the default values of the last n arguments.
 
     Modified version of inspect.getargspec from the Python Standard
     Library."""
 
     if inspect.isfunction(obj):
         func_obj = obj
     elif inspect.ismethod(obj):
         func_obj = obj.__func__
     else:
         raise TypeError('arg is not a Python function')
     args, varargs, varkw = inspect.getargs(func_obj.__code__)
     return args, varargs, varkw, func_obj.__defaults__
 
 #-----------------------------------------------------------------------------
 # Testing functions
 
 @dec.as_unittest
 def trivial():
     """A trivial test"""
     pass
 
 
 @dec.skip()
 def test_deliberately_broken():
     """A deliberately broken test - we want to skip this one."""
     1/0
 
 @dec.skip('Testing the skip decorator')
 def test_deliberately_broken2():
     """Another deliberately broken test - we want to skip this one."""
     1/0
 
 
 # Verify that we can correctly skip the doctest for a function at will, but
 # that the docstring itself is NOT destroyed by the decorator.
 @skip_doctest
 def doctest_bad(x,y=1,**k):
     """A function whose doctest we need to skip.
 
     >>> 1+1
     3
     """
     print('x:',x)
     print('y:',y)
     print('k:',k)
 
 
 def call_doctest_bad():
     """Check that we can still call the decorated functions.
     
     >>> doctest_bad(3,y=4)
     x: 3
     y: 4
     k: {}
     """
     pass
 
 
 def test_skip_dt_decorator():
     """Doctest-skipping decorator should preserve the docstring.
     """
     # Careful: 'check' must be a *verbatim* copy of the doctest_bad docstring!
     check = """A function whose doctest we need to skip.
 
     >>> 1+1
     3
     """
+
     # Fetch the docstring from doctest_bad after decoration.
     val = doctest_bad.__doc__
-    
-    assert check == val, "doctest_bad docstrings don't match"
+
+    assert dedent(check) == dedent(val), "doctest_bad docstrings don't match"
 
 
 # Doctest skipping should work for class methods too
 class FooClass(object):
     """FooClass
 
     Example:
 
     >>> 1+1
     2
     """
 
     @skip_doctest
     def __init__(self,x):
         """Make a FooClass.
 
         Example:
 
         >>> f = FooClass(3)
         junk
         """
         print('Making a FooClass.')
         self.x = x
         
     @skip_doctest
     def bar(self,y):
         """Example:
 
         >>> ff = FooClass(3)
         >>> ff.bar(0)
         boom!
         >>> 1/0
         bam!
         """
         return 1/y
 
     def baz(self,y):
         """Example:
 
         >>> ff2 = FooClass(3)
         Making a FooClass.
         >>> ff2.baz(3)
         True
         """
         return self.x==y
 
 
 def test_skip_dt_decorator2():
     """Doctest-skipping decorator should preserve function signature.
     """
     # Hardcoded correct answer
     dtargs = (['x', 'y'], None, 'k', (1,))
     # Introspect out the value
     dtargsr = getargspec(doctest_bad)
     assert dtargsr==dtargs, \
            "Incorrectly reconstructed args for doctest_bad: %s" % (dtargsr,)
 
 
 @dec.skip_linux
 def test_linux():
     assert sys.platform.startswith("linux") is False, "This test can't run under linux"
 
 
 @dec.skip_win32
 def test_win32():
     assert sys.platform != "win32", "This test can't run under windows"
 
 
 @dec.skip_osx
 def test_osx():
     assert sys.platform != "darwin", "This test can't run under osx"

setup.cfg

@@ -1,116 +1,115 b''
 [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
     typing_extensions
     exceptiongroup
     %(test)s
 kernel =
     ipykernel
 nbconvert =
     nbconvert
 nbformat =
     nbformat
 notebook =
     ipywidgets
     notebook
 parallel =
     ipyparallel
 qtconsole =
     qtconsole
 terminal =
 test =
-    pytest
+    pytest<8
     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'