Repository: ipython/ipython

Issue:
Default value in docs for TerminalInteractiveShell.simple_prompt is incorrect
The default value for `TerminalInteractiveShell.simple_prompt` per the [docs](https://ipython.readthedocs.io/en/stable/config/options/terminal.html#configtrait-TerminalInteractiveShell.simple_prompt) is `True` yet when one produces the default profile `ipython_config.py` the comments imply the default value is `False`.

In addition, the statement "and emacs inferior-shell integration through elpy." should be re-worded to "and emacs inferior-python integration." as "inferior" here in Emacs parlance just means the process is a subprocess but the process here is the ipython/python interpreter and it is also *not just* applicable through Elpy as it can be used ~~within~~ without Elpy. The 'inferior-shell' refers to the subprocess when using the Emacs built-in shell (M-x shell).

I would submit a PR but it is unclear to me if I would have to make changes in [all these places](https://github.com/search?q=repo%3Aipython%2Fipython%20TerminalInteractiveShell.simple_prompt&type=code).

Edit: changed within for without

Discussion:

Patch:
diff --git a/IPython/core/debugger.py b/IPython/core/debugger.py
index 59cf24c6a..4e4b17a94 100644
--- a/IPython/core/debugger.py
+++ b/IPython/core/debugger.py
@@ -149,17 +149,6 @@ def make_arrow(pad):
     return ''
 
 
-def BdbQuit_excepthook(et, ev, tb, excepthook=None):
-    """Exception hook which handles `BdbQuit` exceptions.
-
-    All other exceptions are processed using the `excepthook`
-    parameter.
-    """
-    raise ValueError(
-        "`BdbQuit_excepthook` is deprecated since version 5.1. It is still arround only because it is still imported by ipdb.",
-    )
-
-
 RGX_EXTRA_INDENT = re.compile(r'(?<=\n)\s+')
 
 
diff --git a/IPython/core/display_functions.py b/IPython/core/display_functions.py
index 3851634b1..567cf3fa6 100644
--- a/IPython/core/display_functions.py
+++ b/IPython/core/display_functions.py
@@ -111,7 +111,7 @@ def display(
     display_id=None,
     raw=False,
     clear=False,
-    **kwargs,
+    **kwargs
 ):
     """Display a Python object in all frontends.
 
diff --git a/IPython/core/interactiveshell.py b/IPython/core/interactiveshell.py
index e9e649345..12c120625 100644
--- a/IPython/core/interactiveshell.py
+++ b/IPython/core/interactiveshell.py
@@ -3654,17 +3654,10 @@ def enable_matplotlib(self, gui=None):
             make sense in all contexts, for example a terminal ipython can't
             display figures inline.
         """
-        from .pylabtools import _matplotlib_manages_backends
-
-        if not _matplotlib_manages_backends() and gui in (None, "auto"):
-            # Early import of backend_inline required for its side effect of
-            # calling _enable_matplotlib_integration()
-            import matplotlib_inline.backend_inline
-
         from IPython.core import pylabtools as pt
         gui, backend = pt.find_gui_and_backend(gui, self.pylab_gui_select)
 
-        if gui != None:
+        if gui != 'inline':
             # If we have our first gui selection, store it
             if self.pylab_gui_select is None:
                 self.pylab_gui_select = gui
diff --git a/IPython/core/magics/pylab.py b/IPython/core/magics/pylab.py
index 265f86006..2a69453ac 100644
--- a/IPython/core/magics/pylab.py
+++ b/IPython/core/magics/pylab.py
@@ -18,19 +18,19 @@
 from IPython.core.magic import Magics, magics_class, line_magic
 from IPython.testing.skipdoctest import skip_doctest
 from warnings import warn
+from IPython.core.pylabtools import backends
 
 #-----------------------------------------------------------------------------
 # Magic implementation classes
 #-----------------------------------------------------------------------------
 
 magic_gui_arg = magic_arguments.argument(
-    "gui",
-    nargs="?",
-    help="""Name of the matplotlib backend to use such as 'qt' or 'widget'.
+        'gui', nargs='?',
+        help="""Name of the matplotlib backend to use %s.
         If given, the corresponding matplotlib backend is used,
         otherwise it will be matplotlib's default
         (which you can set in your matplotlib config file).
-        """,
+        """ % str(tuple(sorted(backends.keys())))
 )
 
 
@@ -93,12 +93,8 @@ def matplotlib(self, line=''):
         """
         args = magic_arguments.parse_argstring(self.matplotlib, line)
         if args.list:
-            from IPython.core.pylabtools import _list_matplotlib_backends_and_gui_loops
-
-            print(
-                "Available matplotlib backends: %s"
-                % _list_matplotlib_backends_and_gui_loops()
-            )
+            backends_list = list(backends.keys())
+            print("Available matplotlib backends: %s" % backends_list)
         else:
             gui, backend = self.shell.enable_matplotlib(args.gui.lower() if isinstance(args.gui, str) else args.gui)
             self._show_matplotlib_backend(args.gui, backend)
diff --git a/IPython/core/pylabtools.py b/IPython/core/pylabtools.py
index 1f5a11f37..e5715a949 100644
--- a/IPython/core/pylabtools.py
+++ b/IPython/core/pylabtools.py
@@ -12,12 +12,9 @@
 from IPython.core.display import _pngxy
 from IPython.utils.decorators import flag_calls
 
-
-# Matplotlib backend resolution functionality moved from IPython to Matplotlib
-# in IPython 8.24 and Matplotlib 3.9.1. Need to keep `backends` and `backend2gui`
-# here for earlier Matplotlib and for external backend libraries such as
-# mplcairo that might rely upon it.
-_deprecated_backends = {
+# If user specifies a GUI, that dictates the backend, otherwise we read the
+# user's mpl default from the mpl rc structure
+backends = {
     "tk": "TkAgg",
     "gtk": "GTKAgg",
     "gtk3": "GTK3Agg",
@@ -44,44 +41,29 @@
 # GUI support to activate based on the desired matplotlib backend.  For the
 # most part it's just a reverse of the above dict, but we also need to add a
 # few others that map to the same GUI manually:
-_deprecated_backend2gui = dict(
-    zip(_deprecated_backends.values(), _deprecated_backends.keys())
-)
+backend2gui = dict(zip(backends.values(), backends.keys()))
 # In the reverse mapping, there are a few extra valid matplotlib backends that
 # map to the same GUI support
-_deprecated_backend2gui["GTK"] = _deprecated_backend2gui["GTKCairo"] = "gtk"
-_deprecated_backend2gui["GTK3Cairo"] = "gtk3"
-_deprecated_backend2gui["GTK4Cairo"] = "gtk4"
-_deprecated_backend2gui["WX"] = "wx"
-_deprecated_backend2gui["CocoaAgg"] = "osx"
+backend2gui["GTK"] = backend2gui["GTKCairo"] = "gtk"
+backend2gui["GTK3Cairo"] = "gtk3"
+backend2gui["GTK4Cairo"] = "gtk4"
+backend2gui["WX"] = "wx"
+backend2gui["CocoaAgg"] = "osx"
 # There needs to be a hysteresis here as the new QtAgg Matplotlib backend
 # supports either Qt5 or Qt6 and the IPython qt event loop support Qt4, Qt5,
 # and Qt6.
-_deprecated_backend2gui["QtAgg"] = "qt"
-_deprecated_backend2gui["Qt4Agg"] = "qt4"
-_deprecated_backend2gui["Qt5Agg"] = "qt5"
+backend2gui["QtAgg"] = "qt"
+backend2gui["Qt4Agg"] = "qt4"
+backend2gui["Qt5Agg"] = "qt5"
 
 # And some backends that don't need GUI integration
-del _deprecated_backend2gui["nbAgg"]
-del _deprecated_backend2gui["agg"]
-del _deprecated_backend2gui["svg"]
-del _deprecated_backend2gui["pdf"]
-del _deprecated_backend2gui["ps"]
-del _deprecated_backend2gui["module://matplotlib_inline.backend_inline"]
-del _deprecated_backend2gui["module://ipympl.backend_nbagg"]
-
-
-# Deprecated attributes backends and backend2gui mostly following PEP 562.
-def __getattr__(name):
-    if name in ("backends", "backend2gui"):
-        warnings.warn(
-            f"{name} is deprecated since IPython 8.24, backends are managed "
-            "in matplotlib and can be externally registered.",
-            DeprecationWarning,
-        )
-        return globals()[f"_deprecated_{name}"]
-    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
-
+del backend2gui["nbAgg"]
+del backend2gui["agg"]
+del backend2gui["svg"]
+del backend2gui["pdf"]
+del backend2gui["ps"]
+del backend2gui["module://matplotlib_inline.backend_inline"]
+del backend2gui["module://ipympl.backend_nbagg"]
 
 #-----------------------------------------------------------------------------
 # Matplotlib utilities
@@ -285,7 +267,7 @@ def select_figure_formats(shell, formats, **kwargs):
 
     [ f.pop(Figure, None) for f in shell.display_formatter.formatters.values() ]
     mplbackend = matplotlib.get_backend().lower()
-    if mplbackend in ("nbagg", "ipympl", "widget", "module://ipympl.backend_nbagg"):
+    if mplbackend == 'nbagg' or mplbackend == 'module://ipympl.backend_nbagg':
         formatter = shell.display_formatter.ipython_display_formatter
         formatter.for_type(Figure, _reshow_nbagg_figure)
 
@@ -337,23 +319,7 @@ def find_gui_and_backend(gui=None, gui_select=None):
 
     import matplotlib
 
-    if _matplotlib_manages_backends():
-        backend_registry = matplotlib.backends.registry.backend_registry
-
-        # gui argument may be a gui event loop or may be a backend name.
-        if gui in ("auto", None):
-            backend = matplotlib.rcParamsOrig["backend"]
-            backend, gui = backend_registry.resolve_backend(backend)
-        else:
-            backend, gui = backend_registry.resolve_gui_or_backend(gui)
-
-        return gui, backend
-
-    # Fallback to previous behaviour (Matplotlib < 3.9)
-    mpl_version_info = getattr(matplotlib, "__version_info__", (0, 0))
-    has_unified_qt_backend = mpl_version_info >= (3, 5)
-
-    from IPython.core.pylabtools import backends
+    has_unified_qt_backend = getattr(matplotlib, "__version_info__", (0, 0)) >= (3, 5)
 
     backends_ = dict(backends)
     if not has_unified_qt_backend:
@@ -372,7 +338,6 @@ def find_gui_and_backend(gui=None, gui_select=None):
         backend = matplotlib.rcParamsOrig['backend']
         # In this case, we need to find what the appropriate gui selection call
         # should be for IPython, so we can activate inputhook accordingly
-        from IPython.core.pylabtools import backend2gui
         gui = backend2gui.get(backend, None)
 
         # If we have already had a gui active, we need it and inline are the
@@ -381,11 +346,6 @@ def find_gui_and_backend(gui=None, gui_select=None):
             gui = gui_select
             backend = backends_[gui]
 
-    # Matplotlib before _matplotlib_manages_backends() can return "inline" for
-    # no gui event loop rather than the None that IPython >= 8.24.0 expects.
-    if gui == "inline":
-        gui = None
-
     return gui, backend
 
 
@@ -471,48 +431,3 @@ def configure_inline_support(shell, backend):
     )
 
     configure_inline_support_orig(shell, backend)
-
-
-# Determine if Matplotlib manages backends only if needed, and cache result.
-# Do not read this directly, instead use _matplotlib_manages_backends().
-_matplotlib_manages_backends_value: bool | None = None
-
-
-def _matplotlib_manages_backends() -> bool:
-    """Return True if Matplotlib manages backends, False otherwise.
-
-    If it returns True, the caller can be sure that
-    matplotlib.backends.registry.backend_registry is available along with
-    member functions resolve_gui_or_backend, resolve_backend, list_all, and
-    list_gui_frameworks.
-    """
-    global _matplotlib_manages_backends_value
-    if _matplotlib_manages_backends_value is None:
-        try:
-            from matplotlib.backends.registry import backend_registry
-
-            _matplotlib_manages_backends_value = hasattr(
-                backend_registry, "resolve_gui_or_backend"
-            )
-        except ImportError:
-            _matplotlib_manages_backends_value = False
-
-    return _matplotlib_manages_backends_value
-
-
-def _list_matplotlib_backends_and_gui_loops() -> list[str]:
-    """Return list of all Matplotlib backends and GUI event loops.
-
-    This is the list returned by
-        %matplotlib --list
-    """
-    if _matplotlib_manages_backends():
-        from matplotlib.backends.registry import backend_registry
-
-        ret = backend_registry.list_all() + backend_registry.list_gui_frameworks()
-    else:
-        from IPython.core import pylabtools
-
-        ret = list(pylabtools.backends.keys())
-
-    return sorted(["auto"] + ret)
diff --git a/IPython/core/shellapp.py b/IPython/core/shellapp.py
index 99d1d8a9f..29325a0ad 100644
--- a/IPython/core/shellapp.py
+++ b/IPython/core/shellapp.py
@@ -11,45 +11,37 @@
 from itertools import chain
 import os
 import sys
-import typing as t
 
 from traitlets.config.application import boolean_flag
 from traitlets.config.configurable import Configurable
 from traitlets.config.loader import Config
 from IPython.core.application import SYSTEM_CONFIG_DIRS, ENV_CONFIG_DIRS
+from IPython.core import pylabtools
 from IPython.utils.contexts import preserve_keys
 from IPython.utils.path import filefind
 from traitlets import (
-    Unicode,
-    Instance,
-    List,
-    Bool,
-    CaselessStrEnum,
-    observe,
+    Unicode, Instance, List, Bool, CaselessStrEnum, observe,
     DottedObjectName,
-    Undefined,
 )
 from IPython.terminal import pt_inputhooks
 
-# -----------------------------------------------------------------------------
+#-----------------------------------------------------------------------------
 # Aliases and Flags
-# -----------------------------------------------------------------------------
+#-----------------------------------------------------------------------------
 
 gui_keys = tuple(sorted(pt_inputhooks.backends) + sorted(pt_inputhooks.aliases))
 
+backend_keys = sorted(pylabtools.backends.keys())
+backend_keys.insert(0, 'auto')
+
 shell_flags = {}
 
 addflag = lambda *args: shell_flags.update(boolean_flag(*args))
-addflag(
-    "autoindent",
-    "InteractiveShell.autoindent",
-    "Turn on autoindenting.",
-    "Turn off autoindenting.",
+addflag('autoindent', 'InteractiveShell.autoindent',
+        'Turn on autoindenting.', 'Turn off autoindenting.'
 )
-addflag(
-    "automagic",
-    "InteractiveShell.automagic",
-    """Turn on the auto calling of magic commands. Type %%magic at the
+addflag('automagic', 'InteractiveShell.automagic',
+        """Turn on the auto calling of magic commands. Type %%magic at the
         IPython  prompt  for  more information.""",
         'Turn off the auto calling of magic commands.'
 )
@@ -105,37 +97,6 @@
 )
 shell_aliases['cache-size'] = 'InteractiveShell.cache_size'
 
-
-# -----------------------------------------------------------------------------
-# Traitlets
-# -----------------------------------------------------------------------------
-
-
-class MatplotlibBackendCaselessStrEnum(CaselessStrEnum):
-    """An enum of Matplotlib backend strings where the case should be ignored.
-
-    Prior to Matplotlib 3.9.1 the list of valid backends is hardcoded in
-    pylabtools.backends. After that, Matplotlib manages backends.
-
-    The list of valid backends is determined when it is first needed to avoid
-    wasting unnecessary initialisation time.
-    """
-
-    def __init__(
-        self: CaselessStrEnum[t.Any],
-        default_value: t.Any = Undefined,
-        **kwargs: t.Any,
-    ) -> None:
-        super().__init__(None, default_value=default_value, **kwargs)
-
-    def __getattribute__(self, name):
-        if name == "values" and object.__getattribute__(self, name) is None:
-            from IPython.core.pylabtools import _list_matplotlib_backends_and_gui_loops
-
-            self.values = _list_matplotlib_backends_and_gui_loops()
-        return object.__getattribute__(self, name)
-
-
 #-----------------------------------------------------------------------------
 # Main classes and functions
 #-----------------------------------------------------------------------------
@@ -195,31 +156,30 @@ class InteractiveShellApp(Configurable):
     exec_lines = List(Unicode(),
         help="""lines of code to run at IPython startup."""
     ).tag(config=True)
-    code_to_run = Unicode("", help="Execute the given command string.").tag(config=True)
-    module_to_run = Unicode("", help="Run the module as a script.").tag(config=True)
-    gui = CaselessStrEnum(
-        gui_keys,
-        allow_none=True,
-        help="Enable GUI event loop integration with any of {0}.".format(gui_keys),
+    code_to_run = Unicode('',
+        help="Execute the given command string."
+    ).tag(config=True)
+    module_to_run = Unicode('',
+        help="Run the module as a script."
     ).tag(config=True)
-    matplotlib = MatplotlibBackendCaselessStrEnum(
-        allow_none=True,
+    gui = CaselessStrEnum(gui_keys, allow_none=True,
+        help="Enable GUI event loop integration with any of {0}.".format(gui_keys)
+    ).tag(config=True)
+    matplotlib = CaselessStrEnum(backend_keys, allow_none=True,
         help="""Configure matplotlib for interactive use with
-        the default matplotlib backend.""",
+        the default matplotlib backend."""
     ).tag(config=True)
-    pylab = MatplotlibBackendCaselessStrEnum(
-        allow_none=True,
+    pylab = CaselessStrEnum(backend_keys, allow_none=True,
         help="""Pre-load matplotlib and numpy for interactive use,
         selecting a particular matplotlib backend and loop integration.
-        """,
+        """
     ).tag(config=True)
-    pylab_import_all = Bool(
-        True,
+    pylab_import_all = Bool(True,
         help="""If true, IPython will populate the user namespace with numpy, pylab, etc.
         and an ``import *`` is done from numpy and pylab, when using pylab mode.
 
         When False, pylab mode should not import any names into the user namespace.
-        """,
+        """
     ).tag(config=True)
     ignore_cwd = Bool(
         False,
diff --git a/IPython/terminal/embed.py b/IPython/terminal/embed.py
index d46fa7441..59fa61067 100644
--- a/IPython/terminal/embed.py
+++ b/IPython/terminal/embed.py
@@ -197,7 +197,7 @@ def __call__(
         dummy=None,
         stack_depth=1,
         compile_flags=None,
-        **kw,
+        **kw
     ):
         """Activate the interactive interpreter.
 
diff --git a/IPython/terminal/interactiveshell.py b/IPython/terminal/interactiveshell.py
index 4b930e40a..bc21e4e74 100644
--- a/IPython/terminal/interactiveshell.py
+++ b/IPython/terminal/interactiveshell.py
@@ -225,11 +225,14 @@ class TerminalInteractiveShell(InteractiveShell):
         help="""Use `raw_input` for the REPL, without completion and prompt colors.
 
             Useful when controlling IPython as a subprocess, and piping STDIN/OUT/ERR. Known usage are:
-            IPython own testing machinery, and emacs inferior-shell integration through elpy.
+            IPython own testing machinery, and emacs inferior-python integration through elpy.
 
             This mode default to `True` if the `IPY_TEST_SIMPLE_PROMPT`
-            environment variable is set, or the current terminal is not a tty."""
-            ).tag(config=True)
+            environment variable is set, or the current terminal is not a tty.
+            Thus the Default value reported in --help-all, or config will often
+            be incorrectly reported.
+            """,
+    ).tag(config=True)
 
     @property
     def debugger_cls(self):
@@ -966,7 +969,7 @@ def enable_gui(self, gui: Optional[str] = None) -> None:
         if self._inputhook is not None and gui is None:
             self.active_eventloop = self._inputhook = None
 
-        if gui and (gui not in {None, "webagg"}):
+        if gui and (gui not in {"inline", "webagg"}):
             # This hook runs with each cycle of the `prompt_toolkit`'s event loop.
             self.active_eventloop, self._inputhook = get_inputhook_name_and_func(gui)
         else:
diff --git a/IPython/utils/coloransi.py b/IPython/utils/coloransi.py
index ef2dbcb09..b41f23008 100644
--- a/IPython/utils/coloransi.py
+++ b/IPython/utils/coloransi.py
@@ -69,33 +69,34 @@ class TermColors:
 
     NoColor = ''  # for color schemes in color-less terminals.
     Normal = '\033[0m'   # Reset normal coloring
-
-    Black = "\033[0;30m"
-    Red = "\033[0;31m"
-    Green = "\033[0;32m"
-    Brown = "\033[0;33m"
-    Blue = "\033[0;34m"
-    Purple = "\033[0;35m"
-    Cyan = "\033[0;36m"
-    LightGray = "\033[0;37m"
+    _base  = '\033[%sm'  # Template for all other colors
+
+    Black = "0;30"
+    Red = "0;31"
+    Green = "0;32"
+    Brown = "0;33"
+    Blue = "0;34"
+    Purple = "0;35"
+    Cyan = "0;36"
+    LightGray = "0;37"
     # Light colors
-    DarkGray = "\033[1;30m"
-    LightRed = "\033[1;31m"
-    LightGreen = "\033[1;32m"
-    Yellow = "\033[1;33m"
-    LightBlue = "\033[1;34m"
-    LightPurple = "\033[1;35m"
-    LightCyan = "\033[1;36m"
-    White = "\033[1;37m"
+    DarkGray = "1;31"
+    LightRed = "1;32"
+    LightGreen = "1;33"
+    Yellow = "1;34"
+    LightBlue = "1;35"
+    LightPurple = "1;36"
+    LightCyan = "1;37"
+    White = "1;38"
     # Blinking colors.  Probably should not be used in anything serious.
-    BlinkBlack = "\033[5;30m"
-    BlinkRed = "\033[5;31m"
-    BlinkGreen = "\033[5;32m"
-    BlinkYellow = "\033[5;33m"
-    BlinkBlue = "\033[5;34m"
-    BlinkPurple = "\033[5;35m"
-    BlinkCyan = "\033[5;36m"
-    BlinkLightGray = "\033[5;37m"
+    BlinkBlack = "5;30"
+    BlinkRed = "5;31"
+    BlinkGreen = "5;32"
+    BlinkYellow = "5;33"
+    BlinkBlue = "5;34"
+    BlinkPurple = "5;35"
+    BlinkCyan = "5;36"
+    BlinkLightGray = "5;37"
 
 
 


Test patch:
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 1935286a8..90da8998e 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -49,11 +49,6 @@ jobs:
           - os: macos-latest
             python-version: "pypy-3.10"
             deps: test
-          # Temporary CI run to use entry point compatible code in matplotlib-inline.
-          - os: ubuntu-latest
-            python-version: "3.12"
-            deps: test_extra
-            want-latest-entry-point-code: true
 
     steps:
     - uses: actions/checkout@v3
@@ -87,16 +82,6 @@ jobs:
     - name: Check manifest
       if: runner.os != 'Windows'  # setup.py does not support sdist on Windows
       run: check-manifest
-
-    - name: Install entry point compatible code (TEMPORARY)
-      if: matrix.want-latest-entry-point-code
-      run: |
-        python -m pip list
-        # Not installing matplotlib's entry point code as building matplotlib from source is complex.
-        # Rely upon matplotlib to test all the latest entry point branches together.
-        python -m pip install --upgrade git+https://github.com/ipython/matplotlib-inline.git@main
-        python -m pip list
-
     - name: pytest
       env:
         COLUMNS: 120
diff --git a/IPython/core/tests/test_pylabtools.py b/IPython/core/tests/test_pylabtools.py
index 2ac9d60dd..a06ad4875 100644
--- a/IPython/core/tests/test_pylabtools.py
+++ b/IPython/core/tests/test_pylabtools.py
@@ -199,7 +199,7 @@ def test_qt(self):
         assert s.pylab_gui_select == "qt"
 
         gui, backend = s.enable_matplotlib("inline")
-        assert gui is None
+        assert gui == "inline"
         assert s.pylab_gui_select == "qt"
 
         gui, backend = s.enable_matplotlib("qt")
@@ -207,7 +207,7 @@ def test_qt(self):
         assert s.pylab_gui_select == "qt"
 
         gui, backend = s.enable_matplotlib("inline")
-        assert gui is None
+        assert gui == "inline"
         assert s.pylab_gui_select == "qt"
 
         gui, backend = s.enable_matplotlib()
@@ -217,11 +217,11 @@ def test_qt(self):
     def test_inline(self):
         s = self.Shell()
         gui, backend = s.enable_matplotlib("inline")
-        assert gui is None
+        assert gui == "inline"
         assert s.pylab_gui_select == None
 
         gui, backend = s.enable_matplotlib("inline")
-        assert gui is None
+        assert gui == "inline"
         assert s.pylab_gui_select == None
 
         gui, backend = s.enable_matplotlib("qt")
@@ -233,14 +233,14 @@ def test_inline_twice(self):
 
         ip = self.Shell()
         gui, backend = ip.enable_matplotlib("inline")
-        assert gui is None
+        assert gui == "inline"
 
         fmts =  {'png'}
         active_mimes = {_fmt_mime_map[fmt] for fmt in fmts}
         pt.select_figure_formats(ip, fmts)
 
         gui, backend = ip.enable_matplotlib("inline")
-        assert gui is None
+        assert gui == "inline"
 
         for mime, f in ip.display_formatter.formatters.items():
             if mime in active_mimes:
@@ -254,7 +254,7 @@ def test_qt_gtk(self):
         assert gui == "qt"
         assert s.pylab_gui_select == "qt"
 
-        gui, backend = s.enable_matplotlib("gtk3")
+        gui, backend = s.enable_matplotlib("gtk")
         assert gui == "qt"
         assert s.pylab_gui_select == "qt"
 
@@ -268,87 +268,3 @@ def test_figure_no_canvas():
     fig = Figure()
     fig.canvas = None
     pt.print_figure(fig)
-
-
-@pytest.mark.parametrize(
-    "name, expected_gui, expected_backend",
-    [
-        # name is gui
-        ("gtk3", "gtk3", "gtk3agg"),
-        ("gtk4", "gtk4", "gtk4agg"),
-        ("headless", "headless", "agg"),
-        ("osx", "osx", "macosx"),
-        ("qt", "qt", "qtagg"),
-        ("qt5", "qt5", "qt5agg"),
-        ("qt6", "qt6", "qt6agg"),
-        ("tk", "tk", "tkagg"),
-        ("wx", "wx", "wxagg"),
-        # name is backend
-        ("agg", None, "agg"),
-        ("cairo", None, "cairo"),
-        ("pdf", None, "pdf"),
-        ("ps", None, "ps"),
-        ("svg", None, "svg"),
-        ("template", None, "template"),
-        ("gtk3agg", "gtk3", "gtk3agg"),
-        ("gtk3cairo", "gtk3", "gtk3cairo"),
-        ("gtk4agg", "gtk4", "gtk4agg"),
-        ("gtk4cairo", "gtk4", "gtk4cairo"),
-        ("macosx", "osx", "macosx"),
-        ("nbagg", "nbagg", "nbagg"),
-        ("notebook", "nbagg", "notebook"),
-        ("qtagg", "qt", "qtagg"),
-        ("qtcairo", "qt", "qtcairo"),
-        ("qt5agg", "qt5", "qt5agg"),
-        ("qt5cairo", "qt5", "qt5cairo"),
-        ("qt6agg", "qt", "qt6agg"),
-        ("qt6cairo", "qt", "qt6cairo"),
-        ("tkagg", "tk", "tkagg"),
-        ("tkcairo", "tk", "tkcairo"),
-        ("webagg", "webagg", "webagg"),
-        ("wxagg", "wx", "wxagg"),
-        ("wxcairo", "wx", "wxcairo"),
-    ],
-)
-def test_backend_builtin(name, expected_gui, expected_backend):
-    # Test correct identification of Matplotlib built-in backends without importing and using them,
-    # otherwise we would need to ensure all the complex dependencies such as windowing toolkits are
-    # installed.
-
-    mpl_manages_backends = pt._matplotlib_manages_backends()
-    if not mpl_manages_backends:
-        # Backends not supported before _matplotlib_manages_backends or supported
-        # but with different expected_gui or expected_backend.
-        if (
-            name.endswith("agg")
-            or name.endswith("cairo")
-            or name in ("headless", "macosx", "pdf", "ps", "svg", "template")
-        ):
-            pytest.skip()
-        elif name == "qt6":
-            expected_backend = "qtagg"
-        elif name == "notebook":
-            expected_backend, expected_gui = expected_gui, expected_backend
-
-    gui, backend = pt.find_gui_and_backend(name)
-    if not mpl_manages_backends:
-        gui = gui.lower() if gui else None
-        backend = backend.lower() if backend else None
-    assert gui == expected_gui
-    assert backend == expected_backend
-
-
-def test_backend_entry_point():
-    gui, backend = pt.find_gui_and_backend("inline")
-    assert gui is None
-    expected_backend = (
-        "inline"
-        if pt._matplotlib_manages_backends()
-        else "module://matplotlib_inline.backend_inline"
-    )
-    assert backend == expected_backend
-
-
-def test_backend_unknown():
-    with pytest.raises(RuntimeError if pt._matplotlib_manages_backends() else KeyError):
-        pt.find_gui_and_backend("name-does-not-exist")