Turn on type checking and update crahshandler

IPython/core/crashhandler.py

@@ -1,236 +1,248
 # encoding: utf-8
 """sys.excepthook for IPython itself, leaves a detailed report on disk.
 
 Authors:
 
 * Fernando Perez
 * Brian E. Granger
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2001-2007 Fernando Perez. <[e-mail]>
 #  Copyright (C) 2008-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
 #-----------------------------------------------------------------------------
 
 import sys
 import traceback
 from pprint import pformat
 from pathlib import Path
 
+import builtins as builtin_mod
+
 from IPython.core import ultratb
+from IPython.core.application import Application
 from IPython.core.release import author_email
 from IPython.utils.sysinfo import sys_info
-from IPython.utils.py3compat import input
 
 from IPython.core.release import __version__ as version
 
-from typing import Optional
+from typing import Optional, Dict
+import types
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 # Template for the user message.
 _default_message_template = """\
 Oops, {app_name} crashed. We do our best to make it stable, but...
 
 A crash report was automatically generated with the following information:
   - A verbatim copy of the crash traceback.
   - A copy of your input history during this session.
   - Data on your current {app_name} configuration.
 
 It was left in the file named:
 \t'{crash_report_fname}'
 If you can email this file to the developers, the information in it will help
 them in understanding and correcting the problem.
 
 You can mail it to: {contact_name} at {contact_email}
 with the subject '{app_name} Crash Report'.
 
 If you want to do it now, the following command will work (under Unix):
 mail -s '{app_name} Crash Report' {contact_email} < {crash_report_fname}
 
 In your email, please also include information about:
 - The operating system under which the crash happened: Linux, macOS, Windows,
   other, and which exact version (for example: Ubuntu 16.04.3, macOS 10.13.2,
   Windows 10 Pro), and whether it is 32-bit or 64-bit;
 - How {app_name} was installed: using pip or conda, from GitHub, as part of
   a Docker container, or other, providing more detail if possible;
 - How to reproduce the crash: what exact sequence of instructions can one
   input to get the same crash? Ideally, find a minimal yet complete sequence
   of instructions that yields the crash.
 
 To ensure accurate tracking of this issue, please file a report about it at:
 {bug_tracker}
 """
 
 _lite_message_template = """
 If you suspect this is an IPython {version} bug, please report it at:
     https://github.com/ipython/ipython/issues
 or send an email to the mailing list at {email}
 
 You can print a more detailed traceback right now with "%tb", or use "%debug"
 to interactively debug it.
 
 Extra-detailed tracebacks for bug-reporting purposes can be enabled via:
     {config}Application.verbose_crash=True
 """
 
 
-class CrashHandler(object):
+class CrashHandler:
     """Customizable crash handlers for IPython applications.
 
     Instances of this class provide a :meth:`__call__` method which can be
     used as a ``sys.excepthook``.  The :meth:`__call__` signature is::
 
         def __call__(self, etype, evalue, etb)
     """
 
     message_template = _default_message_template
     section_sep = '\n\n'+'*'*75+'\n\n'
+    info: Dict[str, Optional[str]]
 
     def __init__(
         self,
-        app,
+        app: Application,
         contact_name: Optional[str] = None,
         contact_email: Optional[str] = None,
         bug_tracker: Optional[str] = None,
         show_crash_traceback: bool = True,
         call_pdb: bool = False,
     ):
         """Create a new crash handler
 
         Parameters
         ----------
         app : Application
             A running :class:`Application` instance, which will be queried at
             crash time for internal information.
         contact_name : str
             A string with the name of the person to contact.
         contact_email : str
             A string with the email address of the contact.
         bug_tracker : str
             A string with the URL for your project's bug tracker.
         show_crash_traceback : bool
             If false, don't print the crash traceback on stderr, only generate
             the on-disk report
         call_pdb
             Whether to call pdb on crash
 
         Attributes
         ----------
         These instances contain some non-argument attributes which allow for
         further customization of the crash handler's behavior. Please see the
         source for further details.
 
         """
         self.crash_report_fname = "Crash_report_%s.txt" % app.name
         self.app = app
         self.call_pdb = call_pdb
         #self.call_pdb = True # dbg
         self.show_crash_traceback = show_crash_traceback
         self.info = dict(app_name = app.name,
                     contact_name = contact_name,
                     contact_email = contact_email,
                     bug_tracker = bug_tracker,
                     crash_report_fname = self.crash_report_fname)
 
-
-    def __call__(self, etype, evalue, etb):
+    def __call__(
+        self,
+        etype: type[BaseException],
+        evalue: BaseException,
+        etb: types.TracebackType,
+    ) -> None:
         """Handle an exception, call for compatible with sys.excepthook"""
-        
+
         # do not allow the crash handler to be called twice without reinstalling it
         # this prevents unlikely errors in the crash handling from entering an
         # infinite loop.
         sys.excepthook = sys.__excepthook__
         
         # Report tracebacks shouldn't use color in general (safer for users)
         color_scheme = 'NoColor'
 
         # Use this ONLY for developer debugging (keep commented out for release)
-        #color_scheme = 'Linux'   # dbg
-        try:
-            rptdir = Path(self.app.ipython_dir)
-        except:
+        # color_scheme = 'Linux'   # dbg
+        ipython_dir = getattr(self.app, "ipython_dir")
+        if ipython_dir is not None:
+            assert isinstance(ipython_dir, str)
+            rptdir = Path(ipython_dir)
+        else:
             rptdir = Path.cwd()
         if not rptdir.is_dir():
             rptdir = Path.cwd()
         report_name = rptdir / self.crash_report_fname
         # write the report filename into the instance dict so it can get
         # properly expanded out in the user message template
-        self.crash_report_fname = report_name
-        self.info['crash_report_fname'] = report_name
+        self.crash_report_fname = str(report_name)
+        self.info["crash_report_fname"] = str(report_name)
         TBhandler = ultratb.VerboseTB(
             color_scheme=color_scheme,
-            long_header=1,
+            long_header=True,
             call_pdb=self.call_pdb,
         )
         if self.call_pdb:
             TBhandler(etype,evalue,etb)
             return
         else:
             traceback = TBhandler.text(etype,evalue,etb,context=31)
 
         # print traceback to screen
         if self.show_crash_traceback:
             print(traceback, file=sys.stderr)
 
         # and generate a complete report on disk
         try:
             report = open(report_name, "w", encoding="utf-8")
         except:
             print('Could not create crash report on disk.', file=sys.stderr)
             return
 
         with report:
             # Inform user on stderr of what happened
             print('\n'+'*'*70+'\n', file=sys.stderr)
             print(self.message_template.format(**self.info), file=sys.stderr)
 
             # Construct report on disk
-            report.write(self.make_report(traceback))
+            report.write(self.make_report(str(traceback)))
 
-        input("Hit <Enter> to quit (your terminal may close):")
+        builtin_mod.input("Hit <Enter> to quit (your terminal may close):")
 
-    def make_report(self,traceback):
+    def make_report(self, traceback: str) -> str:
         """Return a string containing a crash report."""
 
         sec_sep = self.section_sep
 
         report = ['*'*75+'\n\n'+'IPython post-mortem report\n\n']
         rpt_add = report.append
         rpt_add(sys_info())
 
         try:
             config = pformat(self.app.config)
             rpt_add(sec_sep)
-            rpt_add('Application name: %s\n\n' % self.app_name)
-            rpt_add('Current user configuration structure:\n\n')
+            rpt_add("Application name: %s\n\n" % self.app.name)
+            rpt_add("Current user configuration structure:\n\n")
             rpt_add(config)
         except:
             pass
         rpt_add(sec_sep+'Crash traceback:\n\n' + traceback)
 
         return ''.join(report)
 
 
-def crash_handler_lite(etype, evalue, tb):
+def crash_handler_lite(
+    etype: type[BaseException], evalue: BaseException, tb: types.TracebackType
+) -> None:
     """a light excepthook, adding a small message to the usual traceback"""
     traceback.print_exception(etype, evalue, tb)
     
     from IPython.core.interactiveshell import InteractiveShell
     if InteractiveShell.initialized():
         # we are in a Shell environment, give %magic example
         config = "%config "
     else:
         # we are not in a shell, show generic config
         config = "c."
     print(_lite_message_template.format(email=author_email, config=config, version=version), file=sys.stderr)
 

IPython/utils/sysinfo.py

@@ -1,143 +1,143
 # encoding: utf-8
 """
 Utilities for getting information about IPython and the system it's running in.
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-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
 #-----------------------------------------------------------------------------
 
 import os
 import platform
 import pprint
 import sys
 import subprocess
 
 from pathlib import Path
 
 from IPython.core import release
 from IPython.utils import _sysinfo, encoding
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 def pkg_commit_hash(pkg_path: str) -> tuple[str, str]:
     """Get short form of commit hash given directory `pkg_path`
 
     We get the commit hash from (in order of preference):
 
     * IPython.utils._sysinfo.commit
     * git output, if we are in a git repository
 
     If these fail, we return a not-found placeholder tuple
 
     Parameters
     ----------
     pkg_path : str
         directory containing package
         only used for getting commit from active repo
 
     Returns
     -------
     hash_from : str
         Where we got the hash from - description
     hash_str : str
         short form of hash
     """
     # Try and get commit from written commit text file
     if _sysinfo.commit:
         return "installation", _sysinfo.commit
 
     # maybe we are in a repository
     proc = subprocess.Popen('git rev-parse --short HEAD'.split(' '),
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE,
                             cwd=pkg_path)
     repo_commit, _ = proc.communicate()
     if repo_commit:
         return 'repository', repo_commit.strip().decode('ascii')
     return '(none found)', '<not found>'
 
 
 def pkg_info(pkg_path: str) -> dict:
     """Return dict describing the context of this package
 
     Parameters
     ----------
     pkg_path : str
         path containing __init__.py for package
 
     Returns
     -------
     context : dict
         with named parameters of interest
     """
     src, hsh = pkg_commit_hash(pkg_path)
     return dict(
         ipython_version=release.version,
         ipython_path=pkg_path,
         commit_source=src,
         commit_hash=hsh,
         sys_version=sys.version,
         sys_executable=sys.executable,
         sys_platform=sys.platform,
         platform=platform.platform(),
         os_name=os.name,
         default_encoding=encoding.DEFAULT_ENCODING,
         )
 
 def get_sys_info() -> dict:
     """Return useful information about IPython and the system, as a dict."""
     path = Path(__file__, "..").resolve().parent
     return pkg_info(str(path))
 
-def sys_info():
+def sys_info() -> str:
     """Return useful information about IPython and the system, as a string.
 
     Examples
     --------
     ::
     
         In [2]: print(sys_info())
         {'commit_hash': '144fdae',      # random
          'commit_source': 'repository',
          'ipython_path': '/home/fperez/usr/lib/python2.6/site-packages/IPython',
          'ipython_version': '0.11.dev',
          'os_name': 'posix',
          'platform': 'Linux-2.6.35-22-generic-i686-with-Ubuntu-10.10-maverick',
          'sys_executable': '/usr/bin/python',
          'sys_platform': 'linux2',
          'sys_version': '2.6.6 (r266:84292, Sep 15 2010, 15:52:39) \\n[GCC 4.4.5]'}
     """
     return pprint.pformat(get_sys_info())
 
 
 def num_cpus():
     """DEPRECATED
 
     Return the effective number of CPUs in the system as an integer.
 
     This cross-platform function makes an attempt at finding the total number of
     available CPUs in the system, as returned by various underlying system and
     python calls.
 
     If it can't find a sensible answer, it returns 1 (though an error *may* make
     it return a large positive number that's actually incorrect).
     """
     import warnings
 
     warnings.warn(
         "`num_cpus` is deprecated since IPython 8.0. Use `os.cpu_count` instead.",
         DeprecationWarning,
         stacklevel=2,
     )
 
     return os.cpu_count() or 1

pyproject.toml

@@ -1,385 +1,397
 [build-system]
 requires = ["setuptools>=61.2"]
 # We need access to the 'setupbase' module at build time.
 # Hence we declare a custom build backend.
 build-backend = "_build_meta"  # just re-exports setuptools.build_meta definitions
 backend-path = ["."]
 
 [project]
 name = "ipython"
 description = "IPython: Productive Interactive Computing"
 keywords = ["Interactive", "Interpreter", "Shell", "Embedding"]
 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",
 ]
 requires-python = ">=3.10"
 dependencies = [
     'colorama; sys_platform == "win32"',
     "decorator",
     "exceptiongroup; python_version<'3.11'",
     "jedi>=0.16",
     "matplotlib-inline",
     'pexpect>4.3; sys_platform != "win32" and sys_platform != "emscripten"',
     "prompt_toolkit>=3.0.41,<3.1.0",
     "pygments>=2.4.0",
     "stack_data",
     "traitlets>=5.13.0",
     "typing_extensions>=4.6; python_version<'3.12'",
 ]
 dynamic = ["authors", "license", "version"]
 
 [project.entry-points."pygments.lexers"]
 ipythonconsole = "IPython.lib.lexers:IPythonConsoleLexer"
 ipython = "IPython.lib.lexers:IPythonLexer"
 ipython3 = "IPython.lib.lexers:IPython3Lexer"
 
 [project.scripts]
 ipython = "IPython:start_ipython"
 ipython3 = "IPython:start_ipython"
 
 [project.readme]
 file = "long_description.rst"
 content-type = "text/x-rst"
 
 [project.urls]
 Homepage = "https://ipython.org"
 Documentation = "https://ipython.readthedocs.io/"
 Funding = "https://numfocus.org/"
 Source = "https://github.com/ipython/ipython"
 Tracker = "https://github.com/ipython/ipython/issues"
 
 [project.optional-dependencies]
 black = [
     "black",
 ]
 doc = [
     "docrepr",
     "exceptiongroup",
     "intersphinx_registry",
     "ipykernel",
     "ipython[test]",
     "matplotlib",
     "setuptools>=18.5",
     "sphinx-rtd-theme",
     "sphinx>=1.3",
     "sphinxcontrib-jquery",
     "tomli ; python_version<'3.11'",
     "typing_extensions",
 ]
 kernel = [
     "ipykernel",
 ]
 nbconvert = [
     "nbconvert",
 ]
 nbformat = [
     "nbformat",
 ]
 notebook = [
     "ipywidgets",
     "notebook",
 ]
 parallel = [
     "ipyparallel",
 ]
 qtconsole = [
     "qtconsole",
 ]
 terminal = []
 test = [
     "pytest",
     "pytest-asyncio<0.22",
     "testpath",
     "pickleshare",
     "packaging",
 ]
 test_extra = [
     "ipython[test]",
     "curio",
     "matplotlib!=3.2.0",
     "nbformat",
     "numpy>=1.23",
     "pandas",
     "trio",
 ]
 matplotlib = [
    "matplotlib"
 ]
 all = [
     "ipython[black,doc,kernel,nbconvert,nbformat,notebook,parallel,qtconsole,matplotlib]",
     "ipython[test,test_extra]",
 ]
 
 [tool.mypy]
 python_version = "3.10"
 ignore_missing_imports = true
 follow_imports = 'silent'
 exclude = [
    'test_\.+\.py',
    'IPython.utils.tests.test_wildcard',
    'testing',
    'tests',
    'PyColorize.py',
    '_process_win32_controller.py',
    'IPython/core/application.py',
    'IPython/core/profileapp.py',
    'IPython/lib/deepreload.py',
    'IPython/sphinxext/ipython_directive.py',
    'IPython/terminal/ipapp.py',
    'IPython/utils/_process_win32.py',
    'IPython/utils/path.py',
 ]
-disallow_untyped_defs = true
+# check_untyped_defs = true
+# disallow_untyped_calls = true
+# disallow_untyped_decorators = true
 # ignore_errors = false
 # ignore_missing_imports = false
-# disallow_untyped_calls = true
 disallow_incomplete_defs = true
-# check_untyped_defs = true
-# disallow_untyped_decorators = true
+disallow_untyped_defs = true
 warn_redundant_casts = true
 
 [[tool.mypy.overrides]]
 module = [
+    "IPython.core.crashhandler",
+]
+check_untyped_defs = true
+disallow_incomplete_defs = true
+disallow_untyped_calls = true
+disallow_untyped_decorators = true
+disallow_untyped_defs = true
+ignore_errors = false
+ignore_missing_imports = false
+
+[[tool.mypy.overrides]]
+module = [
     "IPython.utils.text",
 ]
 disallow_untyped_defs = true
 check_untyped_defs = false
 disallow_untyped_decorators = true
 
 [[tool.mypy.overrides]]
 module = [
 ]
 disallow_untyped_defs = false
 ignore_errors = true
 ignore_missing_imports = true
 disallow_untyped_calls = false
 disallow_incomplete_defs = false
 check_untyped_defs = false
 disallow_untyped_decorators = false
 
+
 # gloabl ignore error
 [[tool.mypy.overrides]]
 module = [
     "IPython",
     "IPython.conftest",
     "IPython.core.alias",
     "IPython.core.async_helpers",
     "IPython.core.autocall",
     "IPython.core.builtin_trap",
     "IPython.core.compilerop",
     "IPython.core.completer",
     "IPython.core.completerlib",
-    "IPython.core.crashhandler",
     "IPython.core.debugger",
     "IPython.core.display",
     "IPython.core.display_functions",
     "IPython.core.display_trap",
     "IPython.core.displayhook",
     "IPython.core.displaypub",
     "IPython.core.events",
     "IPython.core.excolors",
     "IPython.core.extensions",
     "IPython.core.formatters",
     "IPython.core.getipython",
     "IPython.core.guarded_eval",
     "IPython.core.history",
     "IPython.core.historyapp",
     "IPython.core.hooks",
     "IPython.core.inputsplitter",
     "IPython.core.inputtransformer",
     "IPython.core.inputtransformer2",
     "IPython.core.interactiveshell",
     "IPython.core.logger",
     "IPython.core.macro",
     "IPython.core.magic",
     "IPython.core.magic_arguments",
     "IPython.core.magics.ast_mod",
     "IPython.core.magics.auto",
     "IPython.core.magics.basic",
     "IPython.core.magics.code",
     "IPython.core.magics.config",
     "IPython.core.magics.display",
     "IPython.core.magics.execution",
     "IPython.core.magics.extension",
     "IPython.core.magics.history",
     "IPython.core.magics.logging",
     "IPython.core.magics.namespace",
     "IPython.core.magics.osm",
     "IPython.core.magics.packaging",
     "IPython.core.magics.pylab",
     "IPython.core.magics.script",
     "IPython.core.oinspect",
     "IPython.core.page",
     "IPython.core.payload",
     "IPython.core.payloadpage",
     "IPython.core.prefilter",
     "IPython.core.profiledir",
     "IPython.core.prompts",
     "IPython.core.pylabtools",
     "IPython.core.shellapp",
     "IPython.core.splitinput",
     "IPython.core.ultratb",
     "IPython.extensions.autoreload",
     "IPython.extensions.storemagic",
     "IPython.external.qt_for_kernel",
     "IPython.external.qt_loaders",
     "IPython.lib.backgroundjobs",
     "IPython.lib.clipboard",
     "IPython.lib.demo",
     "IPython.lib.display",
     "IPython.lib.editorhooks",
     "IPython.lib.guisupport",
     "IPython.lib.latextools",
     "IPython.lib.lexers",
     "IPython.lib.pretty",
     "IPython.paths",
     "IPython.sphinxext.ipython_console_highlighting",
     "IPython.terminal.debugger",
     "IPython.terminal.embed",
     "IPython.terminal.interactiveshell",
     "IPython.terminal.magics",
     "IPython.terminal.prompts",
     "IPython.terminal.pt_inputhooks",
     "IPython.terminal.pt_inputhooks.asyncio",
     "IPython.terminal.pt_inputhooks.glut",
     "IPython.terminal.pt_inputhooks.gtk",
     "IPython.terminal.pt_inputhooks.gtk3",
     "IPython.terminal.pt_inputhooks.gtk4",
     "IPython.terminal.pt_inputhooks.osx",
     "IPython.terminal.pt_inputhooks.pyglet",
     "IPython.terminal.pt_inputhooks.qt",
     "IPython.terminal.pt_inputhooks.tk",
     "IPython.terminal.pt_inputhooks.wx",
     "IPython.terminal.ptutils",
     "IPython.terminal.shortcuts",
     "IPython.terminal.shortcuts.auto_match",
     "IPython.terminal.shortcuts.auto_suggest",
     "IPython.terminal.shortcuts.filters",
     "IPython.utils._process_cli",
     "IPython.utils._process_common",
     "IPython.utils._process_emscripten",
     "IPython.utils._process_posix",
     "IPython.utils.capture",
     "IPython.utils.coloransi",
     "IPython.utils.contexts",
     "IPython.utils.data",
     "IPython.utils.decorators",
     "IPython.utils.dir2",
     "IPython.utils.encoding",
     "IPython.utils.frame",
     "IPython.utils.generics",
     "IPython.utils.importstring",
     "IPython.utils.io",
     "IPython.utils.ipstruct",
     "IPython.utils.module_paths",
     "IPython.utils.openpy",
     "IPython.utils.process",
     "IPython.utils.py3compat",
     "IPython.utils.sentinel",
     "IPython.utils.shimmodule",
     "IPython.utils.strdispatch",
     "IPython.utils.sysinfo",
     "IPython.utils.syspathcontext",
     "IPython.utils.tempdir",
     "IPython.utils.terminal",
     "IPython.utils.timing",
     "IPython.utils.tokenutil",
     "IPython.utils.tz",
     "IPython.utils.ulinecache",
     "IPython.utils.version",
     "IPython.utils.wildcard",
 
 ]
 disallow_untyped_defs = false
 ignore_errors = true
 ignore_missing_imports = true
 disallow_untyped_calls = false
 disallow_incomplete_defs = false
 check_untyped_defs = false
 disallow_untyped_decorators = false
 
 [tool.pytest.ini_options]
 addopts = [
    "--durations=10",
    "-pIPython.testing.plugin.pytest_ipdoctest",
    "--ipdoctest-modules",
    "--ignore=docs",
    "--ignore=examples",
    "--ignore=htmlcov",
    "--ignore=ipython_kernel",
    "--ignore=ipython_parallel",
    "--ignore=results",
    "--ignore=tmp",
    "--ignore=tools",
    "--ignore=traitlets",
    "--ignore=IPython/core/tests/daft_extension",
    "--ignore=IPython/sphinxext",
    "--ignore=IPython/terminal/pt_inputhooks",
    "--ignore=IPython/__main__.py",
    "--ignore=IPython/external/qt_for_kernel.py",
    "--ignore=IPython/html/widgets/widget_link.py",
    "--ignore=IPython/html/widgets/widget_output.py",
    "--ignore=IPython/terminal/console.py",
    "--ignore=IPython/utils/_process_cli.py",
    "--ignore=IPython/utils/_process_posix.py",
    "--ignore=IPython/utils/_process_win32.py",
    "--ignore=IPython/utils/_process_win32_controller.py",
    "--ignore=IPython/utils/daemonize.py",
    "--ignore=IPython/utils/eventful.py",
    "--ignore=IPython/kernel",
    "--ignore=IPython/consoleapp.py",
    "--ignore=IPython/core/inputsplitter.py",
    "--ignore=IPython/lib/kernel.py",
    "--ignore=IPython/utils/jsonutil.py",
    "--ignore=IPython/utils/localinterfaces.py",
    "--ignore=IPython/utils/log.py",
    "--ignore=IPython/utils/signatures.py",
    "--ignore=IPython/utils/traitlets.py",
    "--ignore=IPython/utils/version.py"
 ]
 doctest_optionflags = [
    "NORMALIZE_WHITESPACE",
    "ELLIPSIS"
 ]
 ipdoctest_optionflags = [
    "NORMALIZE_WHITESPACE",
    "ELLIPSIS"
 ]
 asyncio_mode = "strict"
 
 [tool.pyright]
 pythonPlatform="All"
 
 [tool.setuptools]
 zip-safe = false
 platforms = ["Linux", "Mac OSX", "Windows"]
 license-files = ["LICENSE"]
 include-package-data = false
 
 [tool.setuptools.packages.find]
 exclude = ["setupext"]
 namespaces = false
 
 [tool.setuptools.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"]
 
 [tool.setuptools.dynamic]
 version = {attr = "IPython.core.release.__version__"}
 
 [tool.coverage.run]
 omit = [
     # omit everything in /tmp as we run tempfile
     "/tmp/*",
     ]