ipython 9.11.0__tar.gz → 9.13.0__tar.gz

{ipython-9.11.0 → ipython-9.13.0}/IPython/__init__.py

@@ -27,11 +27,10 @@ import warnings
 #-----------------------------------------------------------------------------
 
 # Don't forget to also update setup.py when this changes!
-if sys.version_info < (3, 12):
+if sys.version_info < (3, 11):
     raise ImportError(
         """
-IPython 9.x supports Python 3.12 and above, following SPEC0
-IPython 8.31+ supports Python 3.11 and above, following SPEC0
+IPython 9.x supports Python 3.11 and above, following SPEC0
 IPython 8.19+ supports Python 3.10 and above, following SPEC0.
 IPython 8.13+ supports Python 3.9 and above, following NEP 29.
 When using Python 2.7, please install IPython 5.x LTS Long Term Support version.

{ipython-9.11.0 → ipython-9.13.0}/IPython/core/alias.py

@@ -219,7 +219,7 @@ class AliasManager(Configurable):
             self.soft_define_alias(name, cmd)
 
     @property
-    def aliases(self):
+    def aliases(self) -> list:
         return [(n, func.cmd) for (n, func) in self.linemagics.items()
                             if isinstance(func, Alias)]
 

{ipython-9.11.0 → ipython-9.13.0}/IPython/core/application.py

@@ -33,10 +33,11 @@ from traitlets import (
 )
 
 if os.name == "nt":
+    # %PROGRAMDATA% is not safe by default, require opt-in to trust it
     programdata = os.environ.get("PROGRAMDATA", None)
-    if programdata is not None:
+    if os.environ.get("IPYTHON_USE_PROGRAMDATA") == "1" and programdata is not None:
         SYSTEM_CONFIG_DIRS = [str(Path(programdata) / "ipython")]
-    else:  # PROGRAMDATA is not defined by default on XP.
+    else:
         SYSTEM_CONFIG_DIRS = []
 else:
     SYSTEM_CONFIG_DIRS = [

{ipython-9.11.0 → ipython-9.13.0}/IPython/core/compilerop.py

@@ -51,7 +51,7 @@ PyCF_MASK = functools.reduce(operator.or_,
 # Local utilities
 #-----------------------------------------------------------------------------
 
-def code_name(code, number=0):
+def code_name(code, number=0) -> str:
     """ Compute a (probably) unique name for code for caching.
 
     This now expects code to be unicode.
@@ -116,7 +116,7 @@ class CachingCompiler(codeop.Compile):
         """
         return code_name(transformed_code, number)
 
-    def format_code_name(self, name):
+    def format_code_name(self, name) -> str:
         """Return a user-friendly label and name for a code block.
 
         Parameters

{ipython-9.11.0 → ipython-9.13.0}/IPython/core/completer.py

@@ -243,7 +243,11 @@ import __main__
 
 from typing import cast
 
-from typing import TypedDict, NotRequired, Protocol, TypeAlias, TypeGuard
+if sys.version_info < (3, 12):
+    from typing_extensions import TypedDict, Protocol
+    from typing import NotRequired, TypeAlias, TypeGuard
+else:
+    from typing import TypedDict, NotRequired, Protocol, TypeAlias, TypeGuard
 
 
 # skip module docstests

{ipython-9.11.0 → ipython-9.13.0}/IPython/core/debugger.py

@@ -444,7 +444,7 @@ class Pdb(OldPdb):
                         self.message(
                             f"More than {self.MAX_CHAINED_EXCEPTION_DEPTH}"
                             " chained exceptions found, not all exceptions"
-                            "will be browsable with `exceptions`."
+                            " will be browsable with `exceptions`."
                         )
                         break
             else:
@@ -874,9 +874,9 @@ class Pdb(OldPdb):
             try:
                 x = eval(arg, {}, {})
                 if type(x) == type(()):
-                    first, last = x
-                    first = int(first)
-                    last = int(last)
+                    first, last = x  # type: ignore[misc]
+                    first = int(first)  # type: ignore[call-overload]
+                    last = int(last)  # type: ignore[call-overload]
                     if last < first:
                         # Assume it's a count
                         last = first + last

{ipython-9.11.0 → ipython-9.13.0}/IPython/core/guarded_eval.py

@@ -32,7 +32,10 @@ from IPython.utils.decorators import undoc
 import types
 from typing import Self, LiteralString, get_type_hints
 
-from typing import TypeAliasType
+if sys.version_info < (3, 12):
+    from typing_extensions import TypeAliasType
+else:
+    from typing import TypeAliasType
 
 
 @undoc

{ipython-9.11.0 → ipython-9.13.0}/IPython/core/history.py

@@ -10,6 +10,7 @@ import atexit
 import datetime
 import os
 import re
+import weakref
 
 
 import threading
@@ -322,12 +323,14 @@ class HistoryAccessor(HistoryAccessorBase):
         """Connect to the database, and create tables if necessary."""
         if not self.enabled:
             self.db = DummyDB()
+            self._finalizer = weakref.finalize(self, lambda db: db.close(), self.db)
             return
 
         # use detect_types so that timestamps return datetime objects
         kwargs = dict(detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES)
         kwargs.update(self.connection_options)
         self.db = sqlite3.connect(str(self.hist_file), **kwargs)  # type: ignore [call-overload]
+        self._finalizer = weakref.finalize(self, lambda db: db.close(), self.db)
         with self.db:
             self.db.execute(
                 """CREATE TABLE IF NOT EXISTS sessions (session integer
@@ -349,10 +352,6 @@ class HistoryAccessor(HistoryAccessorBase):
         # success! reset corrupt db count
         self._corrupt_db_counter = 0
 
-    def __del__(self) -> None:
-        if hasattr(self, "db"):
-            self.db.close()
-
     def writeout_cache(self) -> None:
         """Overridden by HistoryManager to dump the cache before certain
         database lookups."""
@@ -721,7 +720,6 @@ class HistoryManager(HistoryAccessor):
     def __del__(self) -> None:
         if self.save_thread is not None:
             self.save_thread.stop()
-        HistoryAccessor.__del__(self)
 
     @classmethod
     def _stop_thread(cls) -> None:

{ipython-9.11.0 → ipython-9.13.0}/IPython/core/historyapp.py

@@ -50,27 +50,26 @@ class HistoryTrim(BaseIPythonApplication):
     def start(self):
         profile_dir = Path(self.profile_dir.location)
         hist_file = profile_dir / "history.sqlite"
-        con = sqlite3.connect(hist_file)
-
-        # Grab the recent history from the current database.
-        inputs = list(con.execute('SELECT session, line, source, source_raw FROM '
-                                'history ORDER BY session DESC, line DESC LIMIT ?', (self.keep+1,)))
-        if len(inputs) <= self.keep:
-            print("There are already at most %d entries in the history database." % self.keep)
-            print("Not doing anything. Use --keep= argument to keep fewer entries")
-            return
-
-        print("Trimming history to the most recent %d entries." % self.keep)
-
-        inputs.pop() # Remove the extra element we got to check the length.
-        inputs.reverse()
-        if inputs:
-            first_session = inputs[0][0]
-            outputs = list(con.execute('SELECT session, line, output FROM '
-                                       'output_history WHERE session >= ?', (first_session,)))
-            sessions = list(con.execute('SELECT session, start, end, num_cmds, remark FROM '
-                                        'sessions WHERE session >= ?', (first_session,)))
-        con.close()
+        with sqlite3.connect(hist_file) as con:
+
+            # Grab the recent history from the current database.
+            inputs = list(con.execute('SELECT session, line, source, source_raw FROM '
+                                    'history ORDER BY session DESC, line DESC LIMIT ?', (self.keep+1,)))
+            if len(inputs) <= self.keep:
+                print("There are already at most %d entries in the history database." % self.keep)
+                print("Not doing anything. Use --keep= argument to keep fewer entries")
+                return
+
+            print("Trimming history to the most recent %d entries." % self.keep)
+
+            inputs.pop() # Remove the extra element we got to check the length.
+            inputs.reverse()
+            if inputs:
+                first_session = inputs[0][0]
+                outputs = list(con.execute('SELECT session, line, output FROM '
+                                        'output_history WHERE session >= ?', (first_session,)))
+                sessions = list(con.execute('SELECT session, start, end, num_cmds, remark FROM '
+                                            'sessions WHERE session >= ?', (first_session,)))
 
         # Create the new history database.
         new_hist_file = profile_dir / "history.sqlite.new"
@@ -79,26 +78,25 @@ class HistoryTrim(BaseIPythonApplication):
             # Make sure we don't interfere with an existing file.
             i += 1
             new_hist_file = profile_dir / ("history.sqlite.new" + str(i))
-        new_db = sqlite3.connect(new_hist_file)
-        new_db.execute("""CREATE TABLE IF NOT EXISTS sessions (session integer
-                            primary key autoincrement, start timestamp,
-                            end timestamp, num_cmds integer, remark text)""")
-        new_db.execute("""CREATE TABLE IF NOT EXISTS history
-                        (session integer, line integer, source text, source_raw text,
-                        PRIMARY KEY (session, line))""")
-        new_db.execute("""CREATE TABLE IF NOT EXISTS output_history
-                        (session integer, line integer, output text,
-                        PRIMARY KEY (session, line))""")
-        new_db.commit()
-
-
-        if inputs:
-            with new_db:
-                # Add the recent history into the new database.
-                new_db.executemany('insert into sessions values (?,?,?,?,?)', sessions)
-                new_db.executemany('insert into history values (?,?,?,?)', inputs)
-                new_db.executemany('insert into output_history values (?,?,?)', outputs)
-        new_db.close()
+        with sqlite3.connect(new_hist_file) as new_db:
+            new_db.execute("""CREATE TABLE IF NOT EXISTS sessions (session integer
+                                primary key autoincrement, start timestamp,
+                                end timestamp, num_cmds integer, remark text)""")
+            new_db.execute("""CREATE TABLE IF NOT EXISTS history
+                            (session integer, line integer, source text, source_raw text,
+                            PRIMARY KEY (session, line))""")
+            new_db.execute("""CREATE TABLE IF NOT EXISTS output_history
+                            (session integer, line integer, output text,
+                            PRIMARY KEY (session, line))""")
+            new_db.commit()
+
+
+            if inputs:
+                with new_db:
+                    # Add the recent history into the new database.
+                    new_db.executemany('insert into sessions values (?,?,?,?,?)', sessions)
+                    new_db.executemany('insert into history values (?,?,?,?)', inputs)
+                    new_db.executemany('insert into output_history values (?,?,?)', outputs)
 
         if self.backup:
             i = 1

{ipython-9.11.0 → ipython-9.13.0}/IPython/core/inputtransformer2.py

@@ -356,8 +356,24 @@ class MagicAssign(TokenTransformBase):
 class SystemAssign(TokenTransformBase):
     """Transformer for assignments from system commands (a = !foo)"""
     @classmethod
-    def find(cls, tokens_by_line):
-        """Find the first system assignment (a = !foo) in the cell."""
+    def find_pre_312(cls, tokens_by_line):
+        for line in tokens_by_line:
+            assign_ix = _find_assign_op(line)
+            if (assign_ix is not None) \
+                    and not line[assign_ix].line.strip().startswith('=') \
+                    and (len(line) >= assign_ix + 2) \
+                    and (line[assign_ix + 1].type == tokenize.ERRORTOKEN):
+                ix = assign_ix + 1
+
+                while ix < len(line) and line[ix].type == tokenize.ERRORTOKEN:
+                    if line[ix].string == '!':
+                        return cls(line[ix].start)
+                    elif not line[ix].string.isspace():
+                        break
+                    ix += 1
+
+    @classmethod
+    def find_post_312(cls, tokens_by_line):
         for line in tokens_by_line:
             assign_ix = _find_assign_op(line)
             if (
@@ -369,6 +385,13 @@ class SystemAssign(TokenTransformBase):
             ):
                 return cls(line[assign_ix + 1].start)
 
+    @classmethod
+    def find(cls, tokens_by_line):
+        """Find the first system assignment (a = !foo) in the cell."""
+        if sys.version_info < (3, 12):
+            return cls.find_pre_312(tokens_by_line)
+        return cls.find_post_312(tokens_by_line)
+
     def transform(self, lines: List[str]):
         """Transform a system assignment found by the ``find()`` classmethod.
         """

{ipython-9.11.0 → ipython-9.13.0}/IPython/core/interactiveshell.py

@@ -2140,7 +2140,8 @@ class InteractiveShell(SingletonConfigurable):
         sys.last_type = etype
         sys.last_value = value
         sys.last_traceback = tb
-        sys.last_exc = value
+        if sys.version_info >= (3, 12):
+            sys.last_exc = value
 
         return etype, value, tb
 

ipython-9.13.0/IPython/core/kitty.py

@@ -0,0 +1,73 @@
+# Implements https://sw.kovidgoyal.net/kitty/graphics-protocol/
+
+from base64 import b64encode, b64decode
+import sys
+from typing import Union
+
+def _supports_kitty_graphics() -> bool:
+    import platform
+
+    if platform.system() not in ("Darwin", "Linux"):
+        return False
+
+    if not sys.stdout.isatty():
+        return False
+    # Hardcoding process names instead of using
+    # https://sw.kovidgoyal.net/kitty/graphics-protocol/#querying-support-and-available-transmission-mediums
+    # to avoid startup slowdown
+    supported_terminals = {
+        "ghostty",
+        "iTerm2",
+        "kitty",
+        "konsole",
+        "warp",
+        "wayst",
+        "wezterm-gui",
+    }
+    import psutil
+
+    process = psutil.Process()
+    while process := process.parent():
+        if process.name() in supported_terminals:
+            return True
+    return False
+
+
+supports_kitty_graphics = _supports_kitty_graphics()
+
+
+def png_to_kitty_ansi(png: bytes) -> str:
+    if not png.startswith(b"\x89PNG\r\n\x1a\n"):
+        raise ValueError
+    # This simplicity resembles
+    # https://sw.kovidgoyal.net/kitty/graphics-protocol/#a-minimal-example
+    # but if we need tmux support, we can switch to Unicode like
+    # https://github.com/hzeller/timg/blob/main/src/kitty-canvas.cc
+    result = ["\033_Ga=T,f=100,", "m=1;"]
+    encoded = b64encode(png)
+    for i in range(0, len(encoded), 4096):
+        result.append(encoded[i : i + 4096].decode("ascii"))
+        result.append("\033\\")
+        result.append("\033_G")
+        result.append("m=1;")
+    del result[-2:]
+    result[-3] = "m=0;"
+    return "".join(result)
+
+
+def kitty_png_render(png: Union[bytes, str], _md_dict: object) -> None:
+    if isinstance(png, str):
+        png = png_to_kitty_ansi(b64decode(png))
+    else:
+        png = png_to_kitty_ansi(png)
+    print(png)
+
+
+display_formatter_default_active_types = [
+    "text/plain",
+    *(["image/png"] if supports_kitty_graphics else []),
+]
+
+terminal_default_mime_renderers = {
+    "image/png": kitty_png_render,
+}

{ipython-9.11.0 → ipython-9.13.0}/IPython/core/magics/basic.py

@@ -346,9 +346,19 @@ Currently the magic system has the following functions:""",
 
         Valid modes: Plain, Context, Verbose, Minimal, and Docs.
 
-        If called without arguments, acts as a toggle.
-
-        When in verbose mode the value `--show` (and `--hide`)
+        - ``Plain``: similar to Python's default traceback.
+        - ``Context``: shows several lines of surrounding context for each
+          frame in the traceback.
+        - ``Verbose``: like Context, but also displays local variable values
+          in each frame.
+        - ``Minimal``: shows only the exception type and message, without
+          a traceback.
+        - ``Docs``: a stripped-down version of Verbose, designed for use
+          when running doctests.
+
+        If called without arguments, cycles through the available modes.
+
+        When in verbose mode the value ``--show`` (and ``--hide``)
         will respectively show (or hide) frames with ``__tracebackhide__ =
         True`` value set.
         """

{ipython-9.11.0 → ipython-9.13.0}/IPython/core/release.py

@@ -16,7 +16,7 @@
 # release.  'dev' as a _version_extra string means this is a development
 # version
 _version_major = 9
-_version_minor = 11
+_version_minor = 13
 _version_patch = 0
 _version_extra = ".dev"
 # _version_extra = "b2"

{ipython-9.11.0 → ipython-9.13.0}/IPython/core/tbtools.py

@@ -203,7 +203,7 @@ def _tokens_filename(
             ]
     else:
         name = util_path.compress_user(
-            py3compat.cast_unicode(file, util_path.fs_encoding)
+            py3compat.cast_unicode(file or "", util_path.fs_encoding)
         )
         if lineno is None:
             return [

{ipython-9.11.0 → ipython-9.13.0}/IPython/core/tips.py

@@ -1,5 +1,6 @@
 from datetime import datetime
 import os
+import sys
 from random import choice
 from typing import Any
 
@@ -107,6 +108,11 @@ else:
         ]
     )
 
+if sys.version_info < (3, 12):
+    _tips["random"].append(
+        "IPython support for Python versions outside of SPEC-0 is funded by the D.E. Shaw group: https://deshaw.com"
+    )
+
 # Check if argcomplete is installed and add tip
 try:
     import argcomplete

{ipython-9.11.0 → ipython-9.13.0}/IPython/core/ultratb.py

@@ -539,8 +539,13 @@ class VerboseTB(TBTools):
 
         assert isinstance(frame_info.lineno, int)
         args, varargs, varkw, locals_ = inspect.getargvalues(frame_info.frame)
+        func: str
         if frame_info.executing is not None:
             func = frame_info.executing.code_qualname()
+        elif frame_info.code is not None:
+            func = (
+                getattr(frame_info.code, "co_qualname", None) or frame_info.code.co_name
+            )
         else:
             func = "?"
         if func == "<module>":
@@ -609,12 +614,14 @@ class VerboseTB(TBTools):
         if frame_info._sd is None:
             # fast fallback if file is too long
             assert frame_info.filename is not None
-            level_tokens = [
-                (Token.FilenameEm, util_path.compress_user(frame_info.filename)),
-                (Token, " "),
-                (Token, call),
-                (Token, "\n"),
-            ]
+            level_tokens = (
+                _tokens_filename(True, frame_info.filename, lineno=frame_info.lineno)
+                + [
+                    (Token, ", " if call else ""),
+                    (Token, call),
+                    (Token, "\n"),
+                ]
+            )
 
             _line_format = Parser(theme_name=self._theme_name).format2
             assert isinstance(frame_info.code, types.CodeType)
@@ -810,8 +817,10 @@ class VerboseTB(TBTools):
         after = context // 2
         before = context - after
         if self.has_colors:
-            base_style = theme_table[self._theme_name].as_pygments_style()
-            style = stack_data.style_with_executing_node(base_style, self.tb_highlight)
+            theme = theme_table[self._theme_name]
+            base_style = theme.as_pygments_style()
+            tb_highlight = theme.extra_style.get(Token.TbHighlight, self.tb_highlight)
+            style = stack_data.style_with_executing_node(base_style, tb_highlight)
             formatter = Terminal256Formatter(style=style)
         else:
             formatter = None
@@ -821,10 +830,9 @@ class VerboseTB(TBTools):
             pygments_formatter=formatter,
         )
 
-        # Let's estimate the amount of code we will have to parse/highlight.
+        # Collect traceback frames and their module sizes.
         cf: Optional[TracebackType] = etb
-        max_len = 0
-        tbs = []
+        tbs: list[tuple[TracebackType, int]] = []
         while cf is not None:
             try:
                 mod = inspect.getmodule(cf.tb_frame)
@@ -834,31 +842,58 @@ class VerboseTB(TBTools):
                     if root_name == "IPython":
                         cf = cf.tb_next
                         continue
-                max_len = get_line_number_of_frame(cf.tb_frame)
-
+                frame_len = get_line_number_of_frame(cf.tb_frame)
+                if frame_len == 0:
+                    # File not found or not a .py file (e.g. <string> from
+                    # exec()).  Check if source is actually available; if not,
+                    # force the fast path so that FrameInfo's "Could not get
+                    # source" fallback is rendered.
+                    try:
+                        inspect.getsourcelines(cf.tb_frame)
+                    except OSError:
+                        frame_len = FAST_THRESHOLD + 1
             except OSError:
-                max_len = 0
-            max_len = max(max_len, max_len)
-            tbs.append(cf)
-            cf = getattr(cf, "tb_next", None)
-
-        if max_len > FAST_THRESHOLD:
-            FIs: list[FrameInfo] = []
-            for tb in tbs:
+                frame_len = FAST_THRESHOLD + 1
+            assert cf is not None  # narrowing for mypy; guarded by while condition
+            tbs.append((cf, frame_len))
+            cf = cf.tb_next
+
+        # Group consecutive frames by fast/slow and process each group.
+        # Consecutive slow frames must be processed together so that
+        # stack_data can detect RepeatedFrames (recursion collapsing).
+        FIs: list[FrameInfo] = []
+        i = 0
+        while i < len(tbs):
+            tb, frame_len = tbs[i]
+            if frame_len > FAST_THRESHOLD:
                 frame = tb.tb_frame  # type: ignore[union-attr]
                 lineno = frame.f_lineno
                 code = frame.f_code
                 filename = code.co_filename
-                # TODO: Here we need to use before/after/
                 FIs.append(
                     FrameInfo(
                         "Raw frame", filename, lineno, frame, code, context=context
                     )
                 )
-            return FIs
-        res = list(stack_data.FrameInfo.stack_data(etb, options=options))[tb_offset:]
-        res2 = [FrameInfo._from_stack_data_FrameInfo(r) for r in res]
-        return res2
+                i += 1
+            else:
+                # Collect the consecutive run of slow frames
+                group_start = i
+                while i < len(tbs) and tbs[i][1] <= FAST_THRESHOLD:
+                    i += 1
+                # Build set of frame objects in this group for filtering
+                group_frames = {tbs[j][0].tb_frame for j in range(group_start, i)}
+                # Process via stack_data starting from the first tb in the group
+                for sd_fi in stack_data.FrameInfo.stack_data(
+                    tbs[group_start][0], options=options
+                ):
+                    # stack_data follows tb_next through the full chain,
+                    # including IPython frames we skipped during collection.
+                    # Filter those out, but always keep RepeatedFrames.
+                    if isinstance(sd_fi, stack_data.RepeatedFrames) or sd_fi.frame in group_frames:
+                        FIs.append(FrameInfo._from_stack_data_FrameInfo(sd_fi))
+
+        return FIs
 
     def structured_traceback(
         self,
@@ -961,7 +996,11 @@ class VerboseTB(TBTools):
                 self.pdb.botframe = etb.tb_frame
                 # last_value should be deprecated, but last-exc sometimme not set
                 # please check why later and remove the getattr.
-                exc = getattr(sys, "last_exc", sys.last_value)
+                exc = (
+                    sys.last_value
+                    if sys.version_info < (3, 12)
+                    else getattr(sys, "last_exc", sys.last_value)
+                )  # type: ignore[attr-defined]
                 if exc:
                     self.pdb.interaction(None, exc)
                 else:

{ipython-9.11.0 → ipython-9.13.0}/IPython/terminal/interactiveshell.py

@@ -8,6 +8,10 @@ from typing import Union as UnionType, Optional
 
 from IPython.core.async_helpers import get_asyncio_loop
 from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC
+from IPython.core.kitty import (
+    display_formatter_default_active_types,
+    terminal_default_mime_renderers,
+)
 from IPython.utils.py3compat import input
 from IPython.utils.PyColorize import theme_table
 from IPython.utils.terminal import toggle_set_term_title, set_term_title, restore_term_title
@@ -771,7 +775,12 @@ class TerminalInteractiveShell(InteractiveShell):
             "DisplayFormatter" in config
             and "active_types" in config["DisplayFormatter"]
         ):
-            self.display_formatter.active_types = ["text/plain"]
+            self.display_formatter.active_types = display_formatter_default_active_types
+            if not (
+                "TerminalInteractiveShell" in config
+                and "mime_renderers" in config["TerminalInteractiveShell"]
+            ):
+                self.mime_renderers = terminal_default_mime_renderers
 
     def init_prompt_toolkit_cli(self):
         if self.simple_prompt:

{ipython-9.11.0 → ipython-9.13.0}/IPython/terminal/prompts.py

@@ -1,6 +1,6 @@
 """Terminal input and output prompts."""
 
-from pygments.token import Token
+from pygments.token import _TokenType, Token
 import sys
 
 from IPython.core.displayhook import DisplayHook
@@ -8,10 +8,14 @@ from IPython.core.displayhook import DisplayHook
 from prompt_toolkit.formatted_text import fragment_list_width, PygmentsTokens
 from prompt_toolkit.shortcuts import print_formatted_text
 from prompt_toolkit.enums import EditingMode
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
+
+if TYPE_CHECKING:
+    from IPython.terminal.interactiveshell import TerminalInteractiveShell
 
 
 class Prompts:
-    def __init__(self, shell):
+    def __init__(self, shell: "TerminalInteractiveShell"):
         self.shell = shell
 
     def vi_mode(self):
@@ -84,7 +88,7 @@ class Prompts:
             (Token.Prompt, ('-' * (width - 2)) + '> '),
         ]
 
-    def out_prompt_tokens(self):
+    def out_prompt_tokens(self) -> List[Tuple[_TokenType, str]]:
         return [
             (Token.OutPrompt, 'Out['),
             (Token.OutPromptNum, str(self.shell.execution_count - 1)),
@@ -128,7 +132,7 @@ class RichPromptDisplayHook(DisplayHook):
             else:
                 sys.stdout.write(prompt_txt)
 
-    def write_format_data(self, format_dict, md_dict=None) -> None:
+    def write_format_data(self, format_dict: Dict[str, str], md_dict: Optional[Dict[Any, Any]]=None) -> None:
         assert self.shell is not None
         if self.shell.mime_renderers: